mirrors/wlroots
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/wlroots/wlroots.git synced 2025-10-29 05:40:12 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

render/vulkan: rename plain to two_pass

Browse source 
We will introduce a new subpass without any post-processing step.
Rename "plain" so that there's no confusion.
This commit is contained in:
Simon Ser 2025-06-21 16:57:51 +02:00
parent dd7f543189
commit 54374b6fe6
3 changed files with 48 additions and 48 deletions
Download patch file Download diff file Expand all files Collapse all files

4
include/render/vulkan.h
View file

@ -241,10 +241,10 @@ struct wlr_vk_render_buffer {
VkDescriptorSet blend_descriptor_set; VkDescriptorSet blend_descriptor_set;
struct wlr_vk_descriptor_pool *blend_attachment_pool; struct wlr_vk_descriptor_pool *blend_attachment_pool;
bool blend_transitioned; bool blend_transitioned;
} plain; } two_pass;
}; };
bool vulkan_setup_plain_framebuffer(struct wlr_vk_render_buffer *buffer, bool vulkan_setup_two_pass_framebuffer(struct wlr_vk_render_buffer *buffer,
const struct wlr_dmabuf_attributes *dmabuf); const struct wlr_dmabuf_attributes *dmabuf);
struct wlr_vk_command_buffer { struct wlr_vk_command_buffer {

32
render/vulkan/pass.c
View file

@ -227,7 +227,7 @@ static bool render_pass_submit(struct wlr_render_pass *wlr_pass) {
VkPipeline pipeline = VK_NULL_HANDLE; VkPipeline pipeline = VK_NULL_HANDLE;
if (pass->color_transform && pass->color_transform->type != COLOR_TRANSFORM_INVERSE_EOTF) { if (pass->color_transform && pass->color_transform->type != COLOR_TRANSFORM_INVERSE_EOTF) {
pipeline = render_buffer->plain.render_setup->output_pipe_lut3d; pipeline = render_buffer->two_pass.render_setup->output_pipe_lut3d;
} else { } else {
enum wlr_color_transfer_function tf = WLR_COLOR_TRANSFER_FUNCTION_SRGB; enum wlr_color_transfer_function tf = WLR_COLOR_TRANSFER_FUNCTION_SRGB;
if (pass->color_transform && pass->color_transform->type == COLOR_TRANSFORM_INVERSE_EOTF) { if (pass->color_transform && pass->color_transform->type == COLOR_TRANSFORM_INVERSE_EOTF) {
@ -238,13 +238,13 @@ static bool render_pass_submit(struct wlr_render_pass *wlr_pass) {
switch (tf) { switch (tf) {
case WLR_COLOR_TRANSFER_FUNCTION_EXT_LINEAR: case WLR_COLOR_TRANSFER_FUNCTION_EXT_LINEAR:
pipeline = render_buffer->plain.render_setup->output_pipe_identity; pipeline = render_buffer->two_pass.render_setup->output_pipe_identity;
break; break;
case WLR_COLOR_TRANSFER_FUNCTION_SRGB: case WLR_COLOR_TRANSFER_FUNCTION_SRGB:
pipeline = render_buffer->plain.render_setup->output_pipe_srgb; pipeline = render_buffer->two_pass.render_setup->output_pipe_srgb;
break; break;
case WLR_COLOR_TRANSFER_FUNCTION_ST2084_PQ: case WLR_COLOR_TRANSFER_FUNCTION_ST2084_PQ:
pipeline = render_buffer->plain.render_setup->output_pipe_pq; pipeline = render_buffer->two_pass.render_setup->output_pipe_pq;
break; break;
} }
@ -268,7 +268,7 @@ static bool render_pass_submit(struct wlr_render_pass *wlr_pass) {
lut_ds = renderer->output_ds_lut3d_dummy; lut_ds = renderer->output_ds_lut3d_dummy;
} }
VkDescriptorSet ds[] = { VkDescriptorSet ds[] = {
render_buffer->plain.blend_descriptor_set, // set 0 render_buffer->two_pass.blend_descriptor_set, // set 0
lut_ds, // set 1 lut_ds, // set 1
}; };
size_t ds_len = sizeof(ds) / sizeof(ds[0]); size_t ds_len = sizeof(ds) / sizeof(ds[0]);
@ -404,24 +404,24 @@ static bool render_pass_submit(struct wlr_render_pass *wlr_pass) {
render_buffer->srgb.transitioned = true; render_buffer->srgb.transitioned = true;
} }
} else { } else {
if (!render_buffer->plain.transitioned) { if (!render_buffer->two_pass.transitioned) {
src_layout = VK_IMAGE_LAYOUT_PREINITIALIZED; src_layout = VK_IMAGE_LAYOUT_PREINITIALIZED;
render_buffer->plain.transitioned = true; render_buffer->two_pass.transitioned = true;
} }
// The render pass changes the blend image layout from // The render pass changes the blend image layout from
// color attachment to read only, so on each frame, before // color attachment to read only, so on each frame, before
// the render pass starts, we change it back // the render pass starts, we change it back
VkImageLayout blend_src_layout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; VkImageLayout blend_src_layout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
if (!render_buffer->plain.blend_transitioned) { if (!render_buffer->two_pass.blend_transitioned) {
blend_src_layout = VK_IMAGE_LAYOUT_UNDEFINED; blend_src_layout = VK_IMAGE_LAYOUT_UNDEFINED;
render_buffer->plain.blend_transitioned = true; render_buffer->two_pass.blend_transitioned = true;
} }
VkImageMemoryBarrier blend_acq_barrier = { VkImageMemoryBarrier blend_acq_barrier = {
.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED, .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED, .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
.image = render_buffer->plain.blend_image, .image = render_buffer->two_pass.blend_image,
.oldLayout = blend_src_layout, .oldLayout = blend_src_layout,
.newLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, .newLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
.srcAccessMask = VK_ACCESS_SHADER_READ_BIT, .srcAccessMask = VK_ACCESS_SHADER_READ_BIT,
@ -680,7 +680,7 @@ static void render_pass_add_rect(struct wlr_render_pass *wlr_pass,
struct wlr_vk_render_format_setup *setup = pass->srgb_pathway ? struct wlr_vk_render_format_setup *setup = pass->srgb_pathway ?
pass->render_buffer->srgb.render_setup : pass->render_buffer->srgb.render_setup :
pass->render_buffer->plain.render_setup; pass->render_buffer->two_pass.render_setup;
struct wlr_vk_pipeline *pipe = setup_get_or_create_pipeline( struct wlr_vk_pipeline *pipe = setup_get_or_create_pipeline(
setup, setup,
&(struct wlr_vk_pipeline_key) { &(struct wlr_vk_pipeline_key) {
@ -807,7 +807,7 @@ static void render_pass_add_texture(struct wlr_render_pass *wlr_pass,
struct wlr_vk_render_format_setup *setup = pass->srgb_pathway ? struct wlr_vk_render_format_setup *setup = pass->srgb_pathway ?
pass->render_buffer->srgb.render_setup : pass->render_buffer->srgb.render_setup :
pass->render_buffer->plain.render_setup; pass->render_buffer->two_pass.render_setup;
struct wlr_vk_pipeline *pipe = setup_get_or_create_pipeline( struct wlr_vk_pipeline *pipe = setup_get_or_create_pipeline(
setup, setup,
&(struct wlr_vk_pipeline_key) { &(struct wlr_vk_pipeline_key) {
@ -1193,10 +1193,10 @@ struct wlr_vk_render_pass *vulkan_begin_render_pass(struct wlr_vk_renderer *rend
using_srgb_pathway = buffer->srgb.framebuffer != VK_NULL_HANDLE; using_srgb_pathway = buffer->srgb.framebuffer != VK_NULL_HANDLE;
} }
if (!using_srgb_pathway && !buffer->plain.image_view) { if (!using_srgb_pathway && !buffer->two_pass.image_view) {
struct wlr_dmabuf_attributes attribs; struct wlr_dmabuf_attributes attribs;
wlr_buffer_get_dmabuf(buffer->wlr_buffer, &attribs); wlr_buffer_get_dmabuf(buffer->wlr_buffer, &attribs);
if (!vulkan_setup_plain_framebuffer(buffer, &attribs)) { if (!vulkan_setup_two_pass_framebuffer(buffer, &attribs)) {
wlr_log(WLR_ERROR, "Failed to set up blend image"); wlr_log(WLR_ERROR, "Failed to set up blend image");
return NULL; return NULL;
} }
@ -1262,8 +1262,8 @@ struct wlr_vk_render_pass *vulkan_begin_render_pass(struct wlr_vk_renderer *rend
rp_info.renderPass = buffer->srgb.render_setup->render_pass; rp_info.renderPass = buffer->srgb.render_setup->render_pass;
rp_info.framebuffer = buffer->srgb.framebuffer; rp_info.framebuffer = buffer->srgb.framebuffer;
} else { } else {
rp_info.renderPass = buffer->plain.render_setup->render_pass; rp_info.renderPass = buffer->two_pass.render_setup->render_pass;
rp_info.framebuffer = buffer->plain.framebuffer; rp_info.framebuffer = buffer->two_pass.framebuffer;
} }
vkCmdBeginRenderPass(cb->vk, &rp_info, VK_SUBPASS_CONTENTS_INLINE); vkCmdBeginRenderPass(cb->vk, &rp_info, VK_SUBPASS_CONTENTS_INLINE);

60
render/vulkan/renderer.c
View file

@ -620,14 +620,14 @@ static void destroy_render_buffer(struct wlr_vk_render_buffer *buffer) {
vkDestroyFramebuffer(dev, buffer->srgb.framebuffer, NULL); vkDestroyFramebuffer(dev, buffer->srgb.framebuffer, NULL);
vkDestroyImageView(dev, buffer->srgb.image_view, NULL); vkDestroyImageView(dev, buffer->srgb.image_view, NULL);
vkDestroyFramebuffer(dev, buffer->plain.framebuffer, NULL); vkDestroyFramebuffer(dev, buffer->two_pass.framebuffer, NULL);
vkDestroyImageView(dev, buffer->plain.image_view, NULL); vkDestroyImageView(dev, buffer->two_pass.image_view, NULL);
vkDestroyImage(dev, buffer->plain.blend_image, NULL); vkDestroyImage(dev, buffer->two_pass.blend_image, NULL);
vkFreeMemory(dev, buffer->plain.blend_memory, NULL); vkFreeMemory(dev, buffer->two_pass.blend_memory, NULL);
vkDestroyImageView(dev, buffer->plain.blend_image_view, NULL); vkDestroyImageView(dev, buffer->two_pass.blend_image_view, NULL);
if (buffer->plain.blend_attachment_pool) { if (buffer->two_pass.blend_attachment_pool) {
vulkan_free_ds(buffer->renderer, buffer->plain.blend_attachment_pool, vulkan_free_ds(buffer->renderer, buffer->two_pass.blend_attachment_pool,
buffer->plain.blend_descriptor_set); buffer->two_pass.blend_descriptor_set);
} }
vkDestroyImage(dev, buffer->image, NULL); vkDestroyImage(dev, buffer->image, NULL);
@ -648,7 +648,7 @@ static struct wlr_addon_interface render_buffer_addon_impl = {
.destroy = handle_render_buffer_destroy, .destroy = handle_render_buffer_destroy,
}; };
bool vulkan_setup_plain_framebuffer(struct wlr_vk_render_buffer *buffer, bool vulkan_setup_two_pass_framebuffer(struct wlr_vk_render_buffer *buffer,
const struct wlr_dmabuf_attributes *dmabuf) { const struct wlr_dmabuf_attributes *dmabuf) {
struct wlr_vk_renderer *renderer = buffer->renderer; struct wlr_vk_renderer *renderer = buffer->renderer;
VkResult res; VkResult res;
@ -676,15 +676,15 @@ bool vulkan_setup_plain_framebuffer(struct wlr_vk_render_buffer *buffer,
}, },
}; };
res = vkCreateImageView(dev, &view_info, NULL, &buffer->plain.image_view); res = vkCreateImageView(dev, &view_info, NULL, &buffer->two_pass.image_view);
if (res != VK_SUCCESS) { if (res != VK_SUCCESS) {
wlr_vk_error("vkCreateImageView failed", res); wlr_vk_error("vkCreateImageView failed", res);
goto error; goto error;
} }
buffer->plain.render_setup = find_or_create_render_setup( buffer->two_pass.render_setup = find_or_create_render_setup(
renderer, &fmt->format, true); renderer, &fmt->format, true);
if (!buffer->plain.render_setup) { if (!buffer->two_pass.render_setup) {
goto error; goto error;
} }
@ -704,14 +704,14 @@ bool vulkan_setup_plain_framebuffer(struct wlr_vk_render_buffer *buffer,
.usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT, .usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT,
}; };
res = vkCreateImage(dev, &img_info, NULL, &buffer->plain.blend_image); res = vkCreateImage(dev, &img_info, NULL, &buffer->two_pass.blend_image);
if (res != VK_SUCCESS) { if (res != VK_SUCCESS) {
wlr_vk_error("vkCreateImage failed", res); wlr_vk_error("vkCreateImage failed", res);
goto error; goto error;
} }
VkMemoryRequirements mem_reqs; VkMemoryRequirements mem_reqs;
vkGetImageMemoryRequirements(dev, buffer->plain.blend_image, &mem_reqs); vkGetImageMemoryRequirements(dev, buffer->two_pass.blend_image, &mem_reqs);
int mem_type_index = vulkan_find_mem_type(renderer->dev, int mem_type_index = vulkan_find_mem_type(renderer->dev,
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, mem_reqs.memoryTypeBits); VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, mem_reqs.memoryTypeBits);
@ -726,13 +726,13 @@ bool vulkan_setup_plain_framebuffer(struct wlr_vk_render_buffer *buffer,
.memoryTypeIndex = mem_type_index, .memoryTypeIndex = mem_type_index,
}; };
res = vkAllocateMemory(dev, &mem_info, NULL, &buffer->plain.blend_memory); res = vkAllocateMemory(dev, &mem_info, NULL, &buffer->two_pass.blend_memory);
if (res != VK_SUCCESS) { if (res != VK_SUCCESS) {
wlr_vk_error("vkAllocatorMemory failed", res); wlr_vk_error("vkAllocatorMemory failed", res);
goto error; goto error;
} }
res = vkBindImageMemory(dev, buffer->plain.blend_image, buffer->plain.blend_memory, 0); res = vkBindImageMemory(dev, buffer->two_pass.blend_image, buffer->two_pass.blend_memory, 0);
if (res != VK_SUCCESS) { if (res != VK_SUCCESS) {
wlr_vk_error("vkBindMemory failed", res); wlr_vk_error("vkBindMemory failed", res);
goto error; goto error;
@ -740,7 +740,7 @@ bool vulkan_setup_plain_framebuffer(struct wlr_vk_render_buffer *buffer,
VkImageViewCreateInfo blend_view_info = { VkImageViewCreateInfo blend_view_info = {
.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
.image = buffer->plain.blend_image, .image = buffer->two_pass.blend_image,
.viewType = VK_IMAGE_VIEW_TYPE_2D, .viewType = VK_IMAGE_VIEW_TYPE_2D,
.format = img_info.format, .format = img_info.format,
.components.r = VK_COMPONENT_SWIZZLE_IDENTITY, .components.r = VK_COMPONENT_SWIZZLE_IDENTITY,
@ -756,37 +756,37 @@ bool vulkan_setup_plain_framebuffer(struct wlr_vk_render_buffer *buffer,
}, },
}; };
res = vkCreateImageView(dev, &blend_view_info, NULL, &buffer->plain.blend_image_view); res = vkCreateImageView(dev, &blend_view_info, NULL, &buffer->two_pass.blend_image_view);
if (res != VK_SUCCESS) { if (res != VK_SUCCESS) {
wlr_vk_error("vkCreateImageView failed", res); wlr_vk_error("vkCreateImageView failed", res);
goto error; goto error;
} }
buffer->plain.blend_attachment_pool = vulkan_alloc_blend_ds(renderer, buffer->two_pass.blend_attachment_pool = vulkan_alloc_blend_ds(renderer,
&buffer->plain.blend_descriptor_set); &buffer->two_pass.blend_descriptor_set);
if (!buffer->plain.blend_attachment_pool) { if (!buffer->two_pass.blend_attachment_pool) {
wlr_log(WLR_ERROR, "failed to allocate descriptor"); wlr_log(WLR_ERROR, "failed to allocate descriptor");
goto error; goto error;
} }
VkDescriptorImageInfo ds_attach_info = { VkDescriptorImageInfo ds_attach_info = {
.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, .imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
.imageView = buffer->plain.blend_image_view, .imageView = buffer->two_pass.blend_image_view,
.sampler = VK_NULL_HANDLE, .sampler = VK_NULL_HANDLE,
}; };
VkWriteDescriptorSet ds_write = { VkWriteDescriptorSet ds_write = {
.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, .sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
.descriptorCount = 1, .descriptorCount = 1,
.descriptorType = VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, .descriptorType = VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT,
.dstSet = buffer->plain.blend_descriptor_set, .dstSet = buffer->two_pass.blend_descriptor_set,
.dstBinding = 0, .dstBinding = 0,
.pImageInfo = &ds_attach_info, .pImageInfo = &ds_attach_info,
}; };
vkUpdateDescriptorSets(dev, 1, &ds_write, 0, NULL); vkUpdateDescriptorSets(dev, 1, &ds_write, 0, NULL);
VkImageView attachments[] = { VkImageView attachments[] = {
buffer->plain.blend_image_view, buffer->two_pass.blend_image_view,
buffer->plain.image_view buffer->two_pass.image_view,
}; };
VkFramebufferCreateInfo fb_info = { VkFramebufferCreateInfo fb_info = {
.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, .sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO,
@ -796,10 +796,10 @@ bool vulkan_setup_plain_framebuffer(struct wlr_vk_render_buffer *buffer,
.width = dmabuf->width, .width = dmabuf->width,
.height = dmabuf->height, .height = dmabuf->height,
.layers = 1u, .layers = 1u,
.renderPass = buffer->plain.render_setup->render_pass, .renderPass = buffer->two_pass.render_setup->render_pass,
}; };
res = vkCreateFramebuffer(dev, &fb_info, NULL, &buffer->plain.framebuffer); res = vkCreateFramebuffer(dev, &fb_info, NULL, &buffer->two_pass.framebuffer);
if (res != VK_SUCCESS) { if (res != VK_SUCCESS) {
wlr_vk_error("vkCreateFramebuffer", res); wlr_vk_error("vkCreateFramebuffer", res);
goto error; goto error;
@ -824,7 +824,7 @@ static bool vulkan_setup_srgb_framebuffer(struct wlr_vk_render_buffer *buffer,
assert(fmt); assert(fmt);
assert(fmt->format.vk_srgb); assert(fmt->format.vk_srgb);
// Set up the srgb framebuffer by default; plain framebuffer and // Set up the srgb framebuffer by default; two-pass framebuffer and
// blending image will be set up later if necessary // blending image will be set up later if necessary
VkImageViewCreateInfo view_info = { VkImageViewCreateInfo view_info = {
.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
@ -920,8 +920,8 @@ static struct wlr_vk_render_buffer *create_render_buffer(
goto error; goto error;
} }
} else { } else {
// Set up the plain framebuffer & blending image // Set up the two-pass framebuffer & blending image
if (!vulkan_setup_plain_framebuffer(buffer, &dmabuf)) { if (!vulkan_setup_two_pass_framebuffer(buffer, &dmabuf)) {
goto error; goto error;
} }
} }