AuroraMiddleware/gtk
1
0
Fork 1
mirror of https://gitlab.gnome.org/GNOME/gtk.git synced 2024-12-29 06:51:10 +00:00
Code Issues Projects Releases Wiki Activity
b2d22d8125
gtk/gsk/gpu/gskvulkanframe.c

433 lines
15 KiB
C
Raw Normal View History

gpu: Add outline of new GPU renderer For now, it just renders using cairo, uploads the result to the GPU, blits it onto the framebuffer and then is happy. But it can do that using Vulkan and using GL (no idea which version). The most important thing still missing is shaders. It also has a bunch of copy/paste from the Vulkan renderer that isn't used yet. But I didn't want to rip it out and then try to copy it back later
2023-08-12 20:10:16 +00:00
#include "config.h"
#include "gskvulkanframeprivate.h"
#include "gskgpuopprivate.h"
gpu: Add ability to run shaders This heaves over an inital chunk of code from the Vulkan renderer to execute shaders. The only shader that exists for now is a shader that draws a single texture. We use that to replace the blit op we were doing before.
2023-08-21 00:18:37 +00:00
#include "gskvulkanbufferprivate.h"
gpu: Refactor image handling Introduce a new GskGpuImageDescriptors object that tracks descriptors for a set of images that can be managed by the GPU. Then have each GskGpuShaderOp just reference the descriptors object they are using, so that the coe can set things up properly. To reference an image, the ops now just reference their descriptor - which is the uint32 we've been sending to the shaders since forever.
2023-10-03 19:04:21 +00:00
#include "gskvulkandescriptorsprivate.h"
gpu: Add outline of new GPU renderer For now, it just renders using cairo, uploads the result to the GPU, blits it onto the framebuffer and then is happy. But it can do that using Vulkan and using GL (no idea which version). The most important thing still missing is shaders. It also has a bunch of copy/paste from the Vulkan renderer that isn't used yet. But I didn't want to rip it out and then try to copy it back later
2023-08-12 20:10:16 +00:00
#include "gskvulkandeviceprivate.h"
gpu: Add ability to run shaders This heaves over an inital chunk of code from the Vulkan renderer to execute shaders. The only shader that exists for now is a shader that draws a single texture. We use that to replace the blit op we were doing before.
2023-08-21 00:18:37 +00:00
#include "gskvulkanimageprivate.h"
gpu: Add back single descriptors set usage with descriptor indexing
2023-11-05 09:00:11 +00:00
#include "gskvulkanrealdescriptorsprivate.h"
#include "gskvulkansubdescriptorsprivate.h"
gpu: Add outline of new GPU renderer For now, it just renders using cairo, uploads the result to the GPU, blits it onto the framebuffer and then is happy. But it can do that using Vulkan and using GL (no idea which version). The most important thing still missing is shaders. It also has a bunch of copy/paste from the Vulkan renderer that isn't used yet. But I didn't want to rip it out and then try to copy it back later
2023-08-12 20:10:16 +00:00
#include "gdk/gdkdisplayprivate.h"
gpu: Add dmabuf import for Vulkan This now uses all the previously added features to allow displaying YUV images. Also add a utility function that turns an image into a toggle ref for a texture. This makes sure that reffing the image also refs the texture and that ensures that textures stay alive as long as the image is in use.
2023-10-19 11:36:15 +00:00
#include "gdk/gdkdmabuftextureprivate.h"
gpu: Add outline of new GPU renderer For now, it just renders using cairo, uploads the result to the GPU, blits it onto the framebuffer and then is happy. But it can do that using Vulkan and using GL (no idea which version). The most important thing still missing is shaders. It also has a bunch of copy/paste from the Vulkan renderer that isn't used yet. But I didn't want to rip it out and then try to copy it back later
2023-08-12 20:10:16 +00:00
gpu: Handle multiple image descriptors In the case where descriptor indexing is not enabled and the number of max images is small (or we use extensive amounts of immutable samplers), we need to be able to switch descriptors. This patch makes that possible.
2023-11-04 05:11:27 +00:00
#define GDK_ARRAY_NAME gsk_descriptors
#define GDK_ARRAY_TYPE_NAME GskDescriptors
gpu: Add back single descriptors set usage with descriptor indexing
2023-11-05 09:00:11 +00:00
#define GDK_ARRAY_ELEMENT_TYPE GskVulkanRealDescriptors *
gpu: Handle multiple image descriptors In the case where descriptor indexing is not enabled and the number of max images is small (or we use extensive amounts of immutable samplers), we need to be able to switch descriptors. This patch makes that possible.
2023-11-04 05:11:27 +00:00
#define GDK_ARRAY_FREE_FUNC g_object_unref
gpu: Add support for immutable samplers to Vulkan Images can now have samplers - meaning they must be rendered with that sampler. It also means that sampler must be handled as an immutable sampler in descriptorsets. These samplers can be created with a samplerYcbcrConversion, so code has been added to pass that conversion when creating the imageview. Also add code to GskVulkanFrame to track immutable samplers. Nobody is making use of this yet.
2023-10-19 11:30:12 +00:00
#define GDK_ARRAY_NO_MEMSET 1
#include "gdk/gdkarrayimpl.c"
gpu: sync dmabufs via semaphores This ensures both that we signal a semaphore for a dmabuf when we export an image and that we import semaphores for dmabufs and wait on them. Fixes Vulkan node-editor displaying the Vulkan renderer in the sidebar.
2023-11-29 22:14:00 +00:00
#define GDK_ARRAY_NAME gsk_semaphores
#define GDK_ARRAY_TYPE_NAME GskSemaphores
#define GDK_ARRAY_ELEMENT_TYPE VkSemaphore
#define GDK_ARRAY_PREALLOC 16
#define GDK_ARRAY_NO_MEMSET 1
#include "gdk/gdkarrayimpl.c"
#define GDK_ARRAY_NAME gsk_pipeline_stages
#define GDK_ARRAY_TYPE_NAME GskPipelineStages
#define GDK_ARRAY_ELEMENT_TYPE VkPipelineStageFlags
#define GDK_ARRAY_PREALLOC 16
#define GDK_ARRAY_NO_MEMSET 1
#include "gdk/gdkarrayimpl.c"
struct _GskVulkanSemaphores
{
GskSemaphores wait_semaphores;
GskPipelineStages wait_stages;
GskSemaphores signal_semaphores;
};
gpu: Add outline of new GPU renderer For now, it just renders using cairo, uploads the result to the GPU, blits it onto the framebuffer and then is happy. But it can do that using Vulkan and using GL (no idea which version). The most important thing still missing is shaders. It also has a bunch of copy/paste from the Vulkan renderer that isn't used yet. But I didn't want to rip it out and then try to copy it back later
2023-08-12 20:10:16 +00:00
struct _GskVulkanFrame
{
GskGpuFrame parent_instance;
VkFence vk_fence;
VkCommandBuffer vk_command_buffer;
gpu: Add ability to run shaders This heaves over an inital chunk of code from the Vulkan renderer to execute shaders. The only shader that exists for now is a shader that draws a single texture. We use that to replace the blit op we were doing before.
2023-08-21 00:18:37 +00:00
VkDescriptorPool vk_descriptor_pool;
gpu: Handle multiple image descriptors In the case where descriptor indexing is not enabled and the number of max images is small (or we use extensive amounts of immutable samplers), we need to be able to switch descriptors. This patch makes that possible.
2023-11-04 05:11:27 +00:00
GskDescriptors descriptors;
gpu: Set max samplers/buffers based on features If we run older code, we don't have enough samplers and buffers available. So make sure to reflect that.
2023-11-03 01:48:06 +00:00
gsize pool_n_sets;
gpu: Handle multiple image descriptors In the case where descriptor indexing is not enabled and the number of max images is small (or we use extensive amounts of immutable samplers), we need to be able to switch descriptors. This patch makes that possible.
2023-11-04 05:11:27 +00:00
gsize pool_n_images;
gpu: Set max samplers/buffers based on features If we run older code, we don't have enough samplers and buffers available. So make sure to reflect that.
2023-11-03 01:48:06 +00:00
gsize pool_n_buffers;
gpu: Add outline of new GPU renderer For now, it just renders using cairo, uploads the result to the GPU, blits it onto the framebuffer and then is happy. But it can do that using Vulkan and using GL (no idea which version). The most important thing still missing is shaders. It also has a bunch of copy/paste from the Vulkan renderer that isn't used yet. But I didn't want to rip it out and then try to copy it back later
2023-08-12 20:10:16 +00:00
};
struct _GskVulkanFrameClass
{
GskGpuFrameClass parent_class;
};
G_DEFINE_TYPE (GskVulkanFrame, gsk_vulkan_frame, GSK_TYPE_GPU_FRAME)
static gboolean
gsk_vulkan_frame_is_busy (GskGpuFrame *frame)
{
GskVulkanFrame *self = GSK_VULKAN_FRAME (frame);
VkDevice device;
device = gsk_vulkan_device_get_vk_device (GSK_VULKAN_DEVICE (gsk_gpu_frame_get_device (frame)));
return vkGetFenceStatus (device, self->vk_fence) == VK_NOT_READY;
}
static void
gsk_vulkan_frame_setup (GskGpuFrame *frame)
{
GskVulkanFrame *self = GSK_VULKAN_FRAME (frame);
GskVulkanDevice *device;
VkDevice vk_device;
VkCommandPool vk_command_pool;
device = GSK_VULKAN_DEVICE (gsk_gpu_frame_get_device (frame));
vk_device = gsk_vulkan_device_get_vk_device (device);
vk_command_pool = gsk_vulkan_device_get_vk_command_pool (device);
GSK_VK_CHECK (vkAllocateCommandBuffers, vk_device,
&(VkCommandBufferAllocateInfo) {
.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,
.commandPool = vk_command_pool,
.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY,
.commandBufferCount = 1,
},
&self->vk_command_buffer);
GSK_VK_CHECK (vkCreateFence, vk_device,
&(VkFenceCreateInfo) {
.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,
.flags = VK_FENCE_CREATE_SIGNALED_BIT
},
NULL,
&self->vk_fence);
}
static void
gsk_vulkan_frame_cleanup (GskGpuFrame *frame)
{
GskVulkanFrame *self = GSK_VULKAN_FRAME (frame);
gpu: Add GskVulkanPipelineLayout This allows having different layouts sothat we can support immutable samplers, whcih are required for multiplane and YUV formats. We don't use them yet.
2023-10-19 05:43:31 +00:00
GskVulkanDevice *device;
gpu: Add ability to run shaders This heaves over an inital chunk of code from the Vulkan renderer to execute shaders. The only shader that exists for now is a shader that draws a single texture. We use that to replace the blit op we were doing before.
2023-08-21 00:18:37 +00:00
VkDevice vk_device;
gpu: Add outline of new GPU renderer For now, it just renders using cairo, uploads the result to the GPU, blits it onto the framebuffer and then is happy. But it can do that using Vulkan and using GL (no idea which version). The most important thing still missing is shaders. It also has a bunch of copy/paste from the Vulkan renderer that isn't used yet. But I didn't want to rip it out and then try to copy it back later
2023-08-12 20:10:16 +00:00
gpu: Add GskVulkanPipelineLayout This allows having different layouts sothat we can support immutable samplers, whcih are required for multiplane and YUV formats. We don't use them yet.
2023-10-19 05:43:31 +00:00
device = GSK_VULKAN_DEVICE (gsk_gpu_frame_get_device (frame));
vk_device = gsk_vulkan_device_get_vk_device (device);
gpu: Add outline of new GPU renderer For now, it just renders using cairo, uploads the result to the GPU, blits it onto the framebuffer and then is happy. But it can do that using Vulkan and using GL (no idea which version). The most important thing still missing is shaders. It also has a bunch of copy/paste from the Vulkan renderer that isn't used yet. But I didn't want to rip it out and then try to copy it back later
2023-08-12 20:10:16 +00:00
gpu: Add ability to run shaders This heaves over an inital chunk of code from the Vulkan renderer to execute shaders. The only shader that exists for now is a shader that draws a single texture. We use that to replace the blit op we were doing before.
2023-08-21 00:18:37 +00:00
GSK_VK_CHECK (vkWaitForFences, vk_device,
gpu: Add outline of new GPU renderer For now, it just renders using cairo, uploads the result to the GPU, blits it onto the framebuffer and then is happy. But it can do that using Vulkan and using GL (no idea which version). The most important thing still missing is shaders. It also has a bunch of copy/paste from the Vulkan renderer that isn't used yet. But I didn't want to rip it out and then try to copy it back later
2023-08-12 20:10:16 +00:00
1,
&self->vk_fence,
VK_TRUE,
INT64_MAX);
gpu: Add ability to run shaders This heaves over an inital chunk of code from the Vulkan renderer to execute shaders. The only shader that exists for now is a shader that draws a single texture. We use that to replace the blit op we were doing before.
2023-08-21 00:18:37 +00:00
GSK_VK_CHECK (vkResetFences, vk_device,
gpu: Add outline of new GPU renderer For now, it just renders using cairo, uploads the result to the GPU, blits it onto the framebuffer and then is happy. But it can do that using Vulkan and using GL (no idea which version). The most important thing still missing is shaders. It also has a bunch of copy/paste from the Vulkan renderer that isn't used yet. But I didn't want to rip it out and then try to copy it back later
2023-08-12 20:10:16 +00:00
1,
&self->vk_fence);
GSK_VK_CHECK (vkResetCommandBuffer, self->vk_command_buffer,
0);
gpu: Set max samplers/buffers based on features If we run older code, we don't have enough samplers and buffers available. So make sure to reflect that.
2023-11-03 01:48:06 +00:00
if (self->vk_descriptor_pool != VK_NULL_HANDLE)
{
GSK_VK_CHECK (vkResetDescriptorPool, vk_device,
self->vk_descriptor_pool,
0);
}
gpu: Add ability to run shaders This heaves over an inital chunk of code from the Vulkan renderer to execute shaders. The only shader that exists for now is a shader that draws a single texture. We use that to replace the blit op we were doing before.
2023-08-21 00:18:37 +00:00
gpu: Handle multiple image descriptors In the case where descriptor indexing is not enabled and the number of max images is small (or we use extensive amounts of immutable samplers), we need to be able to switch descriptors. This patch makes that possible.
2023-11-04 05:11:27 +00:00
gsk_descriptors_set_size (&self->descriptors, 0);
gpu: Add GskVulkanPipelineLayout This allows having different layouts sothat we can support immutable samplers, whcih are required for multiplane and YUV formats. We don't use them yet.
2023-10-19 05:43:31 +00:00
gpu: Add outline of new GPU renderer For now, it just renders using cairo, uploads the result to the GPU, blits it onto the framebuffer and then is happy. But it can do that using Vulkan and using GL (no idea which version). The most important thing still missing is shaders. It also has a bunch of copy/paste from the Vulkan renderer that isn't used yet. But I didn't want to rip it out and then try to copy it back later
2023-08-12 20:10:16 +00:00
GSK_GPU_FRAME_CLASS (gsk_vulkan_frame_parent_class)->cleanup (frame);
}
gpu: Add dmabuf import for Vulkan This now uses all the previously added features to allow displaying YUV images. Also add a utility function that turns an image into a toggle ref for a texture. This makes sure that reffing the image also refs the texture and that ensures that textures stay alive as long as the image is in use.
2023-10-19 11:36:15 +00:00
static GskGpuImage *
gsk_vulkan_frame_upload_texture (GskGpuFrame *frame,
gpu: Add support for texture-scale nodes This adds GSK_GPU_IMAGE_CAN_MIPMAP and GSK_GPU_IMAGE_MIPMAP flags and support to ensure_image() and image creation functions for creating a mipmapped image. Mipmaps are created using the new mipmap op that uses glGenerateMipmap() on GL and equivalent blit ops on Vulkan. This is then used to ensure the image is mipmapped when rendering it with a texture-scale node.
2023-11-01 05:43:15 +00:00
gboolean with_mipmap,
gpu: Add dmabuf import for Vulkan This now uses all the previously added features to allow displaying YUV images. Also add a utility function that turns an image into a toggle ref for a texture. This makes sure that reffing the image also refs the texture and that ensures that textures stay alive as long as the image is in use.
2023-10-19 11:36:15 +00:00
GdkTexture *texture)
{
#ifdef HAVE_DMABUF
if (GDK_IS_DMABUF_TEXTURE (texture))
{
GskGpuImage *image = gsk_vulkan_image_new_for_dmabuf (GSK_VULKAN_DEVICE (gsk_gpu_frame_get_device (frame)),
texture);
if (image)
return image;
}
#endif
gpu: Add support for texture-scale nodes This adds GSK_GPU_IMAGE_CAN_MIPMAP and GSK_GPU_IMAGE_MIPMAP flags and support to ensure_image() and image creation functions for creating a mipmapped image. Mipmaps are created using the new mipmap op that uses glGenerateMipmap() on GL and equivalent blit ops on Vulkan. This is then used to ensure the image is mipmapped when rendering it with a texture-scale node.
2023-11-01 05:43:15 +00:00
return GSK_GPU_FRAME_CLASS (gsk_vulkan_frame_parent_class)->upload_texture (frame, with_mipmap, texture);
gpu: Add dmabuf import for Vulkan This now uses all the previously added features to allow displaying YUV images. Also add a utility function that turns an image into a toggle ref for a texture. This makes sure that reffing the image also refs the texture and that ensures that textures stay alive as long as the image is in use.
2023-10-19 11:36:15 +00:00
}
gpu: Add ability to run shaders This heaves over an inital chunk of code from the Vulkan renderer to execute shaders. The only shader that exists for now is a shader that draws a single texture. We use that to replace the blit op we were doing before.
2023-08-21 00:18:37 +00:00
static void
gpu: Handle storage buffers via descriptors This makes the (currently single) storage buffer handled by GskGpuDescriptors. A side effect is that we now have support for multiple buffers in place. We just have to use it. Mixed into this commit is a complete rework of the pattern writer. Instead of writing straight into the buffer (complete with repeatedly backtracking when we have to do offscreens), write into a temporary buffer and copy into the storage buffer on committing.
2023-11-19 14:27:10 +00:00
gsk_vulkan_frame_prepare_descriptors (GskVulkanFrame *self)
gpu: Add ability to run shaders This heaves over an inital chunk of code from the Vulkan renderer to execute shaders. The only shader that exists for now is a shader that draws a single texture. We use that to replace the blit op we were doing before.
2023-08-21 00:18:37 +00:00
{
GskVulkanDevice *device;
VkDevice vk_device;
gpu: Make descriptor-indexing optional Do extra work if it's not available.
2023-11-04 18:38:21 +00:00
gsize i, n_images, n_buffers, n_sets;
gpu: Add ability to run shaders This heaves over an inital chunk of code from the Vulkan renderer to execute shaders. The only shader that exists for now is a shader that draws a single texture. We use that to replace the blit op we were doing before.
2023-08-21 00:18:37 +00:00
device = GSK_VULKAN_DEVICE (gsk_gpu_frame_get_device (GSK_GPU_FRAME (self)));
vk_device = gsk_vulkan_device_get_vk_device (device);
gpu: Handle multiple image descriptors In the case where descriptor indexing is not enabled and the number of max images is small (or we use extensive amounts of immutable samplers), we need to be able to switch descriptors. This patch makes that possible.
2023-11-04 05:11:27 +00:00
n_images = 0;
n_buffers = 0;
gpu: Make descriptor-indexing optional Do extra work if it's not available.
2023-11-04 18:38:21 +00:00
n_sets = 2 * gsk_descriptors_get_size (&self->descriptors);
gpu: Handle multiple image descriptors In the case where descriptor indexing is not enabled and the number of max images is small (or we use extensive amounts of immutable samplers), we need to be able to switch descriptors. This patch makes that possible.
2023-11-04 05:11:27 +00:00
for (i = 0; i < gsk_descriptors_get_size (&self->descriptors); i++)
{
gpu: Make descriptor-indexing optional Do extra work if it's not available.
2023-11-04 18:38:21 +00:00
gsize n_desc_images, n_desc_buffers;
gpu: Add back single descriptors set usage with descriptor indexing
2023-11-05 09:00:11 +00:00
GskVulkanRealDescriptors *desc = gsk_descriptors_get (&self->descriptors, i);
gpu: Make VulkanRealDescriptor keep the frame There's too much interaction between the two to warrant not having it around.
2023-11-26 08:28:20 +00:00
gsk_vulkan_real_descriptors_prepare (desc, &n_desc_images, &n_desc_buffers);
gpu: Make descriptor-indexing optional Do extra work if it's not available.
2023-11-04 18:38:21 +00:00
n_images += n_desc_images;
n_buffers += n_desc_buffers;
gpu: Handle multiple image descriptors In the case where descriptor indexing is not enabled and the number of max images is small (or we use extensive amounts of immutable samplers), we need to be able to switch descriptors. This patch makes that possible.
2023-11-04 05:11:27 +00:00
}
gpu: Set max samplers/buffers based on features If we run older code, we don't have enough samplers and buffers available. So make sure to reflect that.
2023-11-03 01:48:06 +00:00
gpu: Make descriptor-indexing optional Do extra work if it's not available.
2023-11-04 18:38:21 +00:00
if (n_sets > self->pool_n_sets ||
n_images > self->pool_n_images ||
gpu: Set max samplers/buffers based on features If we run older code, we don't have enough samplers and buffers available. So make sure to reflect that.
2023-11-03 01:48:06 +00:00
n_buffers > self->pool_n_buffers)
{
if (self->vk_descriptor_pool != VK_NULL_HANDLE)
{
vkDestroyDescriptorPool (vk_device,
self->vk_descriptor_pool,
NULL);
self->vk_descriptor_pool = VK_NULL_HANDLE;
}
gpu: Make descriptor-indexing optional Do extra work if it's not available.
2023-11-04 18:38:21 +00:00
if (n_sets > self->pool_n_sets)
self->pool_n_sets = 4 << g_bit_nth_msf (n_sets - 1, -1);
gpu: Handle multiple image descriptors In the case where descriptor indexing is not enabled and the number of max images is small (or we use extensive amounts of immutable samplers), we need to be able to switch descriptors. This patch makes that possible.
2023-11-04 05:11:27 +00:00
if (n_images > self->pool_n_images)
self->pool_n_images = 2 << g_bit_nth_msf (n_images - 1, -1);
gpu: Set max samplers/buffers based on features If we run older code, we don't have enough samplers and buffers available. So make sure to reflect that.
2023-11-03 01:48:06 +00:00
if (n_buffers > self->pool_n_buffers)
gpu: Make descriptor-indexing optional Do extra work if it's not available.
2023-11-04 18:38:21 +00:00
self->pool_n_buffers = 4 << g_bit_nth_msf (n_buffers - 1, -1);
gpu: Set max samplers/buffers based on features If we run older code, we don't have enough samplers and buffers available. So make sure to reflect that.
2023-11-03 01:48:06 +00:00
}
if (self->vk_descriptor_pool == VK_NULL_HANDLE)
{
GSK_VK_CHECK (vkCreateDescriptorPool, vk_device,
&(VkDescriptorPoolCreateInfo) {
.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO,
gpu: Remove UPDATE_AFTER_BIND flag We don't update after binding.
2023-11-04 05:14:45 +00:00
.flags = 0,
gpu: Set max samplers/buffers based on features If we run older code, we don't have enough samplers and buffers available. So make sure to reflect that.
2023-11-03 01:48:06 +00:00
.maxSets = self->pool_n_sets,
.poolSizeCount = 2,
.pPoolSizes = (VkDescriptorPoolSize[2]) {
{
.type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
gpu: Handle multiple image descriptors In the case where descriptor indexing is not enabled and the number of max images is small (or we use extensive amounts of immutable samplers), we need to be able to switch descriptors. This patch makes that possible.
2023-11-04 05:11:27 +00:00
.descriptorCount = self->pool_n_images,
gpu: Set max samplers/buffers based on features If we run older code, we don't have enough samplers and buffers available. So make sure to reflect that.
2023-11-03 01:48:06 +00:00
},
{
.type = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
.descriptorCount = self->pool_n_buffers,
}
}
},
NULL,
&self->vk_descriptor_pool);
}
gpu: Handle multiple image descriptors In the case where descriptor indexing is not enabled and the number of max images is small (or we use extensive amounts of immutable samplers), we need to be able to switch descriptors. This patch makes that possible.
2023-11-04 05:11:27 +00:00
for (i = 0; i < gsk_descriptors_get_size (&self->descriptors); i++)
gpu: Add ability to run shaders This heaves over an inital chunk of code from the Vulkan renderer to execute shaders. The only shader that exists for now is a shader that draws a single texture. We use that to replace the blit op we were doing before.
2023-08-21 00:18:37 +00:00
{
gpu: Add back single descriptors set usage with descriptor indexing
2023-11-05 09:00:11 +00:00
GskVulkanRealDescriptors *desc = gsk_descriptors_get (&self->descriptors, i);
gpu: Add ability to run shaders This heaves over an inital chunk of code from the Vulkan renderer to execute shaders. The only shader that exists for now is a shader that draws a single texture. We use that to replace the blit op we were doing before.
2023-08-21 00:18:37 +00:00
gpu: Add back single descriptors set usage with descriptor indexing
2023-11-05 09:00:11 +00:00
gsk_vulkan_real_descriptors_update_sets (desc, self->vk_descriptor_pool);
gpu: Handle multiple image descriptors In the case where descriptor indexing is not enabled and the number of max images is small (or we use extensive amounts of immutable samplers), we need to be able to switch descriptors. This patch makes that possible.
2023-11-04 05:11:27 +00:00
}
gpu: Add ability to run shaders This heaves over an inital chunk of code from the Vulkan renderer to execute shaders. The only shader that exists for now is a shader that draws a single texture. We use that to replace the blit op we were doing before.
2023-08-21 00:18:37 +00:00
}
gpu: Refactor image handling Introduce a new GskGpuImageDescriptors object that tracks descriptors for a set of images that can be managed by the GPU. Then have each GskGpuShaderOp just reference the descriptors object they are using, so that the coe can set things up properly. To reference an image, the ops now just reference their descriptor - which is the uint32 we've been sending to the shaders since forever.
2023-10-03 19:04:21 +00:00
static GskGpuDescriptors *
gsk_vulkan_frame_create_descriptors (GskGpuFrame *frame)
{
gpu: Handle multiple image descriptors In the case where descriptor indexing is not enabled and the number of max images is small (or we use extensive amounts of immutable samplers), we need to be able to switch descriptors. This patch makes that possible.
2023-11-04 05:11:27 +00:00
GskVulkanFrame *self = GSK_VULKAN_FRAME (frame);
gpu: Add back single descriptors set usage with descriptor indexing
2023-11-05 09:00:11 +00:00
if (gsk_vulkan_device_has_feature (GSK_VULKAN_DEVICE (gsk_gpu_frame_get_device (frame)), GDK_VULKAN_FEATURE_DESCRIPTOR_INDEXING))
{
GskVulkanRealDescriptors *parent;
if (gsk_descriptors_get_size (&self->descriptors) > 0)
{
parent = gsk_descriptors_get (&self->descriptors, gsk_descriptors_get_size (&self->descriptors) - 1);
if (gsk_vulkan_real_descriptors_is_full (parent))
parent = NULL;
}
else
parent = NULL;
if (parent == NULL)
{
gpu: Make VulkanRealDescriptor keep the frame There's too much interaction between the two to warrant not having it around.
2023-11-26 08:28:20 +00:00
parent = gsk_vulkan_real_descriptors_new (self);
gpu: Add back single descriptors set usage with descriptor indexing
2023-11-05 09:00:11 +00:00
gsk_descriptors_append (&self->descriptors, parent);
}
gpu: Handle multiple image descriptors In the case where descriptor indexing is not enabled and the number of max images is small (or we use extensive amounts of immutable samplers), we need to be able to switch descriptors. This patch makes that possible.
2023-11-04 05:11:27 +00:00
gpu: Add back single descriptors set usage with descriptor indexing
2023-11-05 09:00:11 +00:00
return GSK_GPU_DESCRIPTORS (gsk_vulkan_sub_descriptors_new (GSK_VULKAN_DESCRIPTORS (parent)));
}
else
{
GskVulkanRealDescriptors *desc;
gpu: Make VulkanRealDescriptor keep the frame There's too much interaction between the two to warrant not having it around.
2023-11-26 08:28:20 +00:00
desc = gsk_vulkan_real_descriptors_new (self);
gpu: Add back single descriptors set usage with descriptor indexing
2023-11-05 09:00:11 +00:00
gsk_descriptors_append (&self->descriptors, desc);
return GSK_GPU_DESCRIPTORS (g_object_ref (desc));
}
gpu: Refactor image handling Introduce a new GskGpuImageDescriptors object that tracks descriptors for a set of images that can be managed by the GPU. Then have each GskGpuShaderOp just reference the descriptors object they are using, so that the coe can set things up properly. To reference an image, the ops now just reference their descriptor - which is the uint32 we've been sending to the shaders since forever.
2023-10-03 19:04:21 +00:00
}
gpu: Add ability to run shaders This heaves over an inital chunk of code from the Vulkan renderer to execute shaders. The only shader that exists for now is a shader that draws a single texture. We use that to replace the blit op we were doing before.
2023-08-21 00:18:37 +00:00
static GskGpuBuffer *
gsk_vulkan_frame_create_vertex_buffer (GskGpuFrame *frame,
gsize size)
{
return gsk_vulkan_buffer_new_vertex (GSK_VULKAN_DEVICE (gsk_gpu_frame_get_device (frame)), size);
}
gpu: Add float array to shaders and add an ubershader ... and use it for a naive color node implementation using both so I can test it actually works.
2023-08-30 19:57:41 +00:00
static GskGpuBuffer *
gsk_vulkan_frame_create_storage_buffer (GskGpuFrame *frame,
gsize size)
{
return gsk_vulkan_buffer_new_storage (GSK_VULKAN_DEVICE (gsk_gpu_frame_get_device (frame)), size);
}
gpu: Add outline of new GPU renderer For now, it just renders using cairo, uploads the result to the GPU, blits it onto the framebuffer and then is happy. But it can do that using Vulkan and using GL (no idea which version). The most important thing still missing is shaders. It also has a bunch of copy/paste from the Vulkan renderer that isn't used yet. But I didn't want to rip it out and then try to copy it back later
2023-08-12 20:10:16 +00:00
static void
gpu: Add ability to run shaders This heaves over an inital chunk of code from the Vulkan renderer to execute shaders. The only shader that exists for now is a shader that draws a single texture. We use that to replace the blit op we were doing before.
2023-08-21 00:18:37 +00:00
gsk_vulkan_frame_submit (GskGpuFrame *frame,
GskGpuBuffer *vertex_buffer,
GskGpuOp *op)
gpu: Add outline of new GPU renderer For now, it just renders using cairo, uploads the result to the GPU, blits it onto the framebuffer and then is happy. But it can do that using Vulkan and using GL (no idea which version). The most important thing still missing is shaders. It also has a bunch of copy/paste from the Vulkan renderer that isn't used yet. But I didn't want to rip it out and then try to copy it back later
2023-08-12 20:10:16 +00:00
{
GskVulkanFrame *self = GSK_VULKAN_FRAME (frame);
gpu: sync dmabufs via semaphores This ensures both that we signal a semaphore for a dmabuf when we export an image and that we import semaphores for dmabufs and wait on them. Fixes Vulkan node-editor displaying the Vulkan renderer in the sidebar.
2023-11-29 22:14:00 +00:00
GskVulkanSemaphores semaphores;
gpu: Add a CommandState struct to the command vfuncs This way, we can make it writable and track things like the active textures and the current program. We don't do that yet, but we can.
2023-11-04 02:57:38 +00:00
GskVulkanCommandState state;
gpu: Add outline of new GPU renderer For now, it just renders using cairo, uploads the result to the GPU, blits it onto the framebuffer and then is happy. But it can do that using Vulkan and using GL (no idea which version). The most important thing still missing is shaders. It also has a bunch of copy/paste from the Vulkan renderer that isn't used yet. But I didn't want to rip it out and then try to copy it back later
2023-08-12 20:10:16 +00:00
gpu: Add back single descriptors set usage with descriptor indexing
2023-11-05 09:00:11 +00:00
if (gsk_descriptors_get_size (&self->descriptors) == 0)
gpu: Make VulkanRealDescriptor keep the frame There's too much interaction between the two to warrant not having it around.
2023-11-26 08:28:20 +00:00
gsk_descriptors_append (&self->descriptors, gsk_vulkan_real_descriptors_new (self));
gpu: Add back single descriptors set usage with descriptor indexing
2023-11-05 09:00:11 +00:00
gpu: Handle storage buffers via descriptors This makes the (currently single) storage buffer handled by GskGpuDescriptors. A side effect is that we now have support for multiple buffers in place. We just have to use it. Mixed into this commit is a complete rework of the pattern writer. Instead of writing straight into the buffer (complete with repeatedly backtracking when we have to do offscreens), write into a temporary buffer and copy into the storage buffer on committing.
2023-11-19 14:27:10 +00:00
gsk_vulkan_frame_prepare_descriptors (self);
gpu: Make PipelineLayout objects do more things Let the objects track the number of samplers or buffers needed. This is a required step for making Vulkan work with less featureful (read: mobile) implementations.
2023-11-03 00:59:24 +00:00
gpu: Add outline of new GPU renderer For now, it just renders using cairo, uploads the result to the GPU, blits it onto the framebuffer and then is happy. But it can do that using Vulkan and using GL (no idea which version). The most important thing still missing is shaders. It also has a bunch of copy/paste from the Vulkan renderer that isn't used yet. But I didn't want to rip it out and then try to copy it back later
2023-08-12 20:10:16 +00:00
GSK_VK_CHECK (vkBeginCommandBuffer, self->vk_command_buffer,
&(VkCommandBufferBeginInfo) {
.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,
});
gpu: Add ability to run shaders This heaves over an inital chunk of code from the Vulkan renderer to execute shaders. The only shader that exists for now is a shader that draws a single texture. We use that to replace the blit op we were doing before.
2023-08-21 00:18:37 +00:00
if (vertex_buffer)
vkCmdBindVertexBuffers (self->vk_command_buffer,
0,
1,
(VkBuffer[1]) {
gsk_vulkan_buffer_get_vk_buffer (GSK_VULKAN_BUFFER (vertex_buffer))
},
(VkDeviceSize[1]) { 0 });
gpu: sync dmabufs via semaphores This ensures both that we signal a semaphore for a dmabuf when we export an image and that we import semaphores for dmabufs and wait on them. Fixes Vulkan node-editor displaying the Vulkan renderer in the sidebar.
2023-11-29 22:14:00 +00:00
gsk_semaphores_init (&semaphores.wait_semaphores);
gsk_pipeline_stages_init (&semaphores.wait_stages);
gsk_semaphores_init (&semaphores.signal_semaphores);
gpu: Add a CommandState struct to the command vfuncs This way, we can make it writable and track things like the active textures and the current program. We don't do that yet, but we can.
2023-11-04 02:57:38 +00:00
state.vk_command_buffer = self->vk_command_buffer;
state.vk_render_pass = VK_NULL_HANDLE;
state.vk_format = VK_FORMAT_UNDEFINED;
gpu: Make blend modes configurable For now, we only have OVER and ADD blend modes. This commit doesn't use ADD, it just sets up all the machinery and refactors things.
2023-12-25 04:21:13 +00:00
state.blend = GSK_GPU_BLEND_OVER; /* should we have a BLEND_NONE? */
gpu: Add back single descriptors set usage with descriptor indexing
2023-11-05 09:00:11 +00:00
state.desc = GSK_VULKAN_DESCRIPTORS (gsk_descriptors_get (&self->descriptors, 0));
gpu: sync dmabufs via semaphores This ensures both that we signal a semaphore for a dmabuf when we export an image and that we import semaphores for dmabufs and wait on them. Fixes Vulkan node-editor displaying the Vulkan renderer in the sidebar.
2023-11-29 22:14:00 +00:00
state.semaphores = &semaphores;
gpu: Add back single descriptors set usage with descriptor indexing
2023-11-05 09:00:11 +00:00
gsk_vulkan_descriptors_bind (GSK_VULKAN_DESCRIPTORS (gsk_descriptors_get (&self->descriptors, 0)),
NULL,
state.vk_command_buffer);
gpu: Add a CommandState struct to the command vfuncs This way, we can make it writable and track things like the active textures and the current program. We don't do that yet, but we can.
2023-11-04 02:57:38 +00:00
gpu: Add outline of new GPU renderer For now, it just renders using cairo, uploads the result to the GPU, blits it onto the framebuffer and then is happy. But it can do that using Vulkan and using GL (no idea which version). The most important thing still missing is shaders. It also has a bunch of copy/paste from the Vulkan renderer that isn't used yet. But I didn't want to rip it out and then try to copy it back later
2023-08-12 20:10:16 +00:00
while (op)
{
gpu: Add a CommandState struct to the command vfuncs This way, we can make it writable and track things like the active textures and the current program. We don't do that yet, but we can.
2023-11-04 02:57:38 +00:00
op = gsk_gpu_op_vk_command (op, frame, &state);
gpu: Add outline of new GPU renderer For now, it just renders using cairo, uploads the result to the GPU, blits it onto the framebuffer and then is happy. But it can do that using Vulkan and using GL (no idea which version). The most important thing still missing is shaders. It also has a bunch of copy/paste from the Vulkan renderer that isn't used yet. But I didn't want to rip it out and then try to copy it back later
2023-08-12 20:10:16 +00:00
}
GSK_VK_CHECK (vkEndCommandBuffer, self->vk_command_buffer);
GSK_VK_CHECK (vkQueueSubmit, gsk_vulkan_device_get_vk_queue (GSK_VULKAN_DEVICE (gsk_gpu_frame_get_device (frame))),
1,
&(VkSubmitInfo) {
.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO,
.commandBufferCount = 1,
.pCommandBuffers = &self->vk_command_buffer,
gpu: sync dmabufs via semaphores This ensures both that we signal a semaphore for a dmabuf when we export an image and that we import semaphores for dmabufs and wait on them. Fixes Vulkan node-editor displaying the Vulkan renderer in the sidebar.
2023-11-29 22:14:00 +00:00
.pWaitSemaphores = gsk_semaphores_get_data (&semaphores.wait_semaphores),
.pWaitDstStageMask = gsk_pipeline_stages_get_data (&semaphores.wait_stages),
.waitSemaphoreCount = gsk_semaphores_get_size (&semaphores.wait_semaphores),
.pSignalSemaphores = gsk_semaphores_get_data (&semaphores.signal_semaphores),
.signalSemaphoreCount = gsk_semaphores_get_size (&semaphores.signal_semaphores),
gpu: Add outline of new GPU renderer For now, it just renders using cairo, uploads the result to the GPU, blits it onto the framebuffer and then is happy. But it can do that using Vulkan and using GL (no idea which version). The most important thing still missing is shaders. It also has a bunch of copy/paste from the Vulkan renderer that isn't used yet. But I didn't want to rip it out and then try to copy it back later
2023-08-12 20:10:16 +00:00
},
self->vk_fence);
gpu: sync dmabufs via semaphores This ensures both that we signal a semaphore for a dmabuf when we export an image and that we import semaphores for dmabufs and wait on them. Fixes Vulkan node-editor displaying the Vulkan renderer in the sidebar.
2023-11-29 22:14:00 +00:00
gsk_semaphores_clear (&semaphores.wait_semaphores);
gsk_pipeline_stages_clear (&semaphores.wait_stages);
gsk_semaphores_clear (&semaphores.signal_semaphores);
gpu: Add outline of new GPU renderer For now, it just renders using cairo, uploads the result to the GPU, blits it onto the framebuffer and then is happy. But it can do that using Vulkan and using GL (no idea which version). The most important thing still missing is shaders. It also has a bunch of copy/paste from the Vulkan renderer that isn't used yet. But I didn't want to rip it out and then try to copy it back later
2023-08-12 20:10:16 +00:00
}
static void
gsk_vulkan_frame_finalize (GObject *object)
{
GskVulkanFrame *self = GSK_VULKAN_FRAME (object);
GskVulkanDevice *device;
VkDevice vk_device;
VkCommandPool vk_command_pool;
device = GSK_VULKAN_DEVICE (gsk_gpu_frame_get_device (GSK_GPU_FRAME (self)));
vk_device = gsk_vulkan_device_get_vk_device (device);
vk_command_pool = gsk_vulkan_device_get_vk_command_pool (device);
gpu: Set max samplers/buffers based on features If we run older code, we don't have enough samplers and buffers available. So make sure to reflect that.
2023-11-03 01:48:06 +00:00
if (self->vk_descriptor_pool != VK_NULL_HANDLE)
{
vkDestroyDescriptorPool (vk_device,
self->vk_descriptor_pool,
NULL);
}
gpu: Handle multiple image descriptors In the case where descriptor indexing is not enabled and the number of max images is small (or we use extensive amounts of immutable samplers), we need to be able to switch descriptors. This patch makes that possible.
2023-11-04 05:11:27 +00:00
gsk_descriptors_clear (&self->descriptors);
gpu: Add ability to run shaders This heaves over an inital chunk of code from the Vulkan renderer to execute shaders. The only shader that exists for now is a shader that draws a single texture. We use that to replace the blit op we were doing before.
2023-08-21 00:18:37 +00:00
gpu: Add outline of new GPU renderer For now, it just renders using cairo, uploads the result to the GPU, blits it onto the framebuffer and then is happy. But it can do that using Vulkan and using GL (no idea which version). The most important thing still missing is shaders. It also has a bunch of copy/paste from the Vulkan renderer that isn't used yet. But I didn't want to rip it out and then try to copy it back later
2023-08-12 20:10:16 +00:00
vkFreeCommandBuffers (vk_device,
vk_command_pool,
1, &self->vk_command_buffer);
vkDestroyFence (vk_device,
self->vk_fence,
NULL);
G_OBJECT_CLASS (gsk_vulkan_frame_parent_class)->finalize (object);
}
static void
gsk_vulkan_frame_class_init (GskVulkanFrameClass *klass)
{
GskGpuFrameClass *gpu_frame_class = GSK_GPU_FRAME_CLASS (klass);
GObjectClass *object_class = G_OBJECT_CLASS (klass);
gpu_frame_class->is_busy = gsk_vulkan_frame_is_busy;
gpu_frame_class->setup = gsk_vulkan_frame_setup;
gpu_frame_class->cleanup = gsk_vulkan_frame_cleanup;
gpu: Add dmabuf import for Vulkan This now uses all the previously added features to allow displaying YUV images. Also add a utility function that turns an image into a toggle ref for a texture. This makes sure that reffing the image also refs the texture and that ensures that textures stay alive as long as the image is in use.
2023-10-19 11:36:15 +00:00
gpu_frame_class->upload_texture = gsk_vulkan_frame_upload_texture;
gpu: Refactor image handling Introduce a new GskGpuImageDescriptors object that tracks descriptors for a set of images that can be managed by the GPU. Then have each GskGpuShaderOp just reference the descriptors object they are using, so that the coe can set things up properly. To reference an image, the ops now just reference their descriptor - which is the uint32 we've been sending to the shaders since forever.
2023-10-03 19:04:21 +00:00
gpu_frame_class->create_descriptors = gsk_vulkan_frame_create_descriptors;
gpu: Add ability to run shaders This heaves over an inital chunk of code from the Vulkan renderer to execute shaders. The only shader that exists for now is a shader that draws a single texture. We use that to replace the blit op we were doing before.
2023-08-21 00:18:37 +00:00
gpu_frame_class->create_vertex_buffer = gsk_vulkan_frame_create_vertex_buffer;
gpu: Add float array to shaders and add an ubershader ... and use it for a naive color node implementation using both so I can test it actually works.
2023-08-30 19:57:41 +00:00
gpu_frame_class->create_storage_buffer = gsk_vulkan_frame_create_storage_buffer;
gpu: Add outline of new GPU renderer For now, it just renders using cairo, uploads the result to the GPU, blits it onto the framebuffer and then is happy. But it can do that using Vulkan and using GL (no idea which version). The most important thing still missing is shaders. It also has a bunch of copy/paste from the Vulkan renderer that isn't used yet. But I didn't want to rip it out and then try to copy it back later
2023-08-12 20:10:16 +00:00
gpu_frame_class->submit = gsk_vulkan_frame_submit;
object_class->finalize = gsk_vulkan_frame_finalize;
}
static void
gsk_vulkan_frame_init (GskVulkanFrame *self)
{
gpu: Handle multiple image descriptors In the case where descriptor indexing is not enabled and the number of max images is small (or we use extensive amounts of immutable samplers), we need to be able to switch descriptors. This patch makes that possible.
2023-11-04 05:11:27 +00:00
gsk_descriptors_init (&self->descriptors);
gpu: Set max samplers/buffers based on features If we run older code, we don't have enough samplers and buffers available. So make sure to reflect that.
2023-11-03 01:48:06 +00:00
self->pool_n_sets = 4;
gpu: Handle multiple image descriptors In the case where descriptor indexing is not enabled and the number of max images is small (or we use extensive amounts of immutable samplers), we need to be able to switch descriptors. This patch makes that possible.
2023-11-04 05:11:27 +00:00
self->pool_n_images = 8;
gpu: Set max samplers/buffers based on features If we run older code, we don't have enough samplers and buffers available. So make sure to reflect that.
2023-11-03 01:48:06 +00:00
self->pool_n_buffers = 8;
gpu: Add outline of new GPU renderer For now, it just renders using cairo, uploads the result to the GPU, blits it onto the framebuffer and then is happy. But it can do that using Vulkan and using GL (no idea which version). The most important thing still missing is shaders. It also has a bunch of copy/paste from the Vulkan renderer that isn't used yet. But I didn't want to rip it out and then try to copy it back later
2023-08-12 20:10:16 +00:00
}
VkFence
gsk_vulkan_frame_get_vk_fence (GskVulkanFrame *self)
{
return self->vk_fence;
}
gpu: Add GskVulkanPipelineLayout This allows having different layouts sothat we can support immutable samplers, whcih are required for multiplane and YUV formats. We don't use them yet.
2023-10-19 05:43:31 +00:00
gpu: sync dmabufs via semaphores This ensures both that we signal a semaphore for a dmabuf when we export an image and that we import semaphores for dmabufs and wait on them. Fixes Vulkan node-editor displaying the Vulkan renderer in the sidebar.
2023-11-29 22:14:00 +00:00
void
gsk_vulkan_semaphores_add_wait (GskVulkanSemaphores *self,
VkSemaphore semaphore,
VkPipelineStageFlags stage)
{
gsk_semaphores_append (&self->wait_semaphores, semaphore);
gsk_pipeline_stages_append (&self->wait_stages, stage);
}
void
gsk_vulkan_semaphores_add_signal (GskVulkanSemaphores *self,
VkSemaphore semaphore)
{
gsk_semaphores_append (&self->signal_semaphores, semaphore);
}
Reference in New Issue Copy Permalink