mirror of
https://gitlab.gnome.org/GNOME/gtk.git
synced 2024-09-21 22:34:05 +00:00
ac9d48151b
That way we can reuse them. We only create a new one if the last render operation hasn't finished executing.
364 lines
12 KiB
C
364 lines
12 KiB
C
#include "config.h"
|
|
|
|
#include "gskvulkanrenderprivate.h"
|
|
|
|
#include "gskrendererprivate.h"
|
|
#include "gskvulkanbufferprivate.h"
|
|
#include "gskvulkanpipelineprivate.h"
|
|
#include "gskvulkanrenderpassprivate.h"
|
|
|
|
#define ORTHO_NEAR_PLANE -10000
|
|
#define ORTHO_FAR_PLANE 10000
|
|
|
|
struct _GskVulkanRender
|
|
{
|
|
GskRenderer *renderer;
|
|
GdkVulkanContext *vulkan;
|
|
|
|
graphene_matrix_t mvp;
|
|
int scale_factor;
|
|
VkExtent2D size;
|
|
VkRect2D scissor;
|
|
|
|
VkCommandPool command_pool;
|
|
VkFence fence;
|
|
|
|
VkCommandBuffer command_buffer;
|
|
|
|
GSList *render_passes;
|
|
GSList *cleanup_images;
|
|
};
|
|
|
|
static void
|
|
gsk_vulkan_render_compute_mvp (GskVulkanRender *self)
|
|
{
|
|
GdkWindow *window = gsk_renderer_get_window (self->renderer);
|
|
graphene_matrix_t modelview, projection;
|
|
cairo_rectangle_int_t extents;
|
|
|
|
cairo_region_get_extents (gdk_drawing_context_get_clip (gsk_renderer_get_drawing_context (self->renderer)),
|
|
&extents);
|
|
|
|
self->scale_factor = gsk_renderer_get_scale_factor (self->renderer);
|
|
self->size.width = gdk_window_get_width (window) * self->scale_factor;
|
|
self->size.height = gdk_window_get_height (window) * self->scale_factor;
|
|
self->scissor.offset.x = extents.x * self->scale_factor;
|
|
self->scissor.offset.y = extents.y * self->scale_factor;
|
|
self->scissor.extent.width = extents.width * self->scale_factor;
|
|
self->scissor.extent.height = extents.height * self->scale_factor;
|
|
|
|
graphene_matrix_init_scale (&modelview, self->scale_factor, self->scale_factor, 1.0);
|
|
graphene_matrix_init_ortho (&projection,
|
|
0, self->size.width,
|
|
0, self->size.height,
|
|
ORTHO_NEAR_PLANE,
|
|
ORTHO_FAR_PLANE);
|
|
graphene_matrix_multiply (&modelview, &projection, &self->mvp);
|
|
}
|
|
|
|
GskVulkanRender *
|
|
gsk_vulkan_render_new (GskRenderer *renderer,
|
|
GdkVulkanContext *context)
|
|
{
|
|
GskVulkanRender *self;
|
|
VkDevice device;
|
|
|
|
self = g_slice_new0 (GskVulkanRender);
|
|
|
|
self->vulkan = context;
|
|
self->renderer = renderer;
|
|
|
|
device = gdk_vulkan_context_get_device (self->vulkan);
|
|
|
|
GSK_VK_CHECK (vkCreateCommandPool, device,
|
|
&(const VkCommandPoolCreateInfo) {
|
|
.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,
|
|
.queueFamilyIndex = gdk_vulkan_context_get_queue_family_index (self->vulkan),
|
|
.flags = 0
|
|
},
|
|
NULL,
|
|
&self->command_pool);
|
|
|
|
GSK_VK_CHECK (vkCreateFence, device,
|
|
&(VkFenceCreateInfo) {
|
|
.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,
|
|
.flags = VK_FENCE_CREATE_SIGNALED_BIT
|
|
},
|
|
NULL,
|
|
&self->fence);
|
|
|
|
return self;
|
|
}
|
|
|
|
void
|
|
gsk_vulkan_render_add_cleanup_image (GskVulkanRender *self,
|
|
GskVulkanImage *image)
|
|
{
|
|
self->cleanup_images = g_slist_prepend (self->cleanup_images, image);
|
|
}
|
|
|
|
void
|
|
gsk_vulkan_render_add_node (GskVulkanRender *self,
|
|
GskRenderNode *node)
|
|
{
|
|
GskVulkanRenderPass *pass = gsk_vulkan_render_pass_new (self->vulkan);
|
|
|
|
self->render_passes = g_slist_prepend (self->render_passes, pass);
|
|
|
|
gsk_vulkan_render_pass_add_node (pass, self, node);
|
|
}
|
|
|
|
void
|
|
gsk_vulkan_render_upload (GskVulkanRender *self)
|
|
{
|
|
GSList *l;
|
|
|
|
for (l = self->render_passes; l; l = l->next)
|
|
{
|
|
gsk_vulkan_render_pass_upload (l->data, self, self->command_buffer);
|
|
}
|
|
}
|
|
|
|
static gsize
|
|
gsk_vulkan_renderer_count_vertices (GskVulkanRender *self)
|
|
{
|
|
gsize count;
|
|
GSList *l;
|
|
|
|
count = 0;
|
|
for (l = self->render_passes; l; l = l->next)
|
|
{
|
|
count += gsk_vulkan_render_pass_count_vertices (l->data);
|
|
}
|
|
|
|
return count;
|
|
}
|
|
|
|
static GskVulkanBuffer *
|
|
gsk_vulkan_render_collect_vertices (GskVulkanRender *self)
|
|
{
|
|
GskVulkanBuffer *buffer;
|
|
GskVulkanVertex *vertices;
|
|
GSList *l;
|
|
gsize offset, count;
|
|
|
|
offset = 0;
|
|
count = gsk_vulkan_renderer_count_vertices (self);
|
|
buffer = gsk_vulkan_buffer_new (self->vulkan, sizeof (GskVulkanVertex) * count);
|
|
vertices = (GskVulkanVertex *) gsk_vulkan_buffer_map (buffer);
|
|
|
|
for (l = self->render_passes; l; l = l->next)
|
|
{
|
|
offset += gsk_vulkan_render_pass_collect_vertices (l->data, vertices, offset, count - offset);
|
|
g_assert (offset <= count);
|
|
}
|
|
|
|
gsk_vulkan_buffer_unmap (buffer);
|
|
|
|
return buffer;
|
|
}
|
|
|
|
void
|
|
gsk_vulkan_render_draw (GskVulkanRender *self,
|
|
GskVulkanPipeline *pipeline,
|
|
VkRenderPass render_pass,
|
|
VkFramebuffer framebuffer,
|
|
VkDescriptorSet descriptor_set,
|
|
VkSampler sampler)
|
|
{
|
|
GskVulkanBuffer *buffer;
|
|
GSList *l;
|
|
|
|
buffer = gsk_vulkan_render_collect_vertices (self);
|
|
|
|
for (l = self->render_passes; l; l = l->next)
|
|
{
|
|
gsk_vulkan_render_pass_update_descriptor_sets (l->data, descriptor_set, sampler);
|
|
}
|
|
|
|
vkCmdSetViewport (self->command_buffer,
|
|
0,
|
|
1,
|
|
&(VkViewport) {
|
|
.x = 0,
|
|
.y = 0,
|
|
.width = self->size.width,
|
|
.height = self->size.height,
|
|
.minDepth = 0,
|
|
.maxDepth = 1
|
|
});
|
|
|
|
vkCmdSetScissor (self->command_buffer,
|
|
0,
|
|
1,
|
|
&self->scissor);
|
|
|
|
vkCmdBeginRenderPass (self->command_buffer,
|
|
&(VkRenderPassBeginInfo) {
|
|
.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,
|
|
.renderPass = render_pass,
|
|
.framebuffer = framebuffer,
|
|
.renderArea = {
|
|
{ 0, 0 },
|
|
{ self->size.width, self->size.height }
|
|
},
|
|
.clearValueCount = 1,
|
|
.pClearValues = (VkClearValue [1]) {
|
|
{ .color = { .float32 = { 0.f, 0.f, 0.f, 0.f } } }
|
|
}
|
|
},
|
|
VK_SUBPASS_CONTENTS_INLINE);
|
|
|
|
vkCmdBindPipeline (self->command_buffer,
|
|
VK_PIPELINE_BIND_POINT_GRAPHICS,
|
|
gsk_vulkan_pipeline_get_pipeline (pipeline));
|
|
|
|
vkCmdBindDescriptorSets (self->command_buffer,
|
|
VK_PIPELINE_BIND_POINT_GRAPHICS,
|
|
gsk_vulkan_pipeline_get_pipeline_layout (pipeline),
|
|
0,
|
|
1,
|
|
&descriptor_set,
|
|
0,
|
|
NULL);
|
|
|
|
vkCmdBindVertexBuffers (self->command_buffer,
|
|
0,
|
|
1,
|
|
(VkBuffer[1]) {
|
|
gsk_vulkan_buffer_get_buffer (buffer)
|
|
},
|
|
(VkDeviceSize[1]) { 0 });
|
|
|
|
vkCmdPushConstants (self->command_buffer,
|
|
gsk_vulkan_pipeline_get_pipeline_layout (pipeline),
|
|
VK_SHADER_STAGE_VERTEX_BIT,
|
|
0,
|
|
sizeof (graphene_matrix_t),
|
|
&self->mvp);
|
|
|
|
for (l = self->render_passes; l; l = l->next)
|
|
{
|
|
gsk_vulkan_render_pass_draw (l->data, self, self->command_buffer);
|
|
}
|
|
|
|
vkCmdEndRenderPass (self->command_buffer);
|
|
|
|
gsk_vulkan_buffer_free (buffer);
|
|
}
|
|
|
|
void
|
|
gsk_vulkan_render_submit (GskVulkanRender *self)
|
|
{
|
|
GSK_VK_CHECK (vkEndCommandBuffer, self->command_buffer);
|
|
|
|
GSK_VK_CHECK (vkQueueSubmit, gdk_vulkan_context_get_queue (self->vulkan),
|
|
1,
|
|
&(VkSubmitInfo) {
|
|
.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO,
|
|
.waitSemaphoreCount = 1,
|
|
.pWaitSemaphores = (VkSemaphore[1]) {
|
|
gdk_vulkan_context_get_draw_semaphore (self->vulkan)
|
|
},
|
|
.pWaitDstStageMask = (VkPipelineStageFlags []) {
|
|
VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
|
|
},
|
|
.commandBufferCount = 1,
|
|
.pCommandBuffers = &self->command_buffer,
|
|
.signalSemaphoreCount = 1,
|
|
.pSignalSemaphores = (VkSemaphore[1]) {
|
|
gdk_vulkan_context_get_draw_semaphore (self->vulkan)
|
|
}
|
|
},
|
|
self->fence);
|
|
|
|
GSK_VK_CHECK (vkWaitForFences, gdk_vulkan_context_get_device (self->vulkan),
|
|
1,
|
|
&self->fence,
|
|
VK_TRUE,
|
|
INT64_MAX);
|
|
}
|
|
|
|
static void
|
|
gsk_vulkan_render_cleanup (GskVulkanRender *self)
|
|
{
|
|
VkDevice device = gdk_vulkan_context_get_device (self->vulkan);
|
|
|
|
/* XXX: Wait for fence here or just in reset()? */
|
|
GSK_VK_CHECK (vkWaitForFences, device,
|
|
1,
|
|
&self->fence,
|
|
VK_TRUE,
|
|
INT64_MAX);
|
|
|
|
GSK_VK_CHECK (vkResetFences, device,
|
|
1,
|
|
&self->fence);
|
|
GSK_VK_CHECK (vkResetCommandPool, device,
|
|
self->command_pool,
|
|
0);
|
|
|
|
g_slist_free_full (self->render_passes, (GDestroyNotify) gsk_vulkan_render_pass_free);
|
|
self->render_passes = NULL;
|
|
g_slist_free_full (self->cleanup_images, (GDestroyNotify) gsk_vulkan_image_free);
|
|
self->cleanup_images = NULL;
|
|
}
|
|
|
|
void
|
|
gsk_vulkan_render_free (GskVulkanRender *self)
|
|
{
|
|
VkDevice device;
|
|
|
|
gsk_vulkan_render_cleanup (self);
|
|
|
|
device = gdk_vulkan_context_get_device (self->vulkan);
|
|
|
|
vkDestroyFence (device,
|
|
self->fence,
|
|
NULL);
|
|
vkDestroyCommandPool (device,
|
|
self->command_pool,
|
|
NULL);
|
|
|
|
g_slice_free (GskVulkanRender, self);
|
|
}
|
|
|
|
gboolean
|
|
gsk_vulkan_render_is_busy (GskVulkanRender *self)
|
|
{
|
|
return vkGetFenceStatus (gdk_vulkan_context_get_device (self->vulkan), self->fence) != VK_SUCCESS;
|
|
}
|
|
|
|
void
|
|
gsk_vulkan_render_reset (GskVulkanRender *self)
|
|
{
|
|
VkDevice device;
|
|
|
|
gsk_vulkan_render_cleanup (self);
|
|
|
|
gsk_vulkan_render_compute_mvp (self);
|
|
|
|
device = gdk_vulkan_context_get_device (self->vulkan);
|
|
|
|
GSK_VK_CHECK (vkAllocateCommandBuffers, device,
|
|
&(VkCommandBufferAllocateInfo) {
|
|
.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,
|
|
.commandPool = self->command_pool,
|
|
.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY,
|
|
.commandBufferCount = 1,
|
|
},
|
|
&self->command_buffer);
|
|
|
|
GSK_VK_CHECK (vkBeginCommandBuffer, self->command_buffer,
|
|
&(VkCommandBufferBeginInfo) {
|
|
.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
|
|
.flags = 0
|
|
});
|
|
}
|
|
|
|
GskRenderer *
|
|
gsk_vulkan_render_get_renderer (GskVulkanRender *self)
|
|
{
|
|
return self->renderer;
|
|
}
|