AuroraMiddleware/gtk
1
0
Fork 1
mirror of https://gitlab.gnome.org/GNOME/gtk.git synced 2024-12-26 21:51:08 +00:00
Code Issues Projects Releases Wiki Activity
413d3819cf
gtk/gsk/vulkan/gskvulkanrenderpassop.c

328 lines
11 KiB
C
Raw Normal View History

vulkan: Rename offscreenp to renderpassop They should be used for all renderpasses, not just offscreens.
2023-07-09 20:33:54 +00:00
#include "config.h"
#include "gskvulkanrenderpassopprivate.h"
#include "gskrendernodeprivate.h"
#include "gskvulkanprivate.h"
vulkan: Redo barriers We now store all the relevant state of the image inside the VulkanImage struct, so we can delay barriers for as long as possible. Whenever we want to use an image, we call the new gsk_vulkan_image_transition() and it will add a barrier to the desired state if one is necessary.
2023-07-15 20:19:20 +00:00
#include "gskvulkanshaderopprivate.h"
vulkan: Rename offscreenp to renderpassop They should be used for all renderpasses, not just offscreens.
2023-07-09 20:33:54 +00:00
#include "gdk/gdkvulkancontextprivate.h"
typedef struct _GskVulkanRenderPassOp GskVulkanRenderPassOp;
struct _GskVulkanRenderPassOp
{
GskVulkanOp op;
GskVulkanImage *image;
GskVulkanRenderPass *render_pass;
vulkan: Fold functions into only caller Now that the VulkanOp does begin/end of render passes, there's no need to have a renderpass function for it anymore.
2023-07-13 12:30:16 +00:00
cairo_rectangle_int_t area;
graphene_size_t viewport_size;
VkImageLayout initial_layout;
VkImageLayout final_layout;
vulkan: Rename offscreenp to renderpassop They should be used for all renderpasses, not just offscreens.
2023-07-09 20:33:54 +00:00
};
static void
gsk_vulkan_render_pass_op_finish (GskVulkanOp *op)
{
GskVulkanRenderPassOp *self = (GskVulkanRenderPassOp *) op;
g_object_unref (self->image);
gsk_vulkan_render_pass_free (self->render_pass);
}
static void
gsk_vulkan_render_pass_op_print (GskVulkanOp *op,
GString *string,
guint indent)
{
GskVulkanRenderPassOp *self = (GskVulkanRenderPassOp *) op;
print_indent (string, indent);
g_string_append_printf (string, "begin-render-pass %zux%zu ",
gsk_vulkan_image_get_width (self->image),
gsk_vulkan_image_get_height (self->image));
print_newline (string);
}
static gsize
gsk_vulkan_render_pass_op_count_vertex_data (GskVulkanOp *op,
gsize n_bytes)
{
return n_bytes;
}
static void
gsk_vulkan_render_pass_op_collect_vertex_data (GskVulkanOp *op,
guchar *data)
{
}
static void
gsk_vulkan_render_pass_op_reserve_descriptor_sets (GskVulkanOp *op,
GskVulkanRender *render)
{
}
vulkan: Redo barriers We now store all the relevant state of the image inside the VulkanImage struct, so we can delay barriers for as long as possible. Whenever we want to use an image, we call the new gsk_vulkan_image_transition() and it will add a barrier to the desired state if one is necessary.
2023-07-15 20:19:20 +00:00
static void
gsk_vulkan_render_pass_op_do_barriers (GskVulkanRenderPassOp *self,
VkCommandBuffer command_buffer)
{
GskVulkanShaderOp *shader;
GskVulkanOp *op;
gsize i;
for (op = ((GskVulkanOp *) self)->next;
op->op_class->stage != GSK_VULKAN_STAGE_END_PASS;
op = op->next)
{
if (op->op_class->stage != GSK_VULKAN_STAGE_SHADER)
continue;
shader = (GskVulkanShaderOp *) op;
for (i = 0; i < ((GskVulkanShaderOpClass *) op->op_class)->n_images; i++)
{
gsk_vulkan_image_transition (shader->images[i],
command_buffer,
VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
VK_ACCESS_SHADER_READ_BIT);
}
}
}
vulkan: Rename offscreenp to renderpassop They should be used for all renderpasses, not just offscreens.
2023-07-09 20:33:54 +00:00
static GskVulkanOp *
gsk_vulkan_render_pass_op_command (GskVulkanOp *op,
GskVulkanRender *render,
vulkan: Introduce GskVulkanShaderOp It's the new base class for shaders now. We're doing deep inheritance now, woohoo! Also, port all the shader ops to it.
2023-07-15 09:39:18 +00:00
VkRenderPass render_pass,
vulkan: Rename offscreenp to renderpassop They should be used for all renderpasses, not just offscreens.
2023-07-09 20:33:54 +00:00
VkCommandBuffer command_buffer)
{
GskVulkanRenderPassOp *self = (GskVulkanRenderPassOp *) op;
vulkan: Merge function into only caller The renderpass reshuffling means we can move a bunch of functions now. This is one of them.
2023-07-13 09:17:04 +00:00
VkRenderPass vk_render_pass;
vulkan: Introduce GskVulkanShaderOp It's the new base class for shaders now. We're doing deep inheritance now, woohoo! Also, port all the shader ops to it.
2023-07-15 09:39:18 +00:00
/* nesting render passes not allowed */
g_assert (render_pass == VK_NULL_HANDLE);
vulkan: Redo barriers We now store all the relevant state of the image inside the VulkanImage struct, so we can delay barriers for as long as possible. Whenever we want to use an image, we call the new gsk_vulkan_image_transition() and it will add a barrier to the desired state if one is necessary.
2023-07-15 20:19:20 +00:00
gsk_vulkan_render_pass_op_do_barriers (self, command_buffer);
vulkan: Fold functions into only caller Now that the VulkanOp does begin/end of render passes, there's no need to have a renderpass function for it anymore.
2023-07-13 12:30:16 +00:00
vk_render_pass = gsk_vulkan_render_get_render_pass (render,
gsk_vulkan_image_get_vk_format (self->image),
self->initial_layout,
self->final_layout);
vkCmdSetViewport (command_buffer,
0,
1,
&(VkViewport) {
.x = 0,
.y = 0,
.width = self->viewport_size.width,
.height = self->viewport_size.height,
.minDepth = 0,
.maxDepth = 1
});
vkCmdBeginRenderPass (command_buffer,
&(VkRenderPassBeginInfo) {
.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,
.renderPass = vk_render_pass,
.framebuffer = gsk_vulkan_image_get_framebuffer (self->image,
vk_render_pass),
.renderArea = {
{ self->area.x, self->area.y },
{ self->area.width, self->area.height }
},
.clearValueCount = 1,
.pClearValues = (VkClearValue [1]) {
{ .color = { .float32 = { 0.f, 0.f, 0.f, 0.f } } }
}
},
VK_SUBPASS_CONTENTS_INLINE);
vulkan: Merge function into only caller The renderpass reshuffling means we can move a bunch of functions now. This is one of them.
2023-07-13 09:17:04 +00:00
op = op->next;
vulkan: Simplify The renderpassop always has a matching end op, so there is no need to check for the end of operations and emit one manually.
2023-07-13 09:23:02 +00:00
while (op->op_class->stage != GSK_VULKAN_STAGE_END_PASS)
vulkan: Merge function into only caller The renderpass reshuffling means we can move a bunch of functions now. This is one of them.
2023-07-13 09:17:04 +00:00
{
vulkan: Introduce GskVulkanShaderOp It's the new base class for shaders now. We're doing deep inheritance now, woohoo! Also, port all the shader ops to it.
2023-07-15 09:39:18 +00:00
op = gsk_vulkan_op_command (op, render, vk_render_pass, command_buffer);
vulkan: Merge function into only caller The renderpass reshuffling means we can move a bunch of functions now. This is one of them.
2023-07-13 09:17:04 +00:00
}
vulkan: Introduce GskVulkanShaderOp It's the new base class for shaders now. We're doing deep inheritance now, woohoo! Also, port all the shader ops to it.
2023-07-15 09:39:18 +00:00
op = gsk_vulkan_op_command (op, render, vk_render_pass, command_buffer);
vulkan: Merge function into only caller The renderpass reshuffling means we can move a bunch of functions now. This is one of them.
2023-07-13 09:17:04 +00:00
return op;
vulkan: Rename offscreenp to renderpassop They should be used for all renderpasses, not just offscreens.
2023-07-09 20:33:54 +00:00
}
static const GskVulkanOpClass GSK_VULKAN_RENDER_PASS_OP_CLASS = {
GSK_VULKAN_OP_SIZE (GskVulkanRenderPassOp),
GSK_VULKAN_STAGE_BEGIN_PASS,
gsk_vulkan_render_pass_op_finish,
gsk_vulkan_render_pass_op_print,
gsk_vulkan_render_pass_op_count_vertex_data,
gsk_vulkan_render_pass_op_collect_vertex_data,
gsk_vulkan_render_pass_op_reserve_descriptor_sets,
gsk_vulkan_render_pass_op_command
};
typedef struct _GskVulkanRenderPassEndOp GskVulkanRenderPassEndOp;
struct _GskVulkanRenderPassEndOp
{
GskVulkanOp op;
GskVulkanImage *image;
vulkan: Properly update image layouts The render pass ops were not updating the image's layout to the final layout when a render pass ends. Fix that. Also make the layouts explicit arguments to the render pass op.
2023-07-14 21:05:19 +00:00
VkImageLayout final_layout;
vulkan: Rename offscreenp to renderpassop They should be used for all renderpasses, not just offscreens.
2023-07-09 20:33:54 +00:00
};
static void
gsk_vulkan_render_pass_end_op_finish (GskVulkanOp *op)
{
GskVulkanRenderPassEndOp *self = (GskVulkanRenderPassEndOp *) op;
g_object_unref (self->image);
}
static void
gsk_vulkan_render_pass_end_op_print (GskVulkanOp *op,
GString *string,
guint indent)
{
GskVulkanRenderPassEndOp *self = (GskVulkanRenderPassEndOp *) op;
print_indent (string, indent);
g_string_append_printf (string, "end-render-pass ");
print_image (string, self->image);
print_newline (string);
}
static gsize
gsk_vulkan_render_pass_end_op_count_vertex_data (GskVulkanOp *op,
gsize n_bytes)
{
return n_bytes;
}
static void
gsk_vulkan_render_pass_end_op_collect_vertex_data (GskVulkanOp *op,
guchar *data)
{
}
static void
gsk_vulkan_render_pass_end_op_reserve_descriptor_sets (GskVulkanOp *op,
GskVulkanRender *render)
{
}
static GskVulkanOp *
gsk_vulkan_render_pass_end_op_command (GskVulkanOp *op,
GskVulkanRender *render,
vulkan: Introduce GskVulkanShaderOp It's the new base class for shaders now. We're doing deep inheritance now, woohoo! Also, port all the shader ops to it.
2023-07-15 09:39:18 +00:00
VkRenderPass render_pass,
vulkan: Rename offscreenp to renderpassop They should be used for all renderpasses, not just offscreens.
2023-07-09 20:33:54 +00:00
VkCommandBuffer command_buffer)
{
vulkan: Properly update image layouts The render pass ops were not updating the image's layout to the final layout when a render pass ends. Fix that. Also make the layouts explicit arguments to the render pass op.
2023-07-14 21:05:19 +00:00
GskVulkanRenderPassEndOp *self = (GskVulkanRenderPassEndOp *) op;
vulkan: Rename offscreenp to renderpassop They should be used for all renderpasses, not just offscreens.
2023-07-09 20:33:54 +00:00
vkCmdEndRenderPass (command_buffer);
vulkan: Properly update image layouts The render pass ops were not updating the image's layout to the final layout when a render pass ends. Fix that. Also make the layouts explicit arguments to the render pass op.
2023-07-14 21:05:19 +00:00
gsk_vulkan_image_set_vk_image_layout (self->image,
vulkan: Track the current pipeline stage of images This way, we can in theory properly transition images because we know which stage to transition from. IN practice this is happening in future commits.
2023-07-15 14:38:03 +00:00
VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
vulkan: Properly update image layouts The render pass ops were not updating the image's layout to the final layout when a render pass ends. Fix that. Also make the layouts explicit arguments to the render pass op.
2023-07-14 21:05:19 +00:00
self->final_layout,
vulkan: Redo barriers We now store all the relevant state of the image inside the VulkanImage struct, so we can delay barriers for as long as possible. Whenever we want to use an image, we call the new gsk_vulkan_image_transition() and it will add a barrier to the desired state if one is necessary.
2023-07-15 20:19:20 +00:00
VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT);
vulkan: Rename offscreenp to renderpassop They should be used for all renderpasses, not just offscreens.
2023-07-09 20:33:54 +00:00
return op->next;
}
static const GskVulkanOpClass GSK_VULKAN_RENDER_PASS_END_OP_CLASS = {
GSK_VULKAN_OP_SIZE (GskVulkanRenderPassEndOp),
GSK_VULKAN_STAGE_END_PASS,
gsk_vulkan_render_pass_end_op_finish,
gsk_vulkan_render_pass_end_op_print,
gsk_vulkan_render_pass_end_op_count_vertex_data,
gsk_vulkan_render_pass_end_op_collect_vertex_data,
gsk_vulkan_render_pass_end_op_reserve_descriptor_sets,
gsk_vulkan_render_pass_end_op_command
};
vulkan: Emit a renderpass op ... instead of doing the equivalent things manually by creating a RenderPass and calling the relevant functions. Now all renderpass operations are indeed stored in ops. Also reshuffle the command emission code, because we no longer need to emit the ops for the base renderpass. As a result we only submit a single command buffer containing all the render passes instead of once per render pass. We also bind vertex buffers and descriptor sets only once now at the start instead of once per renderpass.
2023-07-10 01:42:55 +00:00
void
gsk_vulkan_render_pass_op (GskVulkanRender *render,
GdkVulkanContext *context,
GskVulkanImage *image,
cairo_region_t *clip,
const graphene_vec2_t *scale,
const graphene_rect_t *viewport,
GskRenderNode *node,
vulkan: Properly update image layouts The render pass ops were not updating the image's layout to the final layout when a render pass ends. Fix that. Also make the layouts explicit arguments to the render pass op.
2023-07-14 21:05:19 +00:00
VkImageLayout initial_layout,
VkImageLayout final_layout)
vulkan: Emit a renderpass op ... instead of doing the equivalent things manually by creating a RenderPass and calling the relevant functions. Now all renderpass operations are indeed stored in ops. Also reshuffle the command emission code, because we no longer need to emit the ops for the base renderpass. As a result we only submit a single command buffer containing all the render passes instead of once per render pass. We also bind vertex buffers and descriptor sets only once now at the start instead of once per renderpass.
2023-07-10 01:42:55 +00:00
{
GskVulkanRenderPassOp *self;
GskVulkanRenderPassEndOp *end;
self = (GskVulkanRenderPassOp *) gsk_vulkan_op_alloc (render, &GSK_VULKAN_RENDER_PASS_OP_CLASS);
self->image = image;
vulkan: Properly update image layouts The render pass ops were not updating the image's layout to the final layout when a render pass ends. Fix that. Also make the layouts explicit arguments to the render pass op.
2023-07-14 21:05:19 +00:00
self->initial_layout = initial_layout;
self->final_layout = final_layout;
vulkan: Fold functions into only caller Now that the VulkanOp does begin/end of render passes, there's no need to have a renderpass function for it anymore.
2023-07-13 12:30:16 +00:00
cairo_region_get_extents (clip, &self->area);
self->viewport_size = viewport->size;
vulkan: Emit a renderpass op ... instead of doing the equivalent things manually by creating a RenderPass and calling the relevant functions. Now all renderpass operations are indeed stored in ops. Also reshuffle the command emission code, because we no longer need to emit the ops for the base renderpass. As a result we only submit a single command buffer containing all the render passes instead of once per render pass. We also bind vertex buffers and descriptor sets only once now at the start instead of once per renderpass.
2023-07-10 01:42:55 +00:00
self->render_pass = gsk_vulkan_render_pass_new (context,
render,
self->image,
scale,
viewport,
clip,
vulkan: Fold functions into only caller Now that the VulkanOp does begin/end of render passes, there's no need to have a renderpass function for it anymore.
2023-07-13 12:30:16 +00:00
node);
vulkan: Emit a renderpass op ... instead of doing the equivalent things manually by creating a RenderPass and calling the relevant functions. Now all renderpass operations are indeed stored in ops. Also reshuffle the command emission code, because we no longer need to emit the ops for the base renderpass. As a result we only submit a single command buffer containing all the render passes instead of once per render pass. We also bind vertex buffers and descriptor sets only once now at the start instead of once per renderpass.
2023-07-10 01:42:55 +00:00
/* This invalidates the self pointer */
gsk_vulkan_render_pass_add (self->render_pass, render, node);
end = (GskVulkanRenderPassEndOp *) gsk_vulkan_op_alloc (render, &GSK_VULKAN_RENDER_PASS_END_OP_CLASS);
end->image = g_object_ref (image);
vulkan: Properly update image layouts The render pass ops were not updating the image's layout to the final layout when a render pass ends. Fix that. Also make the layouts explicit arguments to the render pass op.
2023-07-14 21:05:19 +00:00
end->final_layout = final_layout;
vulkan: Emit a renderpass op ... instead of doing the equivalent things manually by creating a RenderPass and calling the relevant functions. Now all renderpass operations are indeed stored in ops. Also reshuffle the command emission code, because we no longer need to emit the ops for the base renderpass. As a result we only submit a single command buffer containing all the render passes instead of once per render pass. We also bind vertex buffers and descriptor sets only once now at the start instead of once per renderpass.
2023-07-10 01:42:55 +00:00
}
vulkan: Rename offscreenp to renderpassop They should be used for all renderpasses, not just offscreens.
2023-07-09 20:33:54 +00:00
GskVulkanImage *
gsk_vulkan_render_pass_op_offscreen (GskVulkanRender *render,
GdkVulkanContext *context,
const graphene_vec2_t *scale,
const graphene_rect_t *viewport,
GskRenderNode *node)
{
graphene_rect_t view;
vulkan: Emit a renderpass op ... instead of doing the equivalent things manually by creating a RenderPass and calling the relevant functions. Now all renderpass operations are indeed stored in ops. Also reshuffle the command emission code, because we no longer need to emit the ops for the base renderpass. As a result we only submit a single command buffer containing all the render passes instead of once per render pass. We also bind vertex buffers and descriptor sets only once now at the start instead of once per renderpass.
2023-07-10 01:42:55 +00:00
GskVulkanImage *image;
vulkan: Rename offscreenp to renderpassop They should be used for all renderpasses, not just offscreens.
2023-07-09 20:33:54 +00:00
cairo_region_t *clip;
float scale_x, scale_y;
scale_x = graphene_vec2_get_x (scale);
scale_y = graphene_vec2_get_y (scale);
view = GRAPHENE_RECT_INIT (scale_x * viewport->origin.x,
scale_y * viewport->origin.y,
ceil (scale_x * viewport->size.width),
ceil (scale_y * viewport->size.height));
image = gsk_vulkan_image_new_for_offscreen (context,
gdk_vulkan_context_get_offscreen_format (context,
gsk_render_node_get_preferred_depth (node)),
view.size.width, view.size.height);
clip = cairo_region_create_rectangle (&(cairo_rectangle_int_t) {
0, 0,
vulkan: Emit a renderpass op ... instead of doing the equivalent things manually by creating a RenderPass and calling the relevant functions. Now all renderpass operations are indeed stored in ops. Also reshuffle the command emission code, because we no longer need to emit the ops for the base renderpass. As a result we only submit a single command buffer containing all the render passes instead of once per render pass. We also bind vertex buffers and descriptor sets only once now at the start instead of once per renderpass.
2023-07-10 01:42:55 +00:00
gsk_vulkan_image_get_width (image),
gsk_vulkan_image_get_height (image)
vulkan: Rename offscreenp to renderpassop They should be used for all renderpasses, not just offscreens.
2023-07-09 20:33:54 +00:00
});
vulkan: Emit a renderpass op ... instead of doing the equivalent things manually by creating a RenderPass and calling the relevant functions. Now all renderpass operations are indeed stored in ops. Also reshuffle the command emission code, because we no longer need to emit the ops for the base renderpass. As a result we only submit a single command buffer containing all the render passes instead of once per render pass. We also bind vertex buffers and descriptor sets only once now at the start instead of once per renderpass.
2023-07-10 01:42:55 +00:00
gsk_vulkan_render_pass_op (render,
context,
image,
clip,
scale,
&view,
node,
vulkan: Properly update image layouts The render pass ops were not updating the image's layout to the final layout when a render pass ends. Fix that. Also make the layouts explicit arguments to the render pass op.
2023-07-14 21:05:19 +00:00
VK_IMAGE_LAYOUT_UNDEFINED,
VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
vulkan: Rename offscreenp to renderpassop They should be used for all renderpasses, not just offscreens.
2023-07-09 20:33:54 +00:00
cairo_region_destroy (clip);
vulkan: Emit a renderpass op ... instead of doing the equivalent things manually by creating a RenderPass and calling the relevant functions. Now all renderpass operations are indeed stored in ops. Also reshuffle the command emission code, because we no longer need to emit the ops for the base renderpass. As a result we only submit a single command buffer containing all the render passes instead of once per render pass. We also bind vertex buffers and descriptor sets only once now at the start instead of once per renderpass.
2023-07-10 01:42:55 +00:00
return image;
vulkan: Rename offscreenp to renderpassop They should be used for all renderpasses, not just offscreens.
2023-07-09 20:33:54 +00:00
}
Reference in New Issue Copy Permalink