Merge branch 'buffer-pass-clear' into 'master'

render: optionally clear buffer before rendering

See merge request wlroots/wlroots!4518

examples/fullscreen-shell.c

@@ -91,16 +91,14 @@ static void output_handle_frame(struct wl_listener *listener, void *data) {
 	struct wlr_output_state state;
 	wlr_output_state_init(&state);
 	struct wlr_render_pass *pass = wlr_output_begin_render_pass(output->wlr_output, &state, NULL,
-		NULL);
+		&(struct wlr_buffer_pass_options){
+			.clear_buffer = true,
+			.clear_color = { 0.3, 0.3, 0.3, 1.0 },
+	});
 	if (pass == NULL) {
 		return;
 	}
 
-	wlr_render_pass_add_rect(pass, &(struct wlr_render_rect_options){
-		.color = { 0.3, 0.3, 0.3, 1.0 },
-		.box = { .width = width, .height = height },
-	});
-
 	if (output->surface != NULL) {
 		struct render_data rdata = {
 			.output = output->wlr_output,

examples/output-layers.c

@@ -95,11 +95,9 @@ static void output_handle_frame(struct wl_listener *listener, void *data) {
 	wlr_output_effective_resolution(output->wlr_output, &width, &height);
 
 	struct wlr_render_pass *pass = wlr_output_begin_render_pass(output->wlr_output, &output_state,
-		NULL, NULL);
+		NULL, &(struct wlr_buffer_pass_options){
-
+			.clear_buffer = true,
-	wlr_render_pass_add_rect(pass, &(struct wlr_render_rect_options){
+			.clear_color = { 0.3, 0.3, 0.3, 1 },
-		.box = { .width = width, .height = height },
-		.color = { 0.3, 0.3, 0.3, 1 },
 	});
 
 	size_t i = 0;

examples/output-layout.c

@@ -114,11 +114,10 @@ static void output_frame_notify(struct wl_listener *listener, void *data) {
 
 	struct wlr_output_state output_state;
 	wlr_output_state_init(&output_state);
-	struct wlr_render_pass *pass = wlr_output_begin_render_pass(wlr_output, &output_state, NULL, NULL);
+	struct wlr_render_pass *pass = wlr_output_begin_render_pass(wlr_output, &output_state, NULL,
-
+		&(struct wlr_buffer_pass_options){
-	wlr_render_pass_add_rect(pass, &(struct wlr_render_rect_options){
+			.clear_buffer = true,
-		.box = { .width = wlr_output->width, .height = wlr_output->height },
+			.clear_color = { 0.25, 0.25, 0.25, 1 },
-		.color = { 0.25, 0.25, 0.25, 1 },
 	});
 
 	animate_cat(sample, output->output);

examples/pointer.c

@@ -101,10 +101,9 @@ static void output_frame_notify(struct wl_listener *listener, void *data) {
 
 	struct wlr_output_state output_state;
 	wlr_output_state_init(&output_state);
-	struct wlr_render_pass *pass = wlr_output_begin_render_pass(wlr_output, &output_state, NULL, NULL);
+	struct wlr_render_pass *pass = wlr_output_begin_render_pass(wlr_output, &output_state, NULL, &(struct wlr_buffer_pass_options){
-	wlr_render_pass_add_rect(pass, &(struct wlr_render_rect_options){
+		.clear_buffer = true,
-		.box = { .width = wlr_output->width, .height = wlr_output->height },
+		.clear_color = {
-		.color = {
 			state->clear_color[0],
 			state->clear_color[1],
 			state->clear_color[2],

examples/rotation.c

@@ -59,11 +59,10 @@ static void output_frame_notify(struct wl_listener *listener, void *data) {
 
 	struct wlr_output_state output_state;
 	wlr_output_state_init(&output_state);
-	struct wlr_render_pass *pass = wlr_output_begin_render_pass(wlr_output, &output_state, NULL, NULL);
+	struct wlr_render_pass *pass = wlr_output_begin_render_pass(wlr_output, &output_state, NULL,
-
+		&(struct wlr_buffer_pass_options){
-	wlr_render_pass_add_rect(pass, &(struct wlr_render_rect_options){
+			.clear_buffer = true,
-		.box = { .width = wlr_output->width, .height = wlr_output->height },
+			.clear_color = { 0.25, 0.25, 0.25, 1 },
-		.color = { 0.25, 0.25, 0.25, 1 },
 	});
 
 	for (int y = -128 + (int)sample_output->y_offs; y < height; y += 128) {

examples/simple.c

@@ -63,10 +63,9 @@ static void output_frame_notify(struct wl_listener *listener, void *data) {
 
 	struct wlr_output_state state;
 	wlr_output_state_init(&state);
-	struct wlr_render_pass *pass = wlr_output_begin_render_pass(wlr_output, &state, NULL, NULL);
+	struct wlr_render_pass *pass = wlr_output_begin_render_pass(wlr_output, &state, NULL, &(struct wlr_buffer_pass_options){
-	wlr_render_pass_add_rect(pass, &(struct wlr_render_rect_options){
+		.clear_buffer = true,
-		.box = { .width = wlr_output->width, .height = wlr_output->height },
+		.clear_color = {
-		.color = {
 			.r = sample->color[0],
 			.g = sample->color[1],
 			.b = sample->color[2],

examples/tablet.c

@@ -89,11 +89,10 @@ static void output_frame_notify(struct wl_listener *listener, void *data) {
 
 	struct wlr_output_state output_state;
 	wlr_output_state_init(&output_state);
-	struct wlr_render_pass *pass = wlr_output_begin_render_pass(wlr_output, &output_state, NULL, NULL);
+	struct wlr_render_pass *pass = wlr_output_begin_render_pass(wlr_output, &output_state, NULL,
-
+		&(struct wlr_buffer_pass_options){
-	wlr_render_pass_add_rect(pass, &(struct wlr_render_rect_options){
+			.clear_buffer = true,
-		.box = { .width = wlr_output->width, .height = wlr_output->height },
+			.clear_color = { 0.25, 0.25, 0.25, 1 },
-		.color = { 0.25, 0.25, 0.25, 1 },
 	});
 
 	float distance = 0.8f * (1 - sample->distance);

examples/touch.c

@@ -76,10 +76,10 @@ static void output_frame_notify(struct wl_listener *listener, void *data) {
 
 	struct wlr_output_state output_state;
 	wlr_output_state_init(&output_state);
-	struct wlr_render_pass *pass = wlr_output_begin_render_pass(wlr_output, &output_state, NULL, NULL);
+	struct wlr_render_pass *pass = wlr_output_begin_render_pass(wlr_output, &output_state, NULL,
-	wlr_render_pass_add_rect(pass, &(struct wlr_render_rect_options){
+		&(struct wlr_buffer_pass_options){
-		.box = { .width = width, .height = height },
+			.clear_buffer = true,
-		.color = { 0.25, 0.25, 0.25, 1 },
+			.clear_color = { 0.25, 0.25, 0.25, 1 },
 	});
 
 	struct touch_point *p;

include/render/gles2.h

@@ -169,6 +169,7 @@ void push_gles2_debug_(struct wlr_gles2_renderer *renderer,
 void pop_gles2_debug(struct wlr_gles2_renderer *renderer);
 
 struct wlr_gles2_render_pass *begin_gles2_buffer_pass(struct wlr_gles2_buffer *buffer,
-	struct wlr_egl_context *prev_ctx, struct wlr_gles2_render_timer *timer);
+	struct wlr_egl_context *prev_ctx, struct wlr_gles2_render_timer *timer,
+	const struct wlr_render_color *clear_color);
 
 #endif

include/render/vulkan.h

@@ -175,17 +175,28 @@ struct wlr_vk_pipeline {
 	struct wl_list link; // struct wlr_vk_render_format_setup
 };
 
+struct wlr_vk_framebuffer {
+	int width, height;
+
+	VkFramebuffer vk;
+	struct wlr_vk_render_format_setup *setup;
+	struct wl_list link; // struct wlr_vk_render_format_setup
+};
+
 // For each format we want to render, we need a separate renderpass
 // and therefore also separate pipelines.
 struct wlr_vk_render_format_setup {
 	struct wl_list link; // wlr_vk_renderer.render_format_setups
 	const struct wlr_vk_format *render_format; // used in renderpass
+	bool has_blending_buffer;
+	bool clear_on_load;
 	VkRenderPass render_pass;
 
 	VkPipeline output_pipe;
 
 	struct wlr_vk_renderer *renderer;
 	struct wl_list pipelines; // struct wlr_vk_pipeline.link
+	struct wl_list framebuffers; // struct wlr_vk_framebuffer.link
 };
 
 // Renderer-internal represenation of an wlr_buffer imported for rendering.
@@ -193,12 +204,12 @@ struct wlr_vk_render_buffer {
 	struct wlr_buffer *wlr_buffer;
 	struct wlr_addon addon;
 	struct wlr_vk_renderer *renderer;
-	struct wlr_vk_render_format_setup *render_setup;
 	struct wl_list link; // wlr_vk_renderer.buffers
 
+	const struct wlr_vk_format *fmt;
+
 	VkImage image;
 	VkImageView image_view;
-	VkFramebuffer framebuffer;
 	uint32_t mem_count;
 	VkDeviceMemory memories[WLR_DMABUF_MAX_PLANES];
 	bool transitioned;
@@ -295,12 +306,18 @@ struct wlr_vk_texture_view {
 	struct wlr_vk_descriptor_pool *ds_pool;
 };
 
+struct wlr_vk_render_format_setup *find_or_create_render_setup(
+	struct wlr_vk_renderer *renderer, const struct wlr_vk_format *format,
+	bool has_blending_buffer, bool clear_on_load);
 struct wlr_vk_pipeline *setup_get_or_create_pipeline(
 	struct wlr_vk_render_format_setup *setup,
 	const struct wlr_vk_pipeline_key *key);
 struct wlr_vk_pipeline_layout *get_or_create_pipeline_layout(
 	struct wlr_vk_renderer *renderer,
 	const struct wlr_vk_pipeline_layout_key *key);
+struct wlr_vk_framebuffer *get_or_create_framebuffer(
+	struct wlr_vk_render_format_setup *setup,
+	int width, int height);
 struct wlr_vk_texture_view *vulkan_texture_get_or_create_view(
 	struct wlr_vk_texture *texture,
 	const struct wlr_vk_pipeline_layout *layout);
@@ -321,6 +338,7 @@ struct wlr_vk_render_pass {
 	struct wlr_render_pass base;
 	struct wlr_vk_renderer *renderer;
 	struct wlr_vk_render_buffer *render_buffer;
+	struct wlr_vk_render_format_setup *render_setup;
 	struct wlr_vk_command_buffer *command_buffer;
 	struct rect_union updated_region;
 	VkPipeline bound_pipeline;
@@ -329,7 +347,7 @@ struct wlr_vk_render_pass {
 };
 
 struct wlr_vk_render_pass *vulkan_begin_render_pass(struct wlr_vk_renderer *renderer,
-	struct wlr_vk_render_buffer *buffer);
+	struct wlr_vk_render_buffer *buffer, const struct wlr_render_color *clear_color);
 
 // Suballocates a buffer span with the given size that can be mapped
 // and used as staging buffer. The allocation is implicitly released when the

include/wlr/render/pass.h

@@ -27,9 +27,23 @@ struct wlr_render_pass;
  */
 struct wlr_render_timer;
 
+/**
+ * A color value.
+ *
+ * Each channel has values between 0 and 1 inclusive. The R, G, B
+ * channels need to be pre-multiplied by A.
+ */
+struct wlr_render_color {
+	float r, g, b, a;
+};
+
 struct wlr_buffer_pass_options {
 	/* Timer to measure the duration of the render pass */
 	struct wlr_render_timer *timer;
+	/* Clear the buffer before rendering into it */
+	bool clear_buffer;
+	/* If clearing the buffer, what color to clear it with */
+	struct wlr_render_color clear_color;
 };
 
 /**
@@ -93,16 +107,6 @@ struct wlr_render_texture_options {
 void wlr_render_pass_add_texture(struct wlr_render_pass *render_pass,
 	const struct wlr_render_texture_options *options);
 
-/**
- * A color value.
- *
- * Each channel has values between 0 and 1 inclusive. The R, G, B
- * channels need to be pre-multiplied by A.
- */
-struct wlr_render_color {
-	float r, g, b, a;
-};
-
 struct wlr_render_rect_options {
 	/* Rectangle coordinates */
 	struct wlr_box box;

render/gles2/pass.c

@@ -247,7 +247,8 @@ static const char *reset_status_str(GLenum status) {
 }
 
 struct wlr_gles2_render_pass *begin_gles2_buffer_pass(struct wlr_gles2_buffer *buffer,
-		struct wlr_egl_context *prev_ctx, struct wlr_gles2_render_timer *timer) {
+		struct wlr_egl_context *prev_ctx, struct wlr_gles2_render_timer *timer,
+		const struct wlr_render_color *clear_color) {
 	struct wlr_gles2_renderer *renderer = buffer->renderer;
 	struct wlr_buffer *wlr_buffer = buffer->buffer;
 
@@ -285,6 +286,10 @@ struct wlr_gles2_render_pass *begin_gles2_buffer_pass(struct wlr_gles2_buffer *b
 	glViewport(0, 0, wlr_buffer->width, wlr_buffer->height);
 	glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
 	glDisable(GL_SCISSOR_TEST);
+	if (clear_color) {
+		glClearColor(clear_color->r, clear_color->g, clear_color->b, clear_color->a);
+		glClear(GL_COLOR_BUFFER_BIT);
+	}
 	pop_gles2_debug(renderer);
 
 	return pass;

render/gles2/renderer.c

@@ -258,12 +258,17 @@ static struct wlr_render_pass *gles2_begin_buffer_pass(struct wlr_renderer *wlr_
 		clock_gettime(CLOCK_MONOTONIC, &timer->cpu_start);
 	}
 
+	const struct wlr_render_color *clear_color = NULL;
+	if (options->clear_buffer) {
+		clear_color = &options->clear_color;
+	}
+
 	struct wlr_gles2_buffer *buffer = gles2_buffer_get_or_create(renderer, wlr_buffer);
 	if (!buffer) {
 		return NULL;
 	}
 
-	struct wlr_gles2_render_pass *pass = begin_gles2_buffer_pass(buffer, &prev_ctx, timer);
+	struct wlr_gles2_render_pass *pass = begin_gles2_buffer_pass(buffer, &prev_ctx, timer, clear_color);
 	if (!pass) {
 		return NULL;
 	}

render/pixman/renderer.c

@@ -312,6 +312,13 @@ static struct wlr_render_pass *pixman_begin_buffer_pass(struct wlr_renderer *wlr
 	if (pass == NULL) {
 		return NULL;
 	}
+	if (options->clear_buffer) {
+		wlr_render_pass_add_rect(&pass->base, &(struct wlr_render_rect_options){
+			.box = { .width = buffer->buffer->width, .height = buffer->buffer->height },
+			.color = options->clear_color,
+			.blend_mode = WLR_RENDER_BLEND_MODE_NONE,
+		});
+	}
 	return &pass->base;
 }
 

render/vulkan/pass.c

@@ -105,7 +105,7 @@ static bool render_pass_submit(struct wlr_render_pass *wlr_pass) {
 		};
 		mat3_to_mat4(final_matrix, vert_pcr_data.mat4);
 
-		bind_pipeline(pass, render_buffer->render_setup->output_pipe);
+		bind_pipeline(pass, pass->render_setup->output_pipe);
 		vkCmdPushConstants(render_cb->vk, renderer->output_pipe_layout,
 			VK_SHADER_STAGE_VERTEX_BIT, 0, sizeof(vert_pcr_data), &vert_pcr_data);
 		vkCmdBindDescriptorSets(render_cb->vk,
@@ -484,7 +484,7 @@ static void render_pass_add_rect(struct wlr_render_pass *wlr_pass,
 		wlr_matrix_multiply(matrix, pass->projection, matrix);
 
 		struct wlr_vk_pipeline *pipe = setup_get_or_create_pipeline(
-			pass->render_buffer->render_setup,
+			pass->render_setup,
 			&(struct wlr_vk_pipeline_key) {
 				.source = WLR_VK_SHADER_SOURCE_SINGLE_COLOR,
 				.layout = { .ycbcr_format = NULL },
@@ -548,7 +548,6 @@ static void render_pass_add_texture(struct wlr_render_pass *wlr_pass,
 		const struct wlr_render_texture_options *options) {
 	struct wlr_vk_render_pass *pass = get_render_pass(wlr_pass);
 	struct wlr_vk_renderer *renderer = pass->renderer;
-	struct wlr_vk_render_buffer *render_buffer = pass->render_buffer;
 	VkCommandBuffer cb = pass->command_buffer->vk;
 
 	struct wlr_vk_texture *texture = vulkan_get_texture(options->texture);
@@ -594,7 +593,7 @@ static void render_pass_add_texture(struct wlr_render_pass *wlr_pass,
 	mat3_to_mat4(matrix, vert_pcr_data.mat4);
 
 	struct wlr_vk_pipeline *pipe = setup_get_or_create_pipeline(
-		render_buffer->render_setup,
+		pass->render_setup,
 		&(struct wlr_vk_pipeline_key) {
 			.source = WLR_VK_SHADER_SOURCE_TEXTURE,
 			.layout = {
@@ -659,7 +658,7 @@ static const struct wlr_render_pass_impl render_pass_impl = {
 };
 
 struct wlr_vk_render_pass *vulkan_begin_render_pass(struct wlr_vk_renderer *renderer,
-		struct wlr_vk_render_buffer *buffer) {
+		struct wlr_vk_render_buffer *buffer, const struct wlr_render_color *clear_color) {
 	struct wlr_vk_render_pass *pass = calloc(1, sizeof(*pass));
 	if (pass == NULL) {
 		return NULL;
@@ -669,6 +668,21 @@ struct wlr_vk_render_pass *vulkan_begin_render_pass(struct wlr_vk_renderer *rend
 
 	rect_union_init(&pass->updated_region);
 
+	bool has_blending_buffer = buffer->blend_image != VK_NULL_HANDLE;
+	struct wlr_vk_render_format_setup *render_setup = find_or_create_render_setup(
+		renderer, buffer->fmt, has_blending_buffer, clear_color != NULL);
+	if (render_setup == NULL) {
+		free(pass);
+		return NULL;
+	}
+
+	struct wlr_vk_framebuffer *framebuffer = get_or_create_framebuffer(
+		render_setup, buffer->wlr_buffer->width, buffer->wlr_buffer->height);
+	if (framebuffer == NULL) {
+		free(pass);
+		return NULL;
+	}
+
 	struct wlr_vk_command_buffer *cb = vulkan_acquire_command_buffer(renderer);
 	if (cb == NULL) {
 		free(pass);
@@ -689,13 +703,38 @@ struct wlr_vk_render_pass *vulkan_begin_render_pass(struct wlr_vk_renderer *rend
 	int width = buffer->wlr_buffer->width;
 	int height = buffer->wlr_buffer->height;
 	VkRect2D rect = { .extent = { width, height } };
+	VkImageView attachments[2] = {0};
+	uint32_t attachment_count = 0;
+	VkClearValue clear_values[2] = { 0 };
+	if (clear_color) {
+		clear_values[0] = clear_values[1] = (VkClearValue){
+			.color.float32 = {
+				color_to_linear(clear_color->r),
+				color_to_linear(clear_color->g),
+				color_to_linear(clear_color->b),
+				clear_color->a,
+			}
+		};
+	}
 
+	if (buffer->blend_image_view != VK_NULL_HANDLE) {
+		attachments[attachment_count++] = buffer->blend_image_view;
+	}
+	attachments[attachment_count++] = buffer->image_view;
+
+	VkRenderPassAttachmentBeginInfo attachment_info = {
+		.sType = VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO,
+		.attachmentCount = attachment_count,
+		.pAttachments = attachments,
+	};
 	VkRenderPassBeginInfo rp_info = {
 		.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,
+		.pNext = &attachment_info,
 		.renderArea = rect,
-		.renderPass = buffer->render_setup->render_pass,
+		.renderPass = render_setup->render_pass,
-		.framebuffer = buffer->framebuffer,
+		.framebuffer = framebuffer->vk,
-		.clearValueCount = 0,
+		.clearValueCount = clear_color ? attachment_count : 0,
+		.pClearValues = clear_values,
 	};
 	vkCmdBeginRenderPass(cb->vk, &rp_info, VK_SUBPASS_CONTENTS_INLINE);
 
@@ -711,6 +750,7 @@ struct wlr_vk_render_pass *vulkan_begin_render_pass(struct wlr_vk_renderer *rend
 
 	wlr_buffer_lock(buffer->wlr_buffer);
 	pass->render_buffer = buffer;
+	pass->render_setup = render_setup;
 	pass->command_buffer = cb;
 	return pass;
 }

render/vulkan/renderer.c

@@ -54,10 +54,6 @@ struct wlr_vk_renderer *vulkan_get_renderer(struct wlr_renderer *wlr_renderer) {
 	return renderer;
 }
 
-static struct wlr_vk_render_format_setup *find_or_create_render_setup(
-		struct wlr_vk_renderer *renderer, const struct wlr_vk_format *format,
-		bool has_blending_buffer);
-
 static struct wlr_vk_descriptor_pool *alloc_ds(
 		struct wlr_vk_renderer *renderer, VkDescriptorSet *ds,
 		VkDescriptorType type, const VkDescriptorSetLayout *layout,
@@ -163,6 +159,12 @@ static void destroy_render_format_setup(struct wlr_vk_renderer *renderer,
 		vkDestroyPipeline(dev, pipeline->vk, NULL);
 		free(pipeline);
 	}
+
+	struct wlr_vk_framebuffer *framebuffer, *tmp_framebuffer;
+	wl_list_for_each_safe(framebuffer, tmp_framebuffer, &setup->framebuffers, link) {
+		vkDestroyFramebuffer(dev, framebuffer->vk, NULL);
+		free(framebuffer);
+	}
 }
 
 static void shared_buffer_destroy(struct wlr_vk_renderer *r,
@@ -570,7 +572,6 @@ static void destroy_render_buffer(struct wlr_vk_render_buffer *buffer) {
 		wlr_vk_error("vkQueueWaitIdle", res);
 	}
 
-	vkDestroyFramebuffer(dev, buffer->framebuffer, NULL);
 	vkDestroyImageView(dev, buffer->image_view, NULL);
 	vkDestroyImage(dev, buffer->image, NULL);
 
@@ -743,6 +744,7 @@ static struct wlr_vk_render_buffer *create_render_buffer(
 			dmabuf.format, (const char*) &dmabuf.format);
 		goto error;
 	}
+	buffer->fmt = &fmt->format;
 
 	VkImageViewCreateInfo view_info = {
 		.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
@@ -770,41 +772,10 @@ static struct wlr_vk_render_buffer *create_render_buffer(
 
 	bool has_blending_buffer = !using_mutable_srgb;
 
-	buffer->render_setup = find_or_create_render_setup(
+	if (has_blending_buffer && !setup_blend_image(renderer, buffer, dmabuf.width, dmabuf.height)) {
-		renderer, &fmt->format, has_blending_buffer);
-	if (!buffer->render_setup) {
 		goto error;
 	}
 
-	VkImageView attachments[2] = {0};
-	uint32_t attachment_count = 0;
-
-	if (has_blending_buffer) {
-		if (!setup_blend_image(renderer, buffer, dmabuf.width, dmabuf.height)) {
-			goto error;
-		}
-		attachments[attachment_count++] = buffer->blend_image_view;
-	}
-	attachments[attachment_count++] = buffer->image_view;
-
-	VkFramebufferCreateInfo fb_info = {
-		.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO,
-		.attachmentCount = attachment_count,
-		.pAttachments = attachments,
-		.flags = 0u,
-		.width = dmabuf.width,
-		.height = dmabuf.height,
-		.layers = 1u,
-		.renderPass = buffer->render_setup->render_pass,
-	};
-
-	res = vkCreateFramebuffer(dev, &fb_info, NULL, &buffer->framebuffer);
-	if (res != VK_SUCCESS) {
-		wlr_vk_error("vkCreateFramebuffer", res);
-		goto error;
-	}
-
-
 	wlr_addon_init(&buffer->addon, &wlr_buffer->addons, renderer,
 		&render_buffer_addon_impl);
 	wl_list_insert(&renderer->render_buffers, &buffer->link);
@@ -820,7 +791,6 @@ error:
 	vkFreeMemory(dev, buffer->blend_memory, NULL);
 	vkDestroyImageView(dev, buffer->blend_image_view, NULL);
 
-	vkDestroyFramebuffer(dev, buffer->framebuffer, NULL);
 	vkDestroyImageView(dev, buffer->image_view, NULL);
 	vkDestroyImage(dev, buffer->image, NULL);
 	for (size_t i = 0u; i < buffer->mem_count; ++i) {
@@ -1315,7 +1285,12 @@ static struct wlr_render_pass *vulkan_begin_buffer_pass(struct wlr_renderer *wlr
 		}
 	}
 
-	struct wlr_vk_render_pass *render_pass = vulkan_begin_render_pass(renderer, render_buffer);
+	const struct wlr_render_color *clear_color = NULL;
+	if (options->clear_buffer) {
+		clear_color = &options->clear_color;
+	}
+
+	struct wlr_vk_render_pass *render_pass = vulkan_begin_render_pass(renderer, render_buffer, clear_color);
 	if (render_pass == NULL) {
 		return NULL;
 	}
@@ -1886,12 +1861,12 @@ static bool init_static_render_data(struct wlr_vk_renderer *renderer) {
 	return true;
 }
 
-static struct wlr_vk_render_format_setup *find_or_create_render_setup(
+struct wlr_vk_render_format_setup *find_or_create_render_setup(
 		struct wlr_vk_renderer *renderer, const struct wlr_vk_format *format,
-		bool has_blending_buffer) {
+		bool has_blending_buffer, bool clear_on_load) {
 	struct wlr_vk_render_format_setup *setup;
 	wl_list_for_each(setup, &renderer->render_format_setups, link) {
-		if (setup->render_format == format) {
+		if (setup->render_format == format && setup->has_blending_buffer == has_blending_buffer && setup->clear_on_load == clear_on_load) {
 			return setup;
 		}
 	}
@@ -1903,18 +1878,22 @@ static struct wlr_vk_render_format_setup *find_or_create_render_setup(
 	}
 
 	setup->render_format = format;
+	setup->has_blending_buffer = has_blending_buffer;
+	setup->clear_on_load = clear_on_load;
 	setup->renderer = renderer;
 	wl_list_init(&setup->pipelines);
+	wl_list_init(&setup->framebuffers);
 
 	VkDevice dev = renderer->dev->dev;
 	VkResult res;
+	VkAttachmentLoadOp load_op = clear_on_load ? VK_ATTACHMENT_LOAD_OP_CLEAR : VK_ATTACHMENT_LOAD_OP_LOAD;
 
 	if (has_blending_buffer) {
 		VkAttachmentDescription attachments[2] = {
 			{
 				.format = VK_FORMAT_R16G16B16A16_SFLOAT,
 				.samples = VK_SAMPLE_COUNT_1_BIT,
-				.loadOp = VK_ATTACHMENT_LOAD_OP_LOAD,
+				.loadOp = load_op,
 				.storeOp = VK_ATTACHMENT_STORE_OP_STORE,
 				.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE,
 				.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE,
@@ -1924,7 +1903,7 @@ static struct wlr_vk_render_format_setup *find_or_create_render_setup(
 			{
 				.format = format->vk,
 				.samples = VK_SAMPLE_COUNT_1_BIT,
-				.loadOp = VK_ATTACHMENT_LOAD_OP_LOAD,
+				.loadOp = load_op,
 				.storeOp = VK_ATTACHMENT_STORE_OP_STORE,
 				.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE,
 				.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE,
@@ -2030,7 +2009,7 @@ static struct wlr_vk_render_format_setup *find_or_create_render_setup(
 		VkAttachmentDescription attachment = {
 			.format = format->vk_srgb,
 			.samples = VK_SAMPLE_COUNT_1_BIT,
-			.loadOp = VK_ATTACHMENT_LOAD_OP_LOAD,
+			.loadOp = load_op,
 			.storeOp = VK_ATTACHMENT_STORE_OP_STORE,
 			.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE,
 			.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE,
@@ -2142,6 +2121,91 @@ error:
 	return NULL;
 }
 
+struct wlr_vk_framebuffer *get_or_create_framebuffer(
+		struct wlr_vk_render_format_setup *setup,
+		int width, int height) {
+	struct wlr_vk_framebuffer *framebuffer;
+	wl_list_for_each(framebuffer, &setup->framebuffers, link) {
+		if (framebuffer->width == width && framebuffer->height == height) {
+			return framebuffer;
+		}
+	}
+
+	framebuffer = calloc(1u, sizeof(*framebuffer));
+	if (!framebuffer) {
+		wlr_log(WLR_ERROR, "Allocation failed");
+		return NULL;
+	}
+
+	bool using_mutable_srgb = !setup->has_blending_buffer;
+
+	VkResult res;
+	VkDevice dev = setup->renderer->dev->dev;
+	VkFramebufferAttachmentImageInfo attachments[2] = {0};
+	uint32_t attachment_count = 0;
+
+	VkFormat view_formats[] = {
+		setup->render_format->vk,
+		setup->render_format->vk_srgb,
+	};
+	VkFormat blend_view_formats[] = {
+		VK_FORMAT_R16G16B16A16_SFLOAT,
+	};
+
+	if (setup->has_blending_buffer) {
+		attachments[attachment_count++] = (VkFramebufferAttachmentImageInfo) {
+			.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO,
+			.flags = 0,
+			.usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT,
+			.width = width,
+			.height = height,
+			.layerCount = 1,
+			.viewFormatCount = 1,
+			.pViewFormats = blend_view_formats,
+		};
+	}
+	attachments[attachment_count++] = (VkFramebufferAttachmentImageInfo) {
+		.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO,
+		.flags = using_mutable_srgb ? VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT : 0,
+		.usage = vulkan_render_usage,
+		.width = width,
+		.height = height,
+		.layerCount = 1,
+		.viewFormatCount = using_mutable_srgb ? 2 : 1,
+		.pViewFormats = view_formats,
+	};
+
+	VkFramebufferAttachmentsCreateInfo fb_attachments_info = {
+		.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO,
+		.attachmentImageInfoCount = attachment_count,
+		.pAttachmentImageInfos = attachments,
+	};
+	VkFramebufferCreateInfo fb_info = {
+		.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO,
+		.pNext = &fb_attachments_info,
+		.attachmentCount = attachment_count,
+		.pAttachments = NULL,
+		.flags = VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT,
+		.width = width,
+		.height = height,
+		.layers = 1u,
+		.renderPass = setup->render_pass,
+	};
+
+	res = vkCreateFramebuffer(dev, &fb_info, NULL, &framebuffer->vk);
+	if (res != VK_SUCCESS) {
+		wlr_vk_error("vkCreateFramebuffer", res);
+		goto error;
+	}
+
+	wl_list_insert(&setup->framebuffers, &framebuffer->link);
+	return framebuffer;
+
+error:
+	free(framebuffer);
+	return NULL;
+}
+
 struct wlr_renderer *vulkan_renderer_create_for_device(struct wlr_vk_device *dev) {
 	struct wlr_vk_renderer *renderer;
 	VkResult res;

render/vulkan/vulkan.c

@@ -464,6 +464,7 @@ struct wlr_vk_device *vulkan_device_create(struct wlr_vk_instance *ini,
 	extensions[extensions_len++] = VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME;
 	extensions[extensions_len++] = VK_KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME;
 	extensions[extensions_len++] = VK_KHR_IMAGE_FORMAT_LIST_EXTENSION_NAME; // or vulkan 1.2
+	extensions[extensions_len++] = VK_KHR_IMAGELESS_FRAMEBUFFER_EXTENSION_NAME; // or vulkan 1.2
 	extensions[extensions_len++] = VK_EXT_EXTERNAL_MEMORY_DMA_BUF_EXTENSION_NAME;
 	extensions[extensions_len++] = VK_EXT_QUEUE_FAMILY_FOREIGN_EXTENSION_NAME;
 	extensions[extensions_len++] = VK_EXT_IMAGE_DRM_FORMAT_MODIFIER_EXTENSION_NAME;
@@ -569,8 +570,13 @@ struct wlr_vk_device *vulkan_device_create(struct wlr_vk_instance *ini,
 			"falling back to regular queue priority");
 	}
 
+	VkPhysicalDeviceImagelessFramebufferFeatures imageless_framebuffer_features = {
+		.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES,
+		.imagelessFramebuffer = VK_TRUE,
+	};
 	VkPhysicalDeviceSamplerYcbcrConversionFeatures sampler_ycbcr_features = {
 		.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES,
+		.pNext = &imageless_framebuffer_features,
 		.samplerYcbcrConversion = dev->sampler_ycbcr_conversion,
 	};
 	VkPhysicalDeviceSynchronization2FeaturesKHR sync2_features = {

types/output/cursor.c

@@ -231,7 +231,9 @@ static struct wlr_buffer *render_cursor_buffer(struct wlr_output_cursor *cursor)
 	wlr_box_transform(&dst_box, &dst_box, wlr_output_transform_invert(output->transform),
 		buffer->width, buffer->height);
 
-	struct wlr_render_pass *pass = wlr_renderer_begin_buffer_pass(renderer, buffer, NULL);
+	struct wlr_render_pass *pass = wlr_renderer_begin_buffer_pass(renderer, buffer, &(struct wlr_buffer_pass_options){
+		.clear_buffer = true,
+	});
 	if (pass == NULL) {
 		wlr_buffer_unlock(buffer);
 		return NULL;
@@ -240,10 +242,6 @@ static struct wlr_buffer *render_cursor_buffer(struct wlr_output_cursor *cursor)
 	enum wl_output_transform transform = wlr_output_transform_invert(cursor->transform);
 	transform = wlr_output_transform_compose(transform, output->transform);
 
-	wlr_render_pass_add_rect(pass, &(struct wlr_render_rect_options){
-		.box = { .width = buffer->width, .height = buffer->height },
-		.blend_mode = WLR_RENDER_BLEND_MODE_NONE,
-	});
 	wlr_render_pass_add_texture(pass, &(struct wlr_render_texture_options){
 		.texture = texture,
 		.src_box = cursor->src_box,

types/output/render.c

@@ -61,17 +61,14 @@ static struct wlr_buffer *output_acquire_empty_buffer(struct wlr_output *output,
 	}
 
 	struct wlr_render_pass *pass =
-		wlr_renderer_begin_buffer_pass(output->renderer, buffer, NULL);
+		wlr_renderer_begin_buffer_pass(output->renderer, buffer, &(struct wlr_buffer_pass_options){
+		.clear_buffer = true,
+	});
 	if (pass == NULL) {
 		wlr_buffer_unlock(buffer);
 		return NULL;
 	}
 
-	wlr_render_pass_add_rect(pass, &(struct wlr_render_rect_options){
-		.color = { 0, 0, 0, 0 },
-		.blend_mode = WLR_RENDER_BLEND_MODE_NONE,
-	});
-
 	if (!wlr_render_pass_submit(pass)) {
 		wlr_buffer_unlock(buffer);
 		return NULL;