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;
struct wlr_vk_descriptor_pool *blend_attachment_pool;
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);
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;
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 {
enum wlr_color_transfer_function tf = WLR_COLOR_TRANSFER_FUNCTION_SRGB;
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) {
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;
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;
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;
}
@ -268,7 +268,7 @@ static bool render_pass_submit(struct wlr_render_pass *wlr_pass) {
lut_ds = renderer->output_ds_lut3d_dummy;
}
VkDescriptorSet ds[] = {
render_buffer->plain.blend_descriptor_set, // set 0
render_buffer->two_pass.blend_descriptor_set, // set 0
lut_ds, // set 1
};
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;
}
} else {
if (!render_buffer->plain.transitioned) {
if (!render_buffer->two_pass.transitioned) {
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
// color attachment to read only, so on each frame, before
// the render pass starts, we change it back
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;
render_buffer->plain.blend_transitioned = true;
render_buffer->two_pass.blend_transitioned = true;
}
VkImageMemoryBarrier blend_acq_barrier = {
.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
.srcQueueFamilyIndex = 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,
.newLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
.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 ?
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(
setup,
&(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 ?
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(
setup,
&(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;
}
if (!using_srgb_pathway && !buffer->plain.image_view) {
if (!using_srgb_pathway && !buffer->two_pass.image_view) {
struct wlr_dmabuf_attributes 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");
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.framebuffer = buffer->srgb.framebuffer;
} else {
rp_info.renderPass = buffer->plain.render_setup->render_pass;
rp_info.framebuffer = buffer->plain.framebuffer;
rp_info.renderPass = buffer->two_pass.render_setup->render_pass;
rp_info.framebuffer = buffer->two_pass.framebuffer;
}
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);
vkDestroyImageView(dev, buffer->srgb.image_view, NULL);
vkDestroyFramebuffer(dev, buffer->plain.framebuffer, NULL);
vkDestroyImageView(dev, buffer->plain.image_view, NULL);
vkDestroyImage(dev, buffer->plain.blend_image, NULL);
vkFreeMemory(dev, buffer->plain.blend_memory, NULL);
vkDestroyImageView(dev, buffer->plain.blend_image_view, NULL);
if (buffer->plain.blend_attachment_pool) {
vulkan_free_ds(buffer->renderer, buffer->plain.blend_attachment_pool,
buffer->plain.blend_descriptor_set);
vkDestroyFramebuffer(dev, buffer->two_pass.framebuffer, NULL);
vkDestroyImageView(dev, buffer->two_pass.image_view, NULL);
vkDestroyImage(dev, buffer->two_pass.blend_image, NULL);
vkFreeMemory(dev, buffer->two_pass.blend_memory, NULL);
vkDestroyImageView(dev, buffer->two_pass.blend_image_view, NULL);
if (buffer->two_pass.blend_attachment_pool) {
vulkan_free_ds(buffer->renderer, buffer->two_pass.blend_attachment_pool,
buffer->two_pass.blend_descriptor_set);
}
vkDestroyImage(dev, buffer->image, NULL);
@ -648,7 +648,7 @@ static struct wlr_addon_interface render_buffer_addon_impl = {
.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) {
struct wlr_vk_renderer *renderer = buffer->renderer;
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) {
wlr_vk_error("vkCreateImageView failed", res);
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);
if (!buffer->plain.render_setup) {
if (!buffer->two_pass.render_setup) {
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,
};
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) {
wlr_vk_error("vkCreateImage failed", res);
goto error;
}
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,
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,
};
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) {
wlr_vk_error("vkAllocatorMemory failed", res);
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) {
wlr_vk_error("vkBindMemory failed", res);
goto error;
@ -740,7 +740,7 @@ bool vulkan_setup_plain_framebuffer(struct wlr_vk_render_buffer *buffer,
VkImageViewCreateInfo blend_view_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,
.format = img_info.format,
.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) {
wlr_vk_error("vkCreateImageView failed", res);
goto error;
}
buffer->plain.blend_attachment_pool = vulkan_alloc_blend_ds(renderer,
&buffer->plain.blend_descriptor_set);
if (!buffer->plain.blend_attachment_pool) {
buffer->two_pass.blend_attachment_pool = vulkan_alloc_blend_ds(renderer,
&buffer->two_pass.blend_descriptor_set);
if (!buffer->two_pass.blend_attachment_pool) {
wlr_log(WLR_ERROR, "failed to allocate descriptor");
goto error;
}
VkDescriptorImageInfo ds_attach_info = {
.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,
};
VkWriteDescriptorSet ds_write = {
.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
.descriptorCount = 1,
.descriptorType = VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT,
.dstSet = buffer->plain.blend_descriptor_set,
.dstSet = buffer->two_pass.blend_descriptor_set,
.dstBinding = 0,
.pImageInfo = &ds_attach_info,
};
vkUpdateDescriptorSets(dev, 1, &ds_write, 0, NULL);
VkImageView attachments[] = {
buffer->plain.blend_image_view,
buffer->plain.image_view
buffer->two_pass.blend_image_view,
buffer->two_pass.image_view,
};
VkFramebufferCreateInfo fb_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,
.height = dmabuf->height,
.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) {
wlr_vk_error("vkCreateFramebuffer", res);
goto error;
@ -824,7 +824,7 @@ static bool vulkan_setup_srgb_framebuffer(struct wlr_vk_render_buffer *buffer,
assert(fmt);
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
VkImageViewCreateInfo view_info = {
.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
@ -920,8 +920,8 @@ static struct wlr_vk_render_buffer *create_render_buffer(
goto error;
}
} else {
// Set up the plain framebuffer & blending image
if (!vulkan_setup_plain_framebuffer(buffer, &dmabuf)) {
// Set up the two-pass framebuffer & blending image
if (!vulkan_setup_two_pass_framebuffer(buffer, &dmabuf)) {
goto error;
}
}