AuroraMiddleware/gtk
1
0
Fork 1
mirror of https://gitlab.gnome.org/GNOME/gtk.git synced 2024-12-27 14:10:30 +00:00
Code Issues Projects Releases Wiki Activity
73f1dfc762
gtk/gsk/vulkan/gskvulkanrender.c

852 lines
36 KiB
C
Raw Normal View History

vulkan: Add GskVulkanRender object This is refactoring work. GskVulkanRender is supposed to be the global object for a render operation, ie GskVulkanRenderer.render() will create this object for what it does. The object will be split into stages that perform the operations necessary to create a drawing.
2016-12-07 13:50:52 +00:00
#include "config.h"
gsk: Include the private header Both gskprivate.c and gskvulkanrenderer.c call `gsk_ensure_resources` but fail in clude `gskprivate.h`, where the function is declared.
2017-04-18 14:14:35 +00:00
#include "gskprivate.h"
vulkan: Add GskVulkanRender object This is refactoring work. GskVulkanRender is supposed to be the global object for a render operation, ie GskVulkanRenderer.render() will create this object for what it does. The object will be split into stages that perform the operations necessary to create a drawing.
2016-12-07 13:50:52 +00:00
#include "gskvulkanrenderprivate.h"
vulkan: Add GskVulkanRenderPass And move the actual rendering code there. A RenderPass is a collection of operations on the same target that get executed one after another. It roughly targets VkRenderPass or rather the subpasses of a VkRenderPass. For now, only the infrastructure is there. No real stuff is happening.
2016-12-08 12:26:36 +00:00
#include "gskrendererprivate.h"
#include "gskvulkanbufferprivate.h"
vulkan: Split out command pool This way we can pass the command pool around. And that allows us to allocate and submitcustom buffers. And that is necessary to make staging images work.
2016-12-16 05:10:24 +00:00
#include "gskvulkancommandpoolprivate.h"
vulkan: Make glyphs use new node ops This is a rudimentary - but working - port. Glyph uploads are still using the old machinery, a bunch of functions still exist that probably aren't necessary anymore and each glyph emits its own node. This will need to be improved in further commits.
2023-07-03 07:15:04 +00:00
#include "gskvulkanglyphcacheprivate.h"
vulkan: Add gskvulkanprivate.h It's the new place for all the common stuff. Because the old place is about to go away.
2023-07-03 13:57:30 +00:00
#include "gskvulkanprivate.h"
vulkan: Turn push constants into an op This removes the last remaining original op from the gskvulkanrenderpass.c, so that file got some cleanup, too.
2023-07-03 13:47:53 +00:00
#include "gskvulkanpushconstantsopprivate.h"
vulkan: Make glyphs use new node ops This is a rudimentary - but working - port. Glyph uploads are still using the old machinery, a bunch of functions still exist that probably aren't necessary anymore and each glyph emits its own node. This will need to be improved in further commits.
2023-07-03 07:15:04 +00:00
#include "gskvulkanrendererprivate.h"
vulkan: Add GskVulkanRenderPass And move the actual rendering code there. A RenderPass is a collection of operations on the same target that get executed one after another. It roughly targets VkRenderPass or rather the subpasses of a VkRenderPass. For now, only the infrastructure is there. No real stuff is happening.
2016-12-08 12:26:36 +00:00
#include "gskvulkanrenderpassprivate.h"
vulkan: Create pipeline differently for ops Instead of creating a pipeline GObject, just ask for the VkPipeline. And instead of having the Op handle it, just let the renderpass look up/create the relevant pipeline while creating commands so that it can insert vkCmdBindPipeline calls as-needed.
2023-06-29 04:36:17 +00:00
#include "gdk/gdkvulkancontextprivate.h"
vulkan: Implement bindless texture rendering Instead of having a descriptor set per operation, we just have one descriptor set and bind all our images into it. Then the shaders get to use an index into the large texture array instead. Getting this to work - because it's a Vulkan extension that needs to be manually enabled, even though it's officially part of Vulkan 1.2 - is insane.
2023-05-20 00:56:02 +00:00
#define DESCRIPTOR_POOL_MAXITEMS 50000
#define GDK_ARRAY_NAME gsk_descriptor_image_infos
#define GDK_ARRAY_TYPE_NAME GskDescriptorImageInfos
#define GDK_ARRAY_ELEMENT_TYPE VkDescriptorImageInfo
#define GDK_ARRAY_BY_VALUE 1
#define GDK_ARRAY_PREALLOC 1024
#define GDK_ARRAY_NO_MEMSET 1
#include "gdk/gdkarrayimpl.c"
vulkan: Redo descriptor set handling First, we collect all the info about descriptor sets into a hash table, then we use its size to determine the amount of sets and allocate those before we finally go ahead and use the hash table's contents to initialize the descriptor sets. And then we're ready to render.
2016-12-09 01:55:47 +00:00
vulkan: Add support for storage buffers And add a default storage buffer that is used for per-frame temporary data. So far nothing is using this code, this is just infrastructure.
2023-05-25 20:21:23 +00:00
#define GDK_ARRAY_NAME gsk_descriptor_buffer_infos
#define GDK_ARRAY_TYPE_NAME GskDescriptorBufferInfos
#define GDK_ARRAY_ELEMENT_TYPE VkDescriptorBufferInfo
#define GDK_ARRAY_BY_VALUE 1
#define GDK_ARRAY_PREALLOC 1024
#define GDK_ARRAY_NO_MEMSET 1
#include "gdk/gdkarrayimpl.c"
vulkan: Combine textures and samplers again This reverts most of commit f420c143e0d8947a433704969bab02aea47d82f5 again because it turns out GPUs like combined images and samplers. But: The one thing we don't revert is allowing the C code to select any combination of sampler and image: gsk_vulkan_render_get_image_descriptor() now takes a 2nd argument specifying the sampler. This allows the same flexibility as before, we just combine things early. This change was inspired by https://developer.nvidia.com/blog/vulkan-dos-donts/
2023-06-28 18:50:43 +00:00
#define N_DESCRIPTOR_SETS 2
vulkan: Use 3 descriptor sets, not 3 bindings It turns out variable length is only supported for the last binding in a set, not for every binding. So we need to create one set for each of our arrays. [ VUID-VkDescriptorSetLayoutBindingFlagsCreateInfo-pBindingFlags-03004 ] Object 0: handle = 0x33a9f10, type = VK_OBJECT_TYPE_DEVICE; | MessageID = 0xd3f353a | vkCreateDescriptorSetLayout(): pBindings[0] has VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT but 0 is the largest value of all the bindings. The Vulkan spec states: If an element of pBindingFlags includes VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT, then all other elements of VkDescriptorSetLayoutCreateInfo::pBindings must have a smaller value of binding (https://www.khronos.org/registry/vulkan/specs/1.3-extensions/html/vkspec.html#VUID-VkDescriptorSetLayoutBindingFlagsCreateInfo-pBindingFlags-03004)
2023-06-20 13:39:29 +00:00
vulkan: Make the GskVulkanRender struct private
2016-12-08 16:55:32 +00:00
struct _GskVulkanRender
{
GskRenderer *renderer;
GdkVulkanContext *vulkan;
vulkan: Support fractional scaling Basically what GL does, but without any debug or feature flag to gatekeep it, since the Vulkan backend itself is experimental already. Ceil surface sizes, and floor coordinates, to the fractional scale value.
2023-04-03 13:39:25 +00:00
double scale;
Small simplification Just keep the viewport as a graphene_rect_t, we don't need to use the Vulkan type here.
2017-09-30 14:42:32 +00:00
graphene_rect_t viewport;
vulkan: Only render minimal region It's faster to render once for every rectangle in the clip region than rendering the outline of the clip region. Especially because this reduces the time necessary to build up the frame data. In widget-factory (where we have 3 rectangles), this leads to a 5x speedup in the rendering time rendering alone. Snapshotting time goes from 10ms to ~1ms, which is another huge improvement.
2016-12-26 23:18:52 +00:00
cairo_region_t *clip;
vulkan: Make the GskVulkanRender struct private
2016-12-08 16:55:32 +00:00
vulkan: Split out command pool This way we can pass the command pool around. And that allows us to allocate and submitcustom buffers. And that is necessary to make staging images work.
2016-12-16 05:10:24 +00:00
GskVulkanCommandPool *command_pool;
vulkan: Move command pool and fence into render object
2016-12-08 17:03:05 +00:00
VkFence fence;
vulkan: Use 3 descriptor sets, not 3 bindings It turns out variable length is only supported for the last binding in a set, not for every binding. So we need to create one set for each of our arrays. [ VUID-VkDescriptorSetLayoutBindingFlagsCreateInfo-pBindingFlags-03004 ] Object 0: handle = 0x33a9f10, type = VK_OBJECT_TYPE_DEVICE; | MessageID = 0xd3f353a | vkCreateDescriptorSetLayout(): pBindings[0] has VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT but 0 is the largest value of all the bindings. The Vulkan spec states: If an element of pBindingFlags includes VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT, then all other elements of VkDescriptorSetLayoutCreateInfo::pBindings must have a smaller value of binding (https://www.khronos.org/registry/vulkan/specs/1.3-extensions/html/vkspec.html#VUID-VkDescriptorSetLayoutBindingFlagsCreateInfo-pBindingFlags-03004)
2023-06-20 13:39:29 +00:00
VkDescriptorSetLayout descriptor_set_layouts[N_DESCRIPTOR_SETS];
vulkan: Only use a single pipeline layout There's no need to use 3 different ones when they are compatible.
2023-05-12 18:49:31 +00:00
VkPipelineLayout pipeline_layout;
vulkan: Add GskVulkanUploader It's the thing that makes sure pixels end up on the GPU.
2016-12-17 03:22:44 +00:00
GskVulkanUploader *uploader;
vulkan: Redo descriptor set handling First, we collect all the info about descriptor sets into a hash table, then we use its size to determine the amount of sets and allocate those before we finally go ahead and use the hash table's contents to initialize the descriptor sets. And then we're ready to render.
2016-12-09 01:55:47 +00:00
vulkan: Split textures and samplers The idea here is that we can do more complex combinations and use that to support texture-scale nodes or use fancy texture formats (suc as YUV). I'm not sure this is actually necessary, but for now it gives more flexibility.
2023-05-23 03:08:13 +00:00
GskDescriptorImageInfos descriptor_images;
vulkan: Add support for storage buffers And add a default storage buffer that is used for per-frame temporary data. So far nothing is using this code, this is just infrastructure.
2023-05-25 20:21:23 +00:00
GskDescriptorBufferInfos descriptor_buffers;
vulkan: Move remaining structs to VulkanRender object It now gets to maintain things.
2016-12-08 23:06:59 +00:00
VkDescriptorPool descriptor_pool;
vulkan: Use 3 descriptor sets, not 3 bindings It turns out variable length is only supported for the last binding in a set, not for every binding. So we need to create one set for each of our arrays. [ VUID-VkDescriptorSetLayoutBindingFlagsCreateInfo-pBindingFlags-03004 ] Object 0: handle = 0x33a9f10, type = VK_OBJECT_TYPE_DEVICE; | MessageID = 0xd3f353a | vkCreateDescriptorSetLayout(): pBindings[0] has VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT but 0 is the largest value of all the bindings. The Vulkan spec states: If an element of pBindingFlags includes VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT, then all other elements of VkDescriptorSetLayoutCreateInfo::pBindings must have a smaller value of binding (https://www.khronos.org/registry/vulkan/specs/1.3-extensions/html/vkspec.html#VUID-VkDescriptorSetLayoutBindingFlagsCreateInfo-pBindingFlags-03004)
2023-06-20 13:39:29 +00:00
VkDescriptorSet descriptor_sets[N_DESCRIPTOR_SETS];
vulkan: Create pipeline differently for ops Instead of creating a pipeline GObject, just ask for the VkPipeline. And instead of having the Op handle it, just let the renderpass look up/create the relevant pipeline while creating commands so that it can insert vkCmdBindPipeline calls as-needed.
2023-06-29 04:36:17 +00:00
GHashTable *pipeline_cache;
vulkan: Move command pool and fence into render object
2016-12-08 17:03:05 +00:00
vulkan: Create framebuffers from GskVulkanRender object Also create them on-demand, as they need to be created per-image and per-framebuffer, so we don't want to create loads of them.
2016-12-08 21:35:16 +00:00
GskVulkanImage *target;
vulkan: Add support for texture-scale nodes
2023-05-23 03:26:08 +00:00
VkSampler samplers[3];
vulkan: Add support for storage buffers And add a default storage buffer that is used for per-frame temporary data. So far nothing is using this code, this is just infrastructure.
2023-05-25 20:21:23 +00:00
GskVulkanBuffer *storage_buffer;
guchar *storage_buffer_memory;
gsize storage_buffer_used;
vulkan: Move sampler creation down This is in preparation of allowing multiple samplers.
2017-09-30 02:38:59 +00:00
vulkan: Implement multiple render passes Whenever we need a node as a texture, we now start a new render pass that renders the node into a new intermediate texture, and set up a semaphore to make the current render pass wait for it. As part of this reorganization, much of the setup and drawing code moved from gskvulkanrender.c to gskvulkanrenderpass.c.
2017-09-28 00:56:01 +00:00
GList *render_passes;
vulkan: Make the GskVulkanRender struct private
2016-12-08 16:55:32 +00:00
GSList *cleanup_images;
gsk: Add a profile counter for vulkan render passes This is interesting now that we have multiple render passes.
2017-09-28 12:29:14 +00:00
GQuark render_pass_counter;
vulkan: Measure gpu time Since this value is only meaningful if we wait for the rendering to end, we only keep this timer if GSK_RENDERING_MODE=sync is enabled.
2017-09-28 14:27:58 +00:00
GQuark gpu_time_timer;
vulkan: Make the GskVulkanRender struct private
2016-12-08 16:55:32 +00:00
};
vulkan: Create pipeline differently for ops Instead of creating a pipeline GObject, just ask for the VkPipeline. And instead of having the Op handle it, just let the renderpass look up/create the relevant pipeline while creating commands so that it can insert vkCmdBindPipeline calls as-needed.
2023-06-29 04:36:17 +00:00
typedef struct _PipelineCacheKey PipelineCacheKey;
struct _PipelineCacheKey
{
const /* interned */ char *shader_name;
const /* interned */ char *clip_type;
VkFormat format;
};
static guint
pipeline_cache_key_hash (gconstpointer data)
{
const PipelineCacheKey *key = data;
return GPOINTER_TO_UINT (key->shader_name) ^
GPOINTER_TO_UINT (key->clip_type) ^
key->format;
}
static gboolean
pipeline_cache_key_equal (gconstpointer a,
gconstpointer b)
{
const PipelineCacheKey *keya = a;
const PipelineCacheKey *keyb = b;
return keya->shader_name == keyb->shader_name &&
keya->clip_type == keyb->clip_type &&
keya->format == keyb->format;
}
vulkan: Add GskVulkanRenderPass And move the actual rendering code there. A RenderPass is a collection of operations on the same target that get executed one after another. It roughly targets VkRenderPass or rather the subpasses of a VkRenderPass. For now, only the infrastructure is there. No real stuff is happening.
2016-12-08 12:26:36 +00:00
static void
vulkan: Only render minimal region It's faster to render once for every rectangle in the clip region than rendering the outline of the clip region. Especially because this reduces the time necessary to build up the frame data. In widget-factory (where we have 3 rectangles), this leads to a 5x speedup in the rendering time rendering alone. Snapshotting time goes from 10ms to ~1ms, which is another huge improvement.
2016-12-26 23:18:52 +00:00
gsk_vulkan_render_setup (GskVulkanRender *self,
GskVulkanImage *target,
gsk: move begin/end_frame vfuncs into the renderers
2018-03-28 13:01:34 +00:00
const graphene_rect_t *rect,
const cairo_region_t *clip)
vulkan: Add GskVulkanRenderPass And move the actual rendering code there. A RenderPass is a collection of operations on the same target that get executed one after another. It roughly targets VkRenderPass or rather the subpasses of a VkRenderPass. For now, only the infrastructure is there. No real stuff is happening.
2016-12-08 12:26:36 +00:00
{
gsk/vulkan: Cosmetics No functional changes. Use a variable that already exists instead of calling gdk_draw_context_get_surface() again. Cleanup some newlines.
2023-04-03 11:54:34 +00:00
GdkSurface *surface = gsk_renderer_get_surface (self->renderer);
vulkan: Only render minimal region It's faster to render once for every rectangle in the clip region than rendering the outline of the clip region. Especially because this reduces the time necessary to build up the frame data. In widget-factory (where we have 3 rectangles), this leads to a 5x speedup in the rendering time rendering alone. Snapshotting time goes from 10ms to ~1ms, which is another huge improvement.
2016-12-26 23:18:52 +00:00
self->target = g_object_ref (target);
vulkan: Add GskVulkanRenderPass And move the actual rendering code there. A RenderPass is a collection of operations on the same target that get executed one after another. It roughly targets VkRenderPass or rather the subpasses of a VkRenderPass. For now, only the infrastructure is there. No real stuff is happening.
2016-12-08 12:26:36 +00:00
vulkan: Implement gsk_renderer_render_texture()
2016-12-22 18:01:07 +00:00
if (rect)
{
Small simplification Just keep the viewport as a graphene_rect_t, we don't need to use the Vulkan type here.
2017-09-30 14:42:32 +00:00
self->viewport = *rect;
vulkan: Support fractional scaling Basically what GL does, but without any debug or feature flag to gatekeep it, since the Vulkan backend itself is experimental already. Ceil surface sizes, and floor coordinates, to the fractional scale value.
2023-04-03 13:39:25 +00:00
self->scale = 1.0;
vulkan: Implement gsk_renderer_render_texture()
2016-12-22 18:01:07 +00:00
}
else
{
vulkan: Support fractional scaling Basically what GL does, but without any debug or feature flag to gatekeep it, since the Vulkan backend itself is experimental already. Ceil surface sizes, and floor coordinates, to the fractional scale value.
2023-04-03 13:39:25 +00:00
self->scale = gdk_surface_get_scale (surface);
Small simplification Just keep the viewport as a graphene_rect_t, we don't need to use the Vulkan type here.
2017-09-30 14:42:32 +00:00
self->viewport = GRAPHENE_RECT_INIT (0, 0,
vulkan: Support fractional scaling Basically what GL does, but without any debug or feature flag to gatekeep it, since the Vulkan backend itself is experimental already. Ceil surface sizes, and floor coordinates, to the fractional scale value.
2023-04-03 13:39:25 +00:00
(int) ceil (gdk_surface_get_width (surface) * self->scale),
(int) ceil (gdk_surface_get_height (surface) * self->scale));
gsk: move begin/end_frame vfuncs into the renderers
2018-03-28 13:01:34 +00:00
}
if (clip)
{
Revert "vulkan: Always render clip extents" This reverts commit 0f184d3270cfac522a05ae06d28cc2f1e32c0e6d. The renderer is good enough to make use of the clip region. Or rather: If it isn't, the renderpass should take care of that, not the render object.
2023-06-28 23:56:41 +00:00
self->clip = cairo_region_reference ((cairo_region_t *) clip);
gsk: move begin/end_frame vfuncs into the renderers
2018-03-28 13:01:34 +00:00
}
else
{
self->clip = cairo_region_create_rectangle (&(cairo_rectangle_int_t) {
0, 0,
gsk_vulkan_image_get_width (target),
gsk_vulkan_image_get_height (target)
});
vulkan: Implement gsk_renderer_render_texture()
2016-12-22 18:01:07 +00:00
}
vulkan: Add GskVulkanRenderPass And move the actual rendering code there. A RenderPass is a collection of operations on the same target that get executed one after another. It roughly targets VkRenderPass or rather the subpasses of a VkRenderPass. For now, only the infrastructure is there. No real stuff is happening.
2016-12-08 12:26:36 +00:00
}
vulkan: Add GskVulkanRender object This is refactoring work. GskVulkanRender is supposed to be the global object for a render operation, ie GskVulkanRenderer.render() will create this object for what it does. The object will be split into stages that perform the operations necessary to create a drawing.
2016-12-07 13:50:52 +00:00
vulkan: Make the VulkanRender object allocated That way, we can have multiple of those and keep them around for reuse.
2016-12-08 16:46:08 +00:00
GskVulkanRender *
gsk_vulkan_render_new (GskRenderer *renderer,
vulkan: Move remaining structs to VulkanRender object It now gets to maintain things.
2016-12-08 23:06:59 +00:00
GdkVulkanContext *context)
vulkan: Add GskVulkanRender object This is refactoring work. GskVulkanRender is supposed to be the global object for a render operation, ie GskVulkanRenderer.render() will create this object for what it does. The object will be split into stages that perform the operations necessary to create a drawing.
2016-12-07 13:50:52 +00:00
{
vulkan: Make the VulkanRender object allocated That way, we can have multiple of those and keep them around for reuse.
2016-12-08 16:46:08 +00:00
GskVulkanRender *self;
vulkan: Move command pool and fence into render object
2016-12-08 17:03:05 +00:00
VkDevice device;
vulkan: Make the VulkanRender object allocated That way, we can have multiple of those and keep them around for reuse.
2016-12-08 16:46:08 +00:00
gsk: Stop using g_slice
2023-03-03 11:48:49 +00:00
self = g_new0 (GskVulkanRender, 1);
vulkan: Make the VulkanRender object allocated That way, we can have multiple of those and keep them around for reuse.
2016-12-08 16:46:08 +00:00
vulkan: Add GskVulkanRender object This is refactoring work. GskVulkanRender is supposed to be the global object for a render operation, ie GskVulkanRenderer.render() will create this object for what it does. The object will be split into stages that perform the operations necessary to create a drawing.
2016-12-07 13:50:52 +00:00
self->vulkan = context;
vulkan: Add GskVulkanRenderPass And move the actual rendering code there. A RenderPass is a collection of operations on the same target that get executed one after another. It roughly targets VkRenderPass or rather the subpasses of a VkRenderPass. For now, only the infrastructure is there. No real stuff is happening.
2016-12-08 12:26:36 +00:00
self->renderer = renderer;
vulkan: Split textures and samplers The idea here is that we can do more complex combinations and use that to support texture-scale nodes or use fancy texture formats (suc as YUV). I'm not sure this is actually necessary, but for now it gives more flexibility.
2023-05-23 03:08:13 +00:00
gsk_descriptor_image_infos_init (&self->descriptor_images);
vulkan: Add support for storage buffers And add a default storage buffer that is used for per-frame temporary data. So far nothing is using this code, this is just infrastructure.
2023-05-25 20:21:23 +00:00
gsk_descriptor_buffer_infos_init (&self->descriptor_buffers);
vulkan: Add GskVulkanRender object This is refactoring work. GskVulkanRender is supposed to be the global object for a render operation, ie GskVulkanRenderer.render() will create this object for what it does. The object will be split into stages that perform the operations necessary to create a drawing.
2016-12-07 13:50:52 +00:00
vulkan: Move command pool and fence into render object
2016-12-08 17:03:05 +00:00
device = gdk_vulkan_context_get_device (self->vulkan);
vulkan: Split out command pool This way we can pass the command pool around. And that allows us to allocate and submitcustom buffers. And that is necessary to make staging images work.
2016-12-16 05:10:24 +00:00
self->command_pool = gsk_vulkan_command_pool_new (self->vulkan);
vulkan: Move command pool and fence into render object
2016-12-08 17:03:05 +00:00
GSK_VK_CHECK (vkCreateFence, device,
&(VkFenceCreateInfo) {
.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,
vulkan: Keep render objects around That way we can reuse them. We only create a new one if the last render operation hasn't finished executing.
2016-12-08 17:40:35 +00:00
.flags = VK_FENCE_CREATE_SIGNALED_BIT
vulkan: Move command pool and fence into render object
2016-12-08 17:03:05 +00:00
},
NULL,
&self->fence);
vulkan: Move remaining structs to VulkanRender object It now gets to maintain things.
2016-12-08 23:06:59 +00:00
GSK_VK_CHECK (vkCreateDescriptorPool, device,
&(VkDescriptorPoolCreateInfo) {
.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO,
vulkan: Implement bindless texture rendering Instead of having a descriptor set per operation, we just have one descriptor set and bind all our images into it. Then the shaders get to use an index into the large texture array instead. Getting this to work - because it's a Vulkan extension that needs to be manually enabled, even though it's officially part of Vulkan 1.2 - is insane.
2023-05-20 00:56:02 +00:00
.flags = VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT,
vulkan: Use 3 descriptor sets, not 3 bindings It turns out variable length is only supported for the last binding in a set, not for every binding. So we need to create one set for each of our arrays. [ VUID-VkDescriptorSetLayoutBindingFlagsCreateInfo-pBindingFlags-03004 ] Object 0: handle = 0x33a9f10, type = VK_OBJECT_TYPE_DEVICE; | MessageID = 0xd3f353a | vkCreateDescriptorSetLayout(): pBindings[0] has VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT but 0 is the largest value of all the bindings. The Vulkan spec states: If an element of pBindingFlags includes VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT, then all other elements of VkDescriptorSetLayoutCreateInfo::pBindings must have a smaller value of binding (https://www.khronos.org/registry/vulkan/specs/1.3-extensions/html/vkspec.html#VUID-VkDescriptorSetLayoutBindingFlagsCreateInfo-pBindingFlags-03004)
2023-06-20 13:39:29 +00:00
.maxSets = N_DESCRIPTOR_SETS,
.poolSizeCount = N_DESCRIPTOR_SETS,
.pPoolSizes = (VkDescriptorPoolSize[N_DESCRIPTOR_SETS]) {
vulkan: Move remaining structs to VulkanRender object It now gets to maintain things.
2016-12-08 23:06:59 +00:00
{
vulkan: Combine textures and samplers again This reverts most of commit f420c143e0d8947a433704969bab02aea47d82f5 again because it turns out GPUs like combined images and samplers. But: The one thing we don't revert is allowing the C code to select any combination of sampler and image: gsk_vulkan_render_get_image_descriptor() now takes a 2nd argument specifying the sampler. This allows the same flexibility as before, we just combine things early. This change was inspired by https://developer.nvidia.com/blog/vulkan-dos-donts/
2023-06-28 18:50:43 +00:00
.type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
vulkan: Implement bindless texture rendering Instead of having a descriptor set per operation, we just have one descriptor set and bind all our images into it. Then the shaders get to use an index into the large texture array instead. Getting this to work - because it's a Vulkan extension that needs to be manually enabled, even though it's officially part of Vulkan 1.2 - is insane.
2023-05-20 00:56:02 +00:00
.descriptorCount = DESCRIPTOR_POOL_MAXITEMS
vulkan: Add support for storage buffers And add a default storage buffer that is used for per-frame temporary data. So far nothing is using this code, this is just infrastructure.
2023-05-25 20:21:23 +00:00
},
{
.type = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
.descriptorCount = DESCRIPTOR_POOL_MAXITEMS
vulkan: Move remaining structs to VulkanRender object It now gets to maintain things.
2016-12-08 23:06:59 +00:00
}
}
},
NULL,
&self->descriptor_pool);
vulkan: Use 3 descriptor sets, not 3 bindings It turns out variable length is only supported for the last binding in a set, not for every binding. So we need to create one set for each of our arrays. [ VUID-VkDescriptorSetLayoutBindingFlagsCreateInfo-pBindingFlags-03004 ] Object 0: handle = 0x33a9f10, type = VK_OBJECT_TYPE_DEVICE; | MessageID = 0xd3f353a | vkCreateDescriptorSetLayout(): pBindings[0] has VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT but 0 is the largest value of all the bindings. The Vulkan spec states: If an element of pBindingFlags includes VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT, then all other elements of VkDescriptorSetLayoutCreateInfo::pBindings must have a smaller value of binding (https://www.khronos.org/registry/vulkan/specs/1.3-extensions/html/vkspec.html#VUID-VkDescriptorSetLayoutBindingFlagsCreateInfo-pBindingFlags-03004)
2023-06-20 13:39:29 +00:00
GSK_VK_CHECK (vkCreateDescriptorSetLayout, device,
&(VkDescriptorSetLayoutCreateInfo) {
.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
.bindingCount = 1,
.flags = VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT,
.pBindings = (VkDescriptorSetLayoutBinding[1]) {
vulkan: Split textures and samplers The idea here is that we can do more complex combinations and use that to support texture-scale nodes or use fancy texture formats (suc as YUV). I'm not sure this is actually necessary, but for now it gives more flexibility.
2023-05-23 03:08:13 +00:00
{
vulkan: Use 3 descriptor sets, not 3 bindings It turns out variable length is only supported for the last binding in a set, not for every binding. So we need to create one set for each of our arrays. [ VUID-VkDescriptorSetLayoutBindingFlagsCreateInfo-pBindingFlags-03004 ] Object 0: handle = 0x33a9f10, type = VK_OBJECT_TYPE_DEVICE; | MessageID = 0xd3f353a | vkCreateDescriptorSetLayout(): pBindings[0] has VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT but 0 is the largest value of all the bindings. The Vulkan spec states: If an element of pBindingFlags includes VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT, then all other elements of VkDescriptorSetLayoutCreateInfo::pBindings must have a smaller value of binding (https://www.khronos.org/registry/vulkan/specs/1.3-extensions/html/vkspec.html#VUID-VkDescriptorSetLayoutBindingFlagsCreateInfo-pBindingFlags-03004)
2023-06-20 13:39:29 +00:00
.binding = 0,
vulkan: Combine textures and samplers again This reverts most of commit f420c143e0d8947a433704969bab02aea47d82f5 again because it turns out GPUs like combined images and samplers. But: The one thing we don't revert is allowing the C code to select any combination of sampler and image: gsk_vulkan_render_get_image_descriptor() now takes a 2nd argument specifying the sampler. This allows the same flexibility as before, we just combine things early. This change was inspired by https://developer.nvidia.com/blog/vulkan-dos-donts/
2023-06-28 18:50:43 +00:00
.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
vulkan: Implement bindless texture rendering Instead of having a descriptor set per operation, we just have one descriptor set and bind all our images into it. Then the shaders get to use an index into the large texture array instead. Getting this to work - because it's a Vulkan extension that needs to be manually enabled, even though it's officially part of Vulkan 1.2 - is insane.
2023-05-20 00:56:02 +00:00
.descriptorCount = DESCRIPTOR_POOL_MAXITEMS,
vulkan: Move descriptor set layout to the render object We want to maintain a single descriptor set layout while introducing multiple pipeline layouts, so split this off.
2017-09-22 14:02:27 +00:00
.stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT
vulkan: Use 3 descriptor sets, not 3 bindings It turns out variable length is only supported for the last binding in a set, not for every binding. So we need to create one set for each of our arrays. [ VUID-VkDescriptorSetLayoutBindingFlagsCreateInfo-pBindingFlags-03004 ] Object 0: handle = 0x33a9f10, type = VK_OBJECT_TYPE_DEVICE; | MessageID = 0xd3f353a | vkCreateDescriptorSetLayout(): pBindings[0] has VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT but 0 is the largest value of all the bindings. The Vulkan spec states: If an element of pBindingFlags includes VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT, then all other elements of VkDescriptorSetLayoutCreateInfo::pBindings must have a smaller value of binding (https://www.khronos.org/registry/vulkan/specs/1.3-extensions/html/vkspec.html#VUID-VkDescriptorSetLayoutBindingFlagsCreateInfo-pBindingFlags-03004)
2023-06-20 13:39:29 +00:00
}
},
.pNext = &(VkDescriptorSetLayoutBindingFlagsCreateInfo) {
.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO,
.bindingCount = 1,
.pBindingFlags = (VkDescriptorBindingFlags[1]) {
VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT
| VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT
| VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT,
},
}
},
NULL,
vulkan: Combine textures and samplers again This reverts most of commit f420c143e0d8947a433704969bab02aea47d82f5 again because it turns out GPUs like combined images and samplers. But: The one thing we don't revert is allowing the C code to select any combination of sampler and image: gsk_vulkan_render_get_image_descriptor() now takes a 2nd argument specifying the sampler. This allows the same flexibility as before, we just combine things early. This change was inspired by https://developer.nvidia.com/blog/vulkan-dos-donts/
2023-06-28 18:50:43 +00:00
&self->descriptor_set_layouts[0]);
vulkan: Use 3 descriptor sets, not 3 bindings It turns out variable length is only supported for the last binding in a set, not for every binding. So we need to create one set for each of our arrays. [ VUID-VkDescriptorSetLayoutBindingFlagsCreateInfo-pBindingFlags-03004 ] Object 0: handle = 0x33a9f10, type = VK_OBJECT_TYPE_DEVICE; | MessageID = 0xd3f353a | vkCreateDescriptorSetLayout(): pBindings[0] has VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT but 0 is the largest value of all the bindings. The Vulkan spec states: If an element of pBindingFlags includes VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT, then all other elements of VkDescriptorSetLayoutCreateInfo::pBindings must have a smaller value of binding (https://www.khronos.org/registry/vulkan/specs/1.3-extensions/html/vkspec.html#VUID-VkDescriptorSetLayoutBindingFlagsCreateInfo-pBindingFlags-03004)
2023-06-20 13:39:29 +00:00
GSK_VK_CHECK (vkCreateDescriptorSetLayout, device,
&(VkDescriptorSetLayoutCreateInfo) {
.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
.bindingCount = 1,
.flags = VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT,
.pBindings = (VkDescriptorSetLayoutBinding[1]) {
vulkan: Add support for storage buffers And add a default storage buffer that is used for per-frame temporary data. So far nothing is using this code, this is just infrastructure.
2023-05-25 20:21:23 +00:00
{
vulkan: Use 3 descriptor sets, not 3 bindings It turns out variable length is only supported for the last binding in a set, not for every binding. So we need to create one set for each of our arrays. [ VUID-VkDescriptorSetLayoutBindingFlagsCreateInfo-pBindingFlags-03004 ] Object 0: handle = 0x33a9f10, type = VK_OBJECT_TYPE_DEVICE; | MessageID = 0xd3f353a | vkCreateDescriptorSetLayout(): pBindings[0] has VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT but 0 is the largest value of all the bindings. The Vulkan spec states: If an element of pBindingFlags includes VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT, then all other elements of VkDescriptorSetLayoutCreateInfo::pBindings must have a smaller value of binding (https://www.khronos.org/registry/vulkan/specs/1.3-extensions/html/vkspec.html#VUID-VkDescriptorSetLayoutBindingFlagsCreateInfo-pBindingFlags-03004)
2023-06-20 13:39:29 +00:00
.binding = 0,
vulkan: Add support for storage buffers And add a default storage buffer that is used for per-frame temporary data. So far nothing is using this code, this is just infrastructure.
2023-05-25 20:21:23 +00:00
.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
.descriptorCount = DESCRIPTOR_POOL_MAXITEMS,
.stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT
},
vulkan: Implement bindless texture rendering Instead of having a descriptor set per operation, we just have one descriptor set and bind all our images into it. Then the shaders get to use an index into the large texture array instead. Getting this to work - because it's a Vulkan extension that needs to be manually enabled, even though it's officially part of Vulkan 1.2 - is insane.
2023-05-20 00:56:02 +00:00
},
.pNext = &(VkDescriptorSetLayoutBindingFlagsCreateInfo) {
.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO,
vulkan: Use 3 descriptor sets, not 3 bindings It turns out variable length is only supported for the last binding in a set, not for every binding. So we need to create one set for each of our arrays. [ VUID-VkDescriptorSetLayoutBindingFlagsCreateInfo-pBindingFlags-03004 ] Object 0: handle = 0x33a9f10, type = VK_OBJECT_TYPE_DEVICE; | MessageID = 0xd3f353a | vkCreateDescriptorSetLayout(): pBindings[0] has VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT but 0 is the largest value of all the bindings. The Vulkan spec states: If an element of pBindingFlags includes VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT, then all other elements of VkDescriptorSetLayoutCreateInfo::pBindings must have a smaller value of binding (https://www.khronos.org/registry/vulkan/specs/1.3-extensions/html/vkspec.html#VUID-VkDescriptorSetLayoutBindingFlagsCreateInfo-pBindingFlags-03004)
2023-06-20 13:39:29 +00:00
.bindingCount = 1,
.pBindingFlags = (VkDescriptorBindingFlags[1]) {
vulkan: Implement bindless texture rendering Instead of having a descriptor set per operation, we just have one descriptor set and bind all our images into it. Then the shaders get to use an index into the large texture array instead. Getting this to work - because it's a Vulkan extension that needs to be manually enabled, even though it's officially part of Vulkan 1.2 - is insane.
2023-05-20 00:56:02 +00:00
VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT
| VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT
| VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT,
},
vulkan: Move descriptor set layout to the render object We want to maintain a single descriptor set layout while introducing multiple pipeline layouts, so split this off.
2017-09-22 14:02:27 +00:00
}
},
NULL,
vulkan: Combine textures and samplers again This reverts most of commit f420c143e0d8947a433704969bab02aea47d82f5 again because it turns out GPUs like combined images and samplers. But: The one thing we don't revert is allowing the C code to select any combination of sampler and image: gsk_vulkan_render_get_image_descriptor() now takes a 2nd argument specifying the sampler. This allows the same flexibility as before, we just combine things early. This change was inspired by https://developer.nvidia.com/blog/vulkan-dos-donts/
2023-06-28 18:50:43 +00:00
&self->descriptor_set_layouts[1]);
vulkan: Move descriptor set layout to the render object We want to maintain a single descriptor set layout while introducing multiple pipeline layouts, so split this off.
2017-09-22 14:02:27 +00:00
vulkan: Only use a single pipeline layout There's no need to use 3 different ones when they are compatible.
2023-05-12 18:49:31 +00:00
GSK_VK_CHECK (vkCreatePipelineLayout, device,
&(VkPipelineLayoutCreateInfo) {
.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
vulkan: Use 3 descriptor sets, not 3 bindings It turns out variable length is only supported for the last binding in a set, not for every binding. So we need to create one set for each of our arrays. [ VUID-VkDescriptorSetLayoutBindingFlagsCreateInfo-pBindingFlags-03004 ] Object 0: handle = 0x33a9f10, type = VK_OBJECT_TYPE_DEVICE; | MessageID = 0xd3f353a | vkCreateDescriptorSetLayout(): pBindings[0] has VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT but 0 is the largest value of all the bindings. The Vulkan spec states: If an element of pBindingFlags includes VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT, then all other elements of VkDescriptorSetLayoutCreateInfo::pBindings must have a smaller value of binding (https://www.khronos.org/registry/vulkan/specs/1.3-extensions/html/vkspec.html#VUID-VkDescriptorSetLayoutBindingFlagsCreateInfo-pBindingFlags-03004)
2023-06-20 13:39:29 +00:00
.setLayoutCount = G_N_ELEMENTS (self->descriptor_set_layouts),
.pSetLayouts = self->descriptor_set_layouts,
vulkan: Only use a single pipeline layout There's no need to use 3 different ones when they are compatible.
2023-05-12 18:49:31 +00:00
.pushConstantRangeCount = gsk_vulkan_push_constants_get_range_count (),
.pPushConstantRanges = gsk_vulkan_push_constants_get_ranges ()
},
NULL,
&self->pipeline_layout);
vulkan: Split PipelineLayout into its own object This way, we can share the layout between different pipelines.
2016-12-14 07:00:58 +00:00
vulkan: Move sampler creation down This is in preparation of allowing multiple samplers.
2017-09-30 02:38:59 +00:00
GSK_VK_CHECK (vkCreateSampler, device,
&(VkSamplerCreateInfo) {
.sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO,
.magFilter = VK_FILTER_LINEAR,
.minFilter = VK_FILTER_LINEAR,
vulkan: Use CLAMP_TO_EDGE in sampler We don't want to clamp to the border, that causes fade-outs at the edges.
2023-05-13 04:02:51 +00:00
.addressModeU = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,
.addressModeV = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,
vulkan: Move sampler creation down This is in preparation of allowing multiple samplers.
2017-09-30 02:38:59 +00:00
.addressModeW = VK_SAMPLER_ADDRESS_MODE_REPEAT,
.borderColor = VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK,
.unnormalizedCoordinates = VK_FALSE,
.maxAnisotropy = 1.0,
},
NULL,
vulkan: Split textures and samplers The idea here is that we can do more complex combinations and use that to support texture-scale nodes or use fancy texture formats (suc as YUV). I'm not sure this is actually necessary, but for now it gives more flexibility.
2023-05-23 03:08:13 +00:00
&self->samplers[GSK_VULKAN_SAMPLER_DEFAULT]);
vulkan: Move sampler creation down This is in preparation of allowing multiple samplers.
2017-09-30 02:38:59 +00:00
vulkan: Add a repeating sampler None of the render ops use it, yet.
2017-09-30 03:01:34 +00:00
GSK_VK_CHECK (vkCreateSampler, device,
&(VkSamplerCreateInfo) {
.sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO,
.magFilter = VK_FILTER_LINEAR,
.minFilter = VK_FILTER_LINEAR,
.addressModeU = VK_SAMPLER_ADDRESS_MODE_REPEAT,
.addressModeV = VK_SAMPLER_ADDRESS_MODE_REPEAT,
.addressModeW = VK_SAMPLER_ADDRESS_MODE_REPEAT,
.borderColor = VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK,
.unnormalizedCoordinates = VK_FALSE,
.maxAnisotropy = 1.0,
},
NULL,
vulkan: Split textures and samplers The idea here is that we can do more complex combinations and use that to support texture-scale nodes or use fancy texture formats (suc as YUV). I'm not sure this is actually necessary, but for now it gives more flexibility.
2023-05-23 03:08:13 +00:00
&self->samplers[GSK_VULKAN_SAMPLER_REPEAT]);
vulkan: Add support for texture-scale nodes
2023-05-23 03:26:08 +00:00
GSK_VK_CHECK (vkCreateSampler, device,
&(VkSamplerCreateInfo) {
.sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO,
.magFilter = VK_FILTER_NEAREST,
.minFilter = VK_FILTER_NEAREST,
.addressModeU = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,
.addressModeV = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,
.addressModeW = VK_SAMPLER_ADDRESS_MODE_REPEAT,
.borderColor = VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK,
.unnormalizedCoordinates = VK_FALSE,
.maxAnisotropy = 1.0,
},
NULL,
&self->samplers[GSK_VULKAN_SAMPLER_NEAREST]);
vulkan: Add a repeating sampler None of the render ops use it, yet.
2017-09-30 03:01:34 +00:00
vulkan: Add GskVulkanUploader It's the thing that makes sure pixels end up on the GPU.
2016-12-17 03:22:44 +00:00
self->uploader = gsk_vulkan_uploader_new (self->vulkan, self->command_pool);
vulkan: Create pipeline differently for ops Instead of creating a pipeline GObject, just ask for the VkPipeline. And instead of having the Op handle it, just let the renderpass look up/create the relevant pipeline while creating commands so that it can insert vkCmdBindPipeline calls as-needed.
2023-06-29 04:36:17 +00:00
self->pipeline_cache = g_hash_table_new (pipeline_cache_key_hash, pipeline_cache_key_equal);
vulkan: Add GskVulkanUploader It's the thing that makes sure pixels end up on the GPU.
2016-12-17 03:22:44 +00:00
gsk: Add a profile counter for vulkan render passes This is interesting now that we have multiple render passes.
2017-09-28 12:29:14 +00:00
#ifdef G_ENABLE_DEBUG
self->render_pass_counter = g_quark_from_static_string ("render-passes");
vulkan: Measure gpu time Since this value is only meaningful if we wait for the rendering to end, we only keep this timer if GSK_RENDERING_MODE=sync is enabled.
2017-09-28 14:27:58 +00:00
self->gpu_time_timer = g_quark_from_static_string ("gpu-time");
gsk: Add a profile counter for vulkan render passes This is interesting now that we have multiple render passes.
2017-09-28 12:29:14 +00:00
#endif
vulkan: Make the VulkanRender object allocated That way, we can have multiple of those and keep them around for reuse.
2016-12-08 16:46:08 +00:00
return self;
vulkan: Add GskVulkanRender object This is refactoring work. GskVulkanRender is supposed to be the global object for a render operation, ie GskVulkanRenderer.render() will create this object for what it does. The object will be split into stages that perform the operations necessary to create a drawing.
2016-12-07 13:50:52 +00:00
}
vulkan: Create multiple render objects Sometimes the GPU is still busy when the next frame starts (like when no-vsync benchmarking), so we need to keep all those resources alone and create new ones. That's what the render object is for, so we just create another one. However, when we create too many, we'll starve the CPU. So we'll limit it. Currently, that limit is at 4, but I've never reached it (I've also not starved the GPU yet), so that number may want to be set lower/higher in the future. Note that this is different from the number of outstanding buffers, as those are not busy on the GPU but on the compositor, and as such a buffer may have not finished rendering but have been returend from the compositor (very busy GPU) or have finished rendering but not been returned from the compositor (very idle GPU).
2023-05-24 14:55:18 +00:00
VkFence
gsk_vulkan_render_get_fence (GskVulkanRender *self)
{
return self->fence;
}
vulkan: Add GskVulkanRenderPass And move the actual rendering code there. A RenderPass is a collection of operations on the same target that get executed one after another. It roughly targets VkRenderPass or rather the subpasses of a VkRenderPass. For now, only the infrastructure is there. No real stuff is happening.
2016-12-08 12:26:36 +00:00
void
gsk_vulkan_render_add_cleanup_image (GskVulkanRender *self,
GskVulkanImage *image)
{
self->cleanup_images = g_slist_prepend (self->cleanup_images, image);
}
Reshuffle things a little bit Instead of having a function with lots of arguments in GskVulkanRender that we call from GskVulkanRenderPass which then just calls back into GskVulkanRenderPass, just create the new render pass object locally, and an api to add it to the list that GskVulkanRender keeps. This makes it a lot easier to preserve all the relevant parameters from the parent render pass.
2017-09-30 15:04:16 +00:00
void
Cosmetics Factor out a helper function.
2017-09-30 14:37:55 +00:00
gsk_vulkan_render_add_render_pass (GskVulkanRender *self,
GskVulkanRenderPass *pass)
{
self->render_passes = g_list_prepend (self->render_passes, pass);
#ifdef G_ENABLE_DEBUG
gsk_profiler_counter_inc (gsk_renderer_get_profiler (self->renderer), self->render_pass_counter);
#endif
}
vulkan: Add GskVulkanRenderPass And move the actual rendering code there. A RenderPass is a collection of operations on the same target that get executed one after another. It roughly targets VkRenderPass or rather the subpasses of a VkRenderPass. For now, only the infrastructure is there. No real stuff is happening.
2016-12-08 12:26:36 +00:00
void
gsk_vulkan_render_add_node (GskVulkanRender *self,
GskRenderNode *node)
{
vulkan: Implement multiple render passes Whenever we need a node as a texture, we now start a new render pass that renders the node into a new intermediate texture, and set up a semaphore to make the current render pass wait for it. As part of this reorganization, much of the setup and drawing code moved from gskvulkanrender.c to gskvulkanrenderpass.c.
2017-09-28 00:56:01 +00:00
GskVulkanRenderPass *pass;
vulkan: Clean up scale handling 1. Use a graphene_vec2_t 2. Ensure it's always positive 3. Don't break with fallback The scale value is nothing more than an indication of how many pixels to assume per unit of a node.
2023-05-10 00:46:57 +00:00
graphene_vec2_t scale;
graphene_vec2_init (&scale, self->scale, self->scale);
vulkan: Implement multiple render passes Whenever we need a node as a texture, we now start a new render pass that renders the node into a new intermediate texture, and set up a semaphore to make the current render pass wait for it. As part of this reorganization, much of the setup and drawing code moved from gskvulkanrender.c to gskvulkanrenderpass.c.
2017-09-28 00:56:01 +00:00
pass = gsk_vulkan_render_pass_new (self->vulkan,
self->target,
vulkan: Clean up scale handling 1. Use a graphene_vec2_t 2. Ensure it's always positive 3. Don't break with fallback The scale value is nothing more than an indication of how many pixels to assume per unit of a node.
2023-05-10 00:46:57 +00:00
&scale,
Small simplification Just keep the viewport as a graphene_rect_t, we don't need to use the Vulkan type here.
2017-09-30 14:42:32 +00:00
&self->viewport,
vulkan: Implement multiple render passes Whenever we need a node as a texture, we now start a new render pass that renders the node into a new intermediate texture, and set up a semaphore to make the current render pass wait for it. As part of this reorganization, much of the setup and drawing code moved from gskvulkanrender.c to gskvulkanrenderpass.c.
2017-09-28 00:56:01 +00:00
self->clip,
VK_NULL_HANDLE);
Cosmetics Factor out a helper function.
2017-09-30 14:37:55 +00:00
gsk_vulkan_render_add_render_pass (self, pass);
gsk: Add a profile counter for vulkan render passes This is interesting now that we have multiple render passes.
2017-09-28 12:29:14 +00:00
vulkan: Implement multiple render passes Whenever we need a node as a texture, we now start a new render pass that renders the node into a new intermediate texture, and set up a semaphore to make the current render pass wait for it. As part of this reorganization, much of the setup and drawing code moved from gskvulkanrender.c to gskvulkanrenderpass.c.
2017-09-28 00:56:01 +00:00
gsk_vulkan_render_pass_add (pass, self, node);
vulkan: Add GskVulkanRenderPass And move the actual rendering code there. A RenderPass is a collection of operations on the same target that get executed one after another. It roughly targets VkRenderPass or rather the subpasses of a VkRenderPass. For now, only the infrastructure is there. No real stuff is happening.
2016-12-08 12:26:36 +00:00
}
vulkan: Implement multiple render passes Whenever we need a node as a texture, we now start a new render pass that renders the node into a new intermediate texture, and set up a semaphore to make the current render pass wait for it. As part of this reorganization, much of the setup and drawing code moved from gskvulkanrender.c to gskvulkanrenderpass.c.
2017-09-28 00:56:01 +00:00
void
gsk_vulkan_render_upload (GskVulkanRender *self)
vulkan: Add GskVulkanRenderPass And move the actual rendering code there. A RenderPass is a collection of operations on the same target that get executed one after another. It roughly targets VkRenderPass or rather the subpasses of a VkRenderPass. For now, only the infrastructure is there. No real stuff is happening.
2016-12-08 12:26:36 +00:00
{
vulkan: Implement multiple render passes Whenever we need a node as a texture, we now start a new render pass that renders the node into a new intermediate texture, and set up a semaphore to make the current render pass wait for it. As part of this reorganization, much of the setup and drawing code moved from gskvulkanrender.c to gskvulkanrenderpass.c.
2017-09-28 00:56:01 +00:00
GList *l;
vulkan: Add GskVulkanRenderPass And move the actual rendering code there. A RenderPass is a collection of operations on the same target that get executed one after another. It roughly targets VkRenderPass or rather the subpasses of a VkRenderPass. For now, only the infrastructure is there. No real stuff is happening.
2016-12-08 12:26:36 +00:00
vulkan: Make glyphs use new node ops This is a rudimentary - but working - port. Glyph uploads are still using the old machinery, a bunch of functions still exist that probably aren't necessary anymore and each glyph emits its own node. This will need to be improved in further commits.
2023-07-03 07:15:04 +00:00
gsk_vulkan_glyph_cache_upload (gsk_vulkan_renderer_get_glyph_cache (GSK_VULKAN_RENDERER (self->renderer)),
self->uploader);
vulkan: Implement multiple render passes Whenever we need a node as a texture, we now start a new render pass that renders the node into a new intermediate texture, and set up a semaphore to make the current render pass wait for it. As part of this reorganization, much of the setup and drawing code moved from gskvulkanrender.c to gskvulkanrenderpass.c.
2017-09-28 00:56:01 +00:00
/* gsk_vulkan_render_pass_upload may call gsk_vulkan_render_add_node_for_texture,
* prepending new render passes to the list. Therefore, we walk the list from
* the end.
*/
for (l = g_list_last (self->render_passes); l; l = l->prev)
vulkan: Add GskVulkanRenderPass And move the actual rendering code there. A RenderPass is a collection of operations on the same target that get executed one after another. It roughly targets VkRenderPass or rather the subpasses of a VkRenderPass. For now, only the infrastructure is there. No real stuff is happening.
2016-12-08 12:26:36 +00:00
{
vulkan: Implement multiple render passes Whenever we need a node as a texture, we now start a new render pass that renders the node into a new intermediate texture, and set up a semaphore to make the current render pass wait for it. As part of this reorganization, much of the setup and drawing code moved from gskvulkanrender.c to gskvulkanrenderpass.c.
2017-09-28 00:56:01 +00:00
GskVulkanRenderPass *pass = l->data;
gsk_vulkan_render_pass_upload (pass, self, self->uploader);
vulkan: Add GskVulkanRenderPass And move the actual rendering code there. A RenderPass is a collection of operations on the same target that get executed one after another. It roughly targets VkRenderPass or rather the subpasses of a VkRenderPass. For now, only the infrastructure is there. No real stuff is happening.
2016-12-08 12:26:36 +00:00
}
vulkan: Implement multiple render passes Whenever we need a node as a texture, we now start a new render pass that renders the node into a new intermediate texture, and set up a semaphore to make the current render pass wait for it. As part of this reorganization, much of the setup and drawing code moved from gskvulkanrender.c to gskvulkanrenderpass.c.
2017-09-28 00:56:01 +00:00
gsk_vulkan_uploader_upload (self->uploader);
vulkan: Add GskVulkanRenderPass And move the actual rendering code there. A RenderPass is a collection of operations on the same target that get executed one after another. It roughly targets VkRenderPass or rather the subpasses of a VkRenderPass. For now, only the infrastructure is there. No real stuff is happening.
2016-12-08 12:26:36 +00:00
}
vulkan: Create pipeline differently for ops Instead of creating a pipeline GObject, just ask for the VkPipeline. And instead of having the Op handle it, just let the renderpass look up/create the relevant pipeline while creating commands so that it can insert vkCmdBindPipeline calls as-needed.
2023-06-29 04:36:17 +00:00
VkPipeline
gsk_vulkan_render_create_pipeline (GskVulkanRender *self,
const char *shader_name,
const char *clip_type,
const VkPipelineVertexInputStateCreateInfo *vertex_input_state,
VkFormat format,
VkRenderPass render_pass)
{
PipelineCacheKey cache_key;
VkPipeline pipeline;
GdkDisplay *display;
char *vertex_shader_name, *fragment_shader_name;
cache_key = (PipelineCacheKey) {
.shader_name = g_intern_string (shader_name),
.clip_type = g_intern_string (clip_type),
.format = format,
};
pipeline = g_hash_table_lookup (self->pipeline_cache, &cache_key);
if (pipeline)
return pipeline;
display = gdk_draw_context_get_display (GDK_DRAW_CONTEXT (self->vulkan));
vertex_shader_name = g_strconcat ("/org/gtk/libgsk/vulkan/", shader_name, clip_type, ".vert.spv", NULL);
fragment_shader_name = g_strconcat ("/org/gtk/libgsk/vulkan/", shader_name, clip_type, ".frag.spv", NULL);
GSK_VK_CHECK (vkCreateGraphicsPipelines, gdk_vulkan_context_get_device (self->vulkan),
gdk_vulkan_context_get_pipeline_cache (self->vulkan),
1,
&(VkGraphicsPipelineCreateInfo) {
.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,
.stageCount = 2,
.pStages = (VkPipelineShaderStageCreateInfo[2]) {
{
.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
.stage = VK_SHADER_STAGE_VERTEX_BIT,
.module = gdk_display_get_vk_shader_module (display, vertex_shader_name),
.pName = "main",
},
{
.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
.stage = VK_SHADER_STAGE_FRAGMENT_BIT,
.module = gdk_display_get_vk_shader_module (display, fragment_shader_name),
.pName = "main",
},
},
.pVertexInputState = vertex_input_state,
.pInputAssemblyState = &(VkPipelineInputAssemblyStateCreateInfo) {
.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO,
.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST,
.primitiveRestartEnable = VK_FALSE,
},
.pTessellationState = NULL,
.pViewportState = &(VkPipelineViewportStateCreateInfo) {
.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO,
.viewportCount = 1,
.scissorCount = 1
},
.pRasterizationState = &(VkPipelineRasterizationStateCreateInfo) {
.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO,
.depthClampEnable = VK_FALSE,
.rasterizerDiscardEnable = VK_FALSE,
.polygonMode = VK_POLYGON_MODE_FILL,
.cullMode = VK_CULL_MODE_NONE,
.frontFace = VK_FRONT_FACE_CLOCKWISE,
.lineWidth = 1.0f,
},
.pMultisampleState = &(VkPipelineMultisampleStateCreateInfo) {
.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO,
.rasterizationSamples = 1,
},
.pDepthStencilState = &(VkPipelineDepthStencilStateCreateInfo) {
.sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO
},
.pColorBlendState = &(VkPipelineColorBlendStateCreateInfo) {
.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO,
.attachmentCount = 1,
.pAttachments = (VkPipelineColorBlendAttachmentState []) {
{
.blendEnable = VK_TRUE,
.colorBlendOp = VK_BLEND_OP_ADD,
.srcColorBlendFactor = VK_BLEND_FACTOR_ONE,
.dstColorBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA,
.alphaBlendOp = VK_BLEND_OP_ADD,
.srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE,
.dstAlphaBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA,
.colorWriteMask = VK_COLOR_COMPONENT_A_BIT
| VK_COLOR_COMPONENT_R_BIT
| VK_COLOR_COMPONENT_G_BIT
| VK_COLOR_COMPONENT_B_BIT
},
}
},
.pDynamicState = &(VkPipelineDynamicStateCreateInfo) {
.sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO,
.dynamicStateCount = 2,
.pDynamicStates = (VkDynamicState[2]) {
VK_DYNAMIC_STATE_VIEWPORT,
VK_DYNAMIC_STATE_SCISSOR
},
},
.layout = self->pipeline_layout,
.renderPass = render_pass,
.subpass = 0,
.basePipelineHandle = VK_NULL_HANDLE,
.basePipelineIndex = -1,
},
NULL,
&pipeline);
g_free (fragment_shader_name);
g_free (vertex_shader_name);
g_hash_table_insert (self->pipeline_cache, g_memdup (&cache_key, sizeof (PipelineCacheKey)), pipeline);
gdk_vulkan_context_pipeline_cache_updated (self->vulkan);
return pipeline;
}
vulkan: Use 3 descriptor sets, not 3 bindings It turns out variable length is only supported for the last binding in a set, not for every binding. So we need to create one set for each of our arrays. [ VUID-VkDescriptorSetLayoutBindingFlagsCreateInfo-pBindingFlags-03004 ] Object 0: handle = 0x33a9f10, type = VK_OBJECT_TYPE_DEVICE; | MessageID = 0xd3f353a | vkCreateDescriptorSetLayout(): pBindings[0] has VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT but 0 is the largest value of all the bindings. The Vulkan spec states: If an element of pBindingFlags includes VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT, then all other elements of VkDescriptorSetLayoutCreateInfo::pBindings must have a smaller value of binding (https://www.khronos.org/registry/vulkan/specs/1.3-extensions/html/vkspec.html#VUID-VkDescriptorSetLayoutBindingFlagsCreateInfo-pBindingFlags-03004)
2023-06-20 13:39:29 +00:00
void
gsk_vulkan_render_bind_descriptor_sets (GskVulkanRender *self,
VkCommandBuffer command_buffer)
vulkan: Redo descriptor set handling First, we collect all the info about descriptor sets into a hash table, then we use its size to determine the amount of sets and allocate those before we finally go ahead and use the hash table's contents to initialize the descriptor sets. And then we're ready to render.
2016-12-09 01:55:47 +00:00
{
vulkan: Use 3 descriptor sets, not 3 bindings It turns out variable length is only supported for the last binding in a set, not for every binding. So we need to create one set for each of our arrays. [ VUID-VkDescriptorSetLayoutBindingFlagsCreateInfo-pBindingFlags-03004 ] Object 0: handle = 0x33a9f10, type = VK_OBJECT_TYPE_DEVICE; | MessageID = 0xd3f353a | vkCreateDescriptorSetLayout(): pBindings[0] has VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT but 0 is the largest value of all the bindings. The Vulkan spec states: If an element of pBindingFlags includes VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT, then all other elements of VkDescriptorSetLayoutCreateInfo::pBindings must have a smaller value of binding (https://www.khronos.org/registry/vulkan/specs/1.3-extensions/html/vkspec.html#VUID-VkDescriptorSetLayoutBindingFlagsCreateInfo-pBindingFlags-03004)
2023-06-20 13:39:29 +00:00
vkCmdBindDescriptorSets (command_buffer,
VK_PIPELINE_BIND_POINT_GRAPHICS,
self->pipeline_layout,
0,
vulkan: Combine textures and samplers again This reverts most of commit f420c143e0d8947a433704969bab02aea47d82f5 again because it turns out GPUs like combined images and samplers. But: The one thing we don't revert is allowing the C code to select any combination of sampler and image: gsk_vulkan_render_get_image_descriptor() now takes a 2nd argument specifying the sampler. This allows the same flexibility as before, we just combine things early. This change was inspired by https://developer.nvidia.com/blog/vulkan-dos-donts/
2023-06-28 18:50:43 +00:00
N_DESCRIPTOR_SETS,
vulkan: Use 3 descriptor sets, not 3 bindings It turns out variable length is only supported for the last binding in a set, not for every binding. So we need to create one set for each of our arrays. [ VUID-VkDescriptorSetLayoutBindingFlagsCreateInfo-pBindingFlags-03004 ] Object 0: handle = 0x33a9f10, type = VK_OBJECT_TYPE_DEVICE; | MessageID = 0xd3f353a | vkCreateDescriptorSetLayout(): pBindings[0] has VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT but 0 is the largest value of all the bindings. The Vulkan spec states: If an element of pBindingFlags includes VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT, then all other elements of VkDescriptorSetLayoutCreateInfo::pBindings must have a smaller value of binding (https://www.khronos.org/registry/vulkan/specs/1.3-extensions/html/vkspec.html#VUID-VkDescriptorSetLayoutBindingFlagsCreateInfo-pBindingFlags-03004)
2023-06-20 13:39:29 +00:00
self->descriptor_sets,
0,
NULL);
vulkan: Move sampler creation down This is in preparation of allowing multiple samplers.
2017-09-30 02:38:59 +00:00
}
vulkan: Redo descriptor set handling First, we collect all the info about descriptor sets into a hash table, then we use its size to determine the amount of sets and allocate those before we finally go ahead and use the hash table's contents to initialize the descriptor sets. And then we're ready to render.
2016-12-09 01:55:47 +00:00
gsize
vulkan: Combine textures and samplers again This reverts most of commit f420c143e0d8947a433704969bab02aea47d82f5 again because it turns out GPUs like combined images and samplers. But: The one thing we don't revert is allowing the C code to select any combination of sampler and image: gsk_vulkan_render_get_image_descriptor() now takes a 2nd argument specifying the sampler. This allows the same flexibility as before, we just combine things early. This change was inspired by https://developer.nvidia.com/blog/vulkan-dos-donts/
2023-06-28 18:50:43 +00:00
gsk_vulkan_render_get_image_descriptor (GskVulkanRender *self,
GskVulkanImage *image,
GskVulkanRenderSampler render_sampler)
vulkan: Redo descriptor set handling First, we collect all the info about descriptor sets into a hash table, then we use its size to determine the amount of sets and allocate those before we finally go ahead and use the hash table's contents to initialize the descriptor sets. And then we're ready to render.
2016-12-09 01:55:47 +00:00
{
vulkan: Implement bindless texture rendering Instead of having a descriptor set per operation, we just have one descriptor set and bind all our images into it. Then the shaders get to use an index into the large texture array instead. Getting this to work - because it's a Vulkan extension that needs to be manually enabled, even though it's officially part of Vulkan 1.2 - is insane.
2023-05-20 00:56:02 +00:00
gsize result;
vulkan: Redo descriptor set handling First, we collect all the info about descriptor sets into a hash table, then we use its size to determine the amount of sets and allocate those before we finally go ahead and use the hash table's contents to initialize the descriptor sets. And then we're ready to render.
2016-12-09 01:55:47 +00:00
vulkan: Split textures and samplers The idea here is that we can do more complex combinations and use that to support texture-scale nodes or use fancy texture formats (suc as YUV). I'm not sure this is actually necessary, but for now it gives more flexibility.
2023-05-23 03:08:13 +00:00
result = gsk_descriptor_image_infos_get_size (&self->descriptor_images);
gsk_descriptor_image_infos_append (&self->descriptor_images,
&(VkDescriptorImageInfo) {
vulkan: Combine textures and samplers again This reverts most of commit f420c143e0d8947a433704969bab02aea47d82f5 again because it turns out GPUs like combined images and samplers. But: The one thing we don't revert is allowing the C code to select any combination of sampler and image: gsk_vulkan_render_get_image_descriptor() now takes a 2nd argument specifying the sampler. This allows the same flexibility as before, we just combine things early. This change was inspired by https://developer.nvidia.com/blog/vulkan-dos-donts/
2023-06-28 18:50:43 +00:00
.sampler = self->samplers[render_sampler],
vulkan: Split textures and samplers The idea here is that we can do more complex combinations and use that to support texture-scale nodes or use fancy texture formats (suc as YUV). I'm not sure this is actually necessary, but for now it gives more flexibility.
2023-05-23 03:08:13 +00:00
.imageView = gsk_vulkan_image_get_image_view (image),
.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL
});
vulkan: Move sampler creation down This is in preparation of allowing multiple samplers.
2017-09-30 02:38:59 +00:00
vulkan: Implement bindless texture rendering Instead of having a descriptor set per operation, we just have one descriptor set and bind all our images into it. Then the shaders get to use an index into the large texture array instead. Getting this to work - because it's a Vulkan extension that needs to be manually enabled, even though it's officially part of Vulkan 1.2 - is insane.
2023-05-20 00:56:02 +00:00
g_assert (result < DESCRIPTOR_POOL_MAXITEMS);
vulkan: Move sampler creation down This is in preparation of allowing multiple samplers.
2017-09-30 02:38:59 +00:00
vulkan: Implement bindless texture rendering Instead of having a descriptor set per operation, we just have one descriptor set and bind all our images into it. Then the shaders get to use an index into the large texture array instead. Getting this to work - because it's a Vulkan extension that needs to be manually enabled, even though it's officially part of Vulkan 1.2 - is insane.
2023-05-20 00:56:02 +00:00
return result;
vulkan: Redo descriptor set handling First, we collect all the info about descriptor sets into a hash table, then we use its size to determine the amount of sets and allocate those before we finally go ahead and use the hash table's contents to initialize the descriptor sets. And then we're ready to render.
2016-12-09 01:55:47 +00:00
}
vulkan: Add support for storage buffers And add a default storage buffer that is used for per-frame temporary data. So far nothing is using this code, this is just infrastructure.
2023-05-25 20:21:23 +00:00
static void
gsk_vulkan_render_ensure_storage_buffer (GskVulkanRender *self)
{
if (self->storage_buffer_memory != NULL)
return;
if (self->storage_buffer == NULL)
{
self->storage_buffer = gsk_vulkan_buffer_new_storage (self->vulkan,
/* random */
sizeof (float) * 1024 * 1024);
}
self->storage_buffer_memory = gsk_vulkan_buffer_map (self->storage_buffer);
if (gsk_vulkan_render_get_buffer_descriptor (self, self->storage_buffer) != 0)
{
g_assert_not_reached ();
}
}
gsize
gsk_vulkan_render_get_buffer_descriptor (GskVulkanRender *self,
GskVulkanBuffer *buffer)
{
gsize result;
gsk_vulkan_render_ensure_storage_buffer (self);
result = gsk_descriptor_buffer_infos_get_size (&self->descriptor_buffers);
gsk_descriptor_buffer_infos_append (&self->descriptor_buffers,
&(VkDescriptorBufferInfo) {
.buffer = gsk_vulkan_buffer_get_buffer (buffer),
.offset = 0,
.range = VK_WHOLE_SIZE
});
g_assert (result < DESCRIPTOR_POOL_MAXITEMS);
return result;
}
static inline gsize
round_up (gsize number, gsize divisor)
{
return (number + divisor - 1) / divisor * divisor;
}
guchar *
gsk_vulkan_render_get_buffer_memory (GskVulkanRender *self,
gsize size,
gsize alignment,
gsize *out_offset)
{
guchar *result;
g_assert (alignment >= sizeof (float));
gsk_vulkan_render_ensure_storage_buffer (self);
self->storage_buffer_used = round_up (self->storage_buffer_used, alignment);
result = self->storage_buffer_memory + self->storage_buffer_used;
*out_offset = self->storage_buffer_used / sizeof (float);
self->storage_buffer_used += size;
return result;
}
vulkan: Redo descriptor set handling First, we collect all the info about descriptor sets into a hash table, then we use its size to determine the amount of sets and allocate those before we finally go ahead and use the hash table's contents to initialize the descriptor sets. And then we're ready to render.
2016-12-09 01:55:47 +00:00
static void
vulkan: Move sampler creation down This is in preparation of allowing multiple samplers.
2017-09-30 02:38:59 +00:00
gsk_vulkan_render_prepare_descriptor_sets (GskVulkanRender *self)
vulkan: Redo descriptor set handling First, we collect all the info about descriptor sets into a hash table, then we use its size to determine the amount of sets and allocate those before we finally go ahead and use the hash table's contents to initialize the descriptor sets. And then we're ready to render.
2016-12-09 01:55:47 +00:00
{
VkDevice device;
vulkan: Combine textures and samplers again This reverts most of commit f420c143e0d8947a433704969bab02aea47d82f5 again because it turns out GPUs like combined images and samplers. But: The one thing we don't revert is allowing the C code to select any combination of sampler and image: gsk_vulkan_render_get_image_descriptor() now takes a 2nd argument specifying the sampler. This allows the same flexibility as before, we just combine things early. This change was inspired by https://developer.nvidia.com/blog/vulkan-dos-donts/
2023-06-28 18:50:43 +00:00
VkWriteDescriptorSet descriptor_sets[N_DESCRIPTOR_SETS];
vulkan: Only update descriptor sets with contents If one of the descriptor sets doesn't have any items, don't include it in the sets passed to vkUpdateDescriptorSets(). This has no effect right now, because we either have both images and samplers or neither, but it will become relevant once we also support buffers.
2023-06-08 04:55:40 +00:00
gsize n_descriptor_sets;
vulkan: Implement multiple render passes Whenever we need a node as a texture, we now start a new render pass that renders the node into a new intermediate texture, and set up a semaphore to make the current render pass wait for it. As part of this reorganization, much of the setup and drawing code moved from gskvulkanrender.c to gskvulkanrenderpass.c.
2017-09-28 00:56:01 +00:00
GList *l;
vulkan: Redo descriptor set handling First, we collect all the info about descriptor sets into a hash table, then we use its size to determine the amount of sets and allocate those before we finally go ahead and use the hash table's contents to initialize the descriptor sets. And then we're ready to render.
2016-12-09 01:55:47 +00:00
device = gdk_vulkan_context_get_device (self->vulkan);
for (l = self->render_passes; l; l = l->next)
{
vulkan: Implement multiple render passes Whenever we need a node as a texture, we now start a new render pass that renders the node into a new intermediate texture, and set up a semaphore to make the current render pass wait for it. As part of this reorganization, much of the setup and drawing code moved from gskvulkanrender.c to gskvulkanrenderpass.c.
2017-09-28 00:56:01 +00:00
GskVulkanRenderPass *pass = l->data;
gsk_vulkan_render_pass_reserve_descriptor_sets (pass, self);
vulkan: Redo descriptor set handling First, we collect all the info about descriptor sets into a hash table, then we use its size to determine the amount of sets and allocate those before we finally go ahead and use the hash table's contents to initialize the descriptor sets. And then we're ready to render.
2016-12-09 01:55:47 +00:00
}
vulkan: Add support for storage buffers And add a default storage buffer that is used for per-frame temporary data. So far nothing is using this code, this is just infrastructure.
2023-05-25 20:21:23 +00:00
if (self->storage_buffer_memory)
{
gsk_vulkan_buffer_unmap (self->storage_buffer);
self->storage_buffer_memory = NULL;
vulkan: Actually reset the buffer size Fixes a bug introduced in d1135f9e3c7. Luckily the buffer was large enough that all my testing didn't catch it because it took a few minutes to overflow.
2023-06-18 16:38:48 +00:00
self->storage_buffer_used = 0;
vulkan: Add support for storage buffers And add a default storage buffer that is used for per-frame temporary data. So far nothing is using this code, this is just infrastructure.
2023-05-25 20:21:23 +00:00
}
vulkan: Reallocate descriptor sets Because wee now reset the descriptor pool, we also need to reallocate the descriptor sets.
2017-01-06 17:10:12 +00:00
GSK_VK_CHECK (vkAllocateDescriptorSets, device,
&(VkDescriptorSetAllocateInfo) {
.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO,
.descriptorPool = self->descriptor_pool,
vulkan: Use 3 descriptor sets, not 3 bindings It turns out variable length is only supported for the last binding in a set, not for every binding. So we need to create one set for each of our arrays. [ VUID-VkDescriptorSetLayoutBindingFlagsCreateInfo-pBindingFlags-03004 ] Object 0: handle = 0x33a9f10, type = VK_OBJECT_TYPE_DEVICE; | MessageID = 0xd3f353a | vkCreateDescriptorSetLayout(): pBindings[0] has VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT but 0 is the largest value of all the bindings. The Vulkan spec states: If an element of pBindingFlags includes VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT, then all other elements of VkDescriptorSetLayoutCreateInfo::pBindings must have a smaller value of binding (https://www.khronos.org/registry/vulkan/specs/1.3-extensions/html/vkspec.html#VUID-VkDescriptorSetLayoutBindingFlagsCreateInfo-pBindingFlags-03004)
2023-06-20 13:39:29 +00:00
.descriptorSetCount = N_DESCRIPTOR_SETS,
.pSetLayouts = self->descriptor_set_layouts,
vulkan: Implement bindless texture rendering Instead of having a descriptor set per operation, we just have one descriptor set and bind all our images into it. Then the shaders get to use an index into the large texture array instead. Getting this to work - because it's a Vulkan extension that needs to be manually enabled, even though it's officially part of Vulkan 1.2 - is insane.
2023-05-20 00:56:02 +00:00
.pNext = &(VkDescriptorSetVariableDescriptorCountAllocateInfo) {
.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO,
vulkan: Use 3 descriptor sets, not 3 bindings It turns out variable length is only supported for the last binding in a set, not for every binding. So we need to create one set for each of our arrays. [ VUID-VkDescriptorSetLayoutBindingFlagsCreateInfo-pBindingFlags-03004 ] Object 0: handle = 0x33a9f10, type = VK_OBJECT_TYPE_DEVICE; | MessageID = 0xd3f353a | vkCreateDescriptorSetLayout(): pBindings[0] has VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT but 0 is the largest value of all the bindings. The Vulkan spec states: If an element of pBindingFlags includes VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT, then all other elements of VkDescriptorSetLayoutCreateInfo::pBindings must have a smaller value of binding (https://www.khronos.org/registry/vulkan/specs/1.3-extensions/html/vkspec.html#VUID-VkDescriptorSetLayoutBindingFlagsCreateInfo-pBindingFlags-03004)
2023-06-20 13:39:29 +00:00
.descriptorSetCount = N_DESCRIPTOR_SETS,
.pDescriptorCounts = (uint32_t[N_DESCRIPTOR_SETS]) {
MAX (1, gsk_descriptor_image_infos_get_size (&self->descriptor_images)),
MAX (1, gsk_descriptor_buffer_infos_get_size (&self->descriptor_buffers))
vulkan: Implement bindless texture rendering Instead of having a descriptor set per operation, we just have one descriptor set and bind all our images into it. Then the shaders get to use an index into the large texture array instead. Getting this to work - because it's a Vulkan extension that needs to be manually enabled, even though it's officially part of Vulkan 1.2 - is insane.
2023-05-20 00:56:02 +00:00
}
}
vulkan: Reallocate descriptor sets Because wee now reset the descriptor pool, we also need to reallocate the descriptor sets.
2017-01-06 17:10:12 +00:00
},
vulkan: Use 3 descriptor sets, not 3 bindings It turns out variable length is only supported for the last binding in a set, not for every binding. So we need to create one set for each of our arrays. [ VUID-VkDescriptorSetLayoutBindingFlagsCreateInfo-pBindingFlags-03004 ] Object 0: handle = 0x33a9f10, type = VK_OBJECT_TYPE_DEVICE; | MessageID = 0xd3f353a | vkCreateDescriptorSetLayout(): pBindings[0] has VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT but 0 is the largest value of all the bindings. The Vulkan spec states: If an element of pBindingFlags includes VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT, then all other elements of VkDescriptorSetLayoutCreateInfo::pBindings must have a smaller value of binding (https://www.khronos.org/registry/vulkan/specs/1.3-extensions/html/vkspec.html#VUID-VkDescriptorSetLayoutBindingFlagsCreateInfo-pBindingFlags-03004)
2023-06-20 13:39:29 +00:00
self->descriptor_sets);
vulkan: Implement bindless texture rendering Instead of having a descriptor set per operation, we just have one descriptor set and bind all our images into it. Then the shaders get to use an index into the large texture array instead. Getting this to work - because it's a Vulkan extension that needs to be manually enabled, even though it's officially part of Vulkan 1.2 - is insane.
2023-05-20 00:56:02 +00:00
vulkan: Only update descriptor sets with contents If one of the descriptor sets doesn't have any items, don't include it in the sets passed to vkUpdateDescriptorSets(). This has no effect right now, because we either have both images and samplers or neither, but it will become relevant once we also support buffers.
2023-06-08 04:55:40 +00:00
n_descriptor_sets = 0;
if (gsk_descriptor_image_infos_get_size (&self->descriptor_images) > 0)
{
descriptor_sets[n_descriptor_sets++] = (VkWriteDescriptorSet) {
.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
vulkan: Use 3 descriptor sets, not 3 bindings It turns out variable length is only supported for the last binding in a set, not for every binding. So we need to create one set for each of our arrays. [ VUID-VkDescriptorSetLayoutBindingFlagsCreateInfo-pBindingFlags-03004 ] Object 0: handle = 0x33a9f10, type = VK_OBJECT_TYPE_DEVICE; | MessageID = 0xd3f353a | vkCreateDescriptorSetLayout(): pBindings[0] has VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT but 0 is the largest value of all the bindings. The Vulkan spec states: If an element of pBindingFlags includes VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT, then all other elements of VkDescriptorSetLayoutCreateInfo::pBindings must have a smaller value of binding (https://www.khronos.org/registry/vulkan/specs/1.3-extensions/html/vkspec.html#VUID-VkDescriptorSetLayoutBindingFlagsCreateInfo-pBindingFlags-03004)
2023-06-20 13:39:29 +00:00
.dstSet = self->descriptor_sets[0],
vulkan: Only update descriptor sets with contents If one of the descriptor sets doesn't have any items, don't include it in the sets passed to vkUpdateDescriptorSets(). This has no effect right now, because we either have both images and samplers or neither, but it will become relevant once we also support buffers.
2023-06-08 04:55:40 +00:00
.dstBinding = 0,
.dstArrayElement = 0,
.descriptorCount = gsk_descriptor_image_infos_get_size (&self->descriptor_images),
vulkan: Combine textures and samplers again This reverts most of commit f420c143e0d8947a433704969bab02aea47d82f5 again because it turns out GPUs like combined images and samplers. But: The one thing we don't revert is allowing the C code to select any combination of sampler and image: gsk_vulkan_render_get_image_descriptor() now takes a 2nd argument specifying the sampler. This allows the same flexibility as before, we just combine things early. This change was inspired by https://developer.nvidia.com/blog/vulkan-dos-donts/
2023-06-28 18:50:43 +00:00
.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
vulkan: Only update descriptor sets with contents If one of the descriptor sets doesn't have any items, don't include it in the sets passed to vkUpdateDescriptorSets(). This has no effect right now, because we either have both images and samplers or neither, but it will become relevant once we also support buffers.
2023-06-08 04:55:40 +00:00
.pImageInfo = gsk_descriptor_image_infos_get_data (&self->descriptor_images)
};
}
vulkan: Add support for storage buffers And add a default storage buffer that is used for per-frame temporary data. So far nothing is using this code, this is just infrastructure.
2023-05-25 20:21:23 +00:00
if (gsk_descriptor_buffer_infos_get_size (&self->descriptor_buffers) > 0)
{
descriptor_sets[n_descriptor_sets++] = (VkWriteDescriptorSet) {
.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
vulkan: Combine textures and samplers again This reverts most of commit f420c143e0d8947a433704969bab02aea47d82f5 again because it turns out GPUs like combined images and samplers. But: The one thing we don't revert is allowing the C code to select any combination of sampler and image: gsk_vulkan_render_get_image_descriptor() now takes a 2nd argument specifying the sampler. This allows the same flexibility as before, we just combine things early. This change was inspired by https://developer.nvidia.com/blog/vulkan-dos-donts/
2023-06-28 18:50:43 +00:00
.dstSet = self->descriptor_sets[1],
vulkan: Use 3 descriptor sets, not 3 bindings It turns out variable length is only supported for the last binding in a set, not for every binding. So we need to create one set for each of our arrays. [ VUID-VkDescriptorSetLayoutBindingFlagsCreateInfo-pBindingFlags-03004 ] Object 0: handle = 0x33a9f10, type = VK_OBJECT_TYPE_DEVICE; | MessageID = 0xd3f353a | vkCreateDescriptorSetLayout(): pBindings[0] has VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT but 0 is the largest value of all the bindings. The Vulkan spec states: If an element of pBindingFlags includes VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT, then all other elements of VkDescriptorSetLayoutCreateInfo::pBindings must have a smaller value of binding (https://www.khronos.org/registry/vulkan/specs/1.3-extensions/html/vkspec.html#VUID-VkDescriptorSetLayoutBindingFlagsCreateInfo-pBindingFlags-03004)
2023-06-20 13:39:29 +00:00
.dstBinding = 0,
vulkan: Add support for storage buffers And add a default storage buffer that is used for per-frame temporary data. So far nothing is using this code, this is just infrastructure.
2023-05-25 20:21:23 +00:00
.dstArrayElement = 0,
.descriptorCount = gsk_descriptor_buffer_infos_get_size (&self->descriptor_buffers),
.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
.pBufferInfo = gsk_descriptor_buffer_infos_get_data (&self->descriptor_buffers)
};
}
vulkan: Only update descriptor sets with contents If one of the descriptor sets doesn't have any items, don't include it in the sets passed to vkUpdateDescriptorSets(). This has no effect right now, because we either have both images and samplers or neither, but it will become relevant once we also support buffers.
2023-06-08 04:55:40 +00:00
vulkan: Implement bindless texture rendering Instead of having a descriptor set per operation, we just have one descriptor set and bind all our images into it. Then the shaders get to use an index into the large texture array instead. Getting this to work - because it's a Vulkan extension that needs to be manually enabled, even though it's officially part of Vulkan 1.2 - is insane.
2023-05-20 00:56:02 +00:00
vkUpdateDescriptorSets (device,
vulkan: Only update descriptor sets with contents If one of the descriptor sets doesn't have any items, don't include it in the sets passed to vkUpdateDescriptorSets(). This has no effect right now, because we either have both images and samplers or neither, but it will become relevant once we also support buffers.
2023-06-08 04:55:40 +00:00
n_descriptor_sets,
descriptor_sets,
vulkan: Implement bindless texture rendering Instead of having a descriptor set per operation, we just have one descriptor set and bind all our images into it. Then the shaders get to use an index into the large texture array instead. Getting this to work - because it's a Vulkan extension that needs to be manually enabled, even though it's officially part of Vulkan 1.2 - is insane.
2023-05-20 00:56:02 +00:00
0, NULL);
vulkan: Redo descriptor set handling First, we collect all the info about descriptor sets into a hash table, then we use its size to determine the amount of sets and allocate those before we finally go ahead and use the hash table's contents to initialize the descriptor sets. And then we're ready to render.
2016-12-09 01:55:47 +00:00
}
vulkan: Split out a function Making that function externally usable allows having render passes managed externally. Also remove a nonexisting function from the header.
2023-06-25 03:02:48 +00:00
void
gsk_vulkan_render_draw_pass (GskVulkanRender *self,
GskVulkanRenderPass *pass,
VkFence fence)
{
VkCommandBuffer command_buffer;
gsize wait_semaphore_count;
gsize signal_semaphore_count;
VkSemaphore *wait_semaphores;
VkSemaphore *signal_semaphores;
wait_semaphore_count = gsk_vulkan_render_pass_get_wait_semaphores (pass, &wait_semaphores);
signal_semaphore_count = gsk_vulkan_render_pass_get_signal_semaphores (pass, &signal_semaphores);
command_buffer = gsk_vulkan_command_pool_get_buffer (self->command_pool);
gsk_vulkan_render_pass_draw (pass, self, self->pipeline_layout, command_buffer);
gsk_vulkan_command_pool_submit_buffer (self->command_pool,
command_buffer,
wait_semaphore_count,
wait_semaphores,
signal_semaphore_count,
signal_semaphores,
fence);
}
vulkan: Add GskVulkanRenderPass And move the actual rendering code there. A RenderPass is a collection of operations on the same target that get executed one after another. It roughly targets VkRenderPass or rather the subpasses of a VkRenderPass. For now, only the infrastructure is there. No real stuff is happening.
2016-12-08 12:26:36 +00:00
void
vulkan: Move sampler creation down This is in preparation of allowing multiple samplers.
2017-09-30 02:38:59 +00:00
gsk_vulkan_render_draw (GskVulkanRender *self)
vulkan: Add GskVulkanRenderPass And move the actual rendering code there. A RenderPass is a collection of operations on the same target that get executed one after another. It roughly targets VkRenderPass or rather the subpasses of a VkRenderPass. For now, only the infrastructure is there. No real stuff is happening.
2016-12-08 12:26:36 +00:00
{
vulkan: Implement multiple render passes Whenever we need a node as a texture, we now start a new render pass that renders the node into a new intermediate texture, and set up a semaphore to make the current render pass wait for it. As part of this reorganization, much of the setup and drawing code moved from gskvulkanrender.c to gskvulkanrenderpass.c.
2017-09-28 00:56:01 +00:00
GList *l;
vulkan: Add GskVulkanRenderPass And move the actual rendering code there. A RenderPass is a collection of operations on the same target that get executed one after another. It roughly targets VkRenderPass or rather the subpasses of a VkRenderPass. For now, only the infrastructure is there. No real stuff is happening.
2016-12-08 12:26:36 +00:00
vulkan: Measure gpu time Since this value is only meaningful if we wait for the rendering to end, we only keep this timer if GSK_RENDERING_MODE=sync is enabled.
2017-09-28 14:27:58 +00:00
#ifdef G_ENABLE_DEBUG
gsk: Reorganize env vars Get rid of GSK_RENDERING_MODE and add the flags to GSK_DEBUG, following the same pattern we use in gdk now.
2018-01-14 20:11:33 +00:00
if (GSK_RENDERER_DEBUG_CHECK (self->renderer, SYNC))
vulkan: Measure gpu time Since this value is only meaningful if we wait for the rendering to end, we only keep this timer if GSK_RENDERING_MODE=sync is enabled.
2017-09-28 14:27:58 +00:00
gsk_profiler_timer_begin (gsk_renderer_get_profiler (self->renderer), self->gpu_time_timer);
#endif
vulkan: Move sampler creation down This is in preparation of allowing multiple samplers.
2017-09-30 02:38:59 +00:00
gsk_vulkan_render_prepare_descriptor_sets (self);
vulkan: Add GskVulkanRenderPass And move the actual rendering code there. A RenderPass is a collection of operations on the same target that get executed one after another. It roughly targets VkRenderPass or rather the subpasses of a VkRenderPass. For now, only the infrastructure is there. No real stuff is happening.
2016-12-08 12:26:36 +00:00
vulkan: Implement multiple render passes Whenever we need a node as a texture, we now start a new render pass that renders the node into a new intermediate texture, and set up a semaphore to make the current render pass wait for it. As part of this reorganization, much of the setup and drawing code moved from gskvulkanrender.c to gskvulkanrenderpass.c.
2017-09-28 00:56:01 +00:00
for (l = self->render_passes; l; l = l->next)
vulkan: Only render minimal region It's faster to render once for every rectangle in the clip region than rendering the outline of the clip region. Especially because this reduces the time necessary to build up the frame data. In widget-factory (where we have 3 rectangles), this leads to a 5x speedup in the rendering time rendering alone. Snapshotting time goes from 10ms to ~1ms, which is another huge improvement.
2016-12-26 23:18:52 +00:00
{
vulkan: Split out a function Making that function externally usable allows having render passes managed externally. Also remove a nonexisting function from the header.
2023-06-25 03:02:48 +00:00
gsk_vulkan_render_draw_pass (self,
l->data,
l->next != NULL ? VK_NULL_HANDLE : self->fence);
vulkan: Only render minimal region It's faster to render once for every rectangle in the clip region than rendering the outline of the clip region. Especially because this reduces the time necessary to build up the frame data. In widget-factory (where we have 3 rectangles), this leads to a 5x speedup in the rendering time rendering alone. Snapshotting time goes from 10ms to ~1ms, which is another huge improvement.
2016-12-26 23:18:52 +00:00
}
vulkan: Add GskVulkanRenderPass And move the actual rendering code there. A RenderPass is a collection of operations on the same target that get executed one after another. It roughly targets VkRenderPass or rather the subpasses of a VkRenderPass. For now, only the infrastructure is there. No real stuff is happening.
2016-12-08 12:26:36 +00:00
gsk: Reorganize env vars Get rid of GSK_RENDERING_MODE and add the flags to GSK_DEBUG, following the same pattern we use in gdk now.
2018-01-14 20:11:33 +00:00
#ifdef G_ENABLE_DEBUG
if (GSK_RENDERER_DEBUG_CHECK (self->renderer, SYNC))
vulkan: Don't wait until graphics are done computing We can let the GPU do its stuff without waiting. The GPU knows what it's doing. Which means we now get a lot of time to spend on doing CPU things (read: we're way better in benchmarks). The old behavior is safer, so we want to keep it around for debugging. It can be reenabled with GSK_RENDERING_MODE=sync.
2016-12-08 18:56:56 +00:00
{
vulkan: Measure gpu time Since this value is only meaningful if we wait for the rendering to end, we only keep this timer if GSK_RENDERING_MODE=sync is enabled.
2017-09-28 14:27:58 +00:00
GskProfiler *profiler;
gint64 gpu_time;
vulkan: Don't wait until graphics are done computing We can let the GPU do its stuff without waiting. The GPU knows what it's doing. Which means we now get a lot of time to spend on doing CPU things (read: we're way better in benchmarks). The old behavior is safer, so we want to keep it around for debugging. It can be reenabled with GSK_RENDERING_MODE=sync.
2016-12-08 18:56:56 +00:00
GSK_VK_CHECK (vkWaitForFences, gdk_vulkan_context_get_device (self->vulkan),
1,
&self->fence,
VK_TRUE,
INT64_MAX);
vulkan: Measure gpu time Since this value is only meaningful if we wait for the rendering to end, we only keep this timer if GSK_RENDERING_MODE=sync is enabled.
2017-09-28 14:27:58 +00:00
profiler = gsk_renderer_get_profiler (self->renderer);
gpu_time = gsk_profiler_timer_end (profiler, self->gpu_time_timer);
gsk_profiler_timer_set (profiler, self->gpu_time_timer, gpu_time);
vulkan: Don't wait until graphics are done computing We can let the GPU do its stuff without waiting. The GPU knows what it's doing. Which means we now get a lot of time to spend on doing CPU things (read: we're way better in benchmarks). The old behavior is safer, so we want to keep it around for debugging. It can be reenabled with GSK_RENDERING_MODE=sync.
2016-12-08 18:56:56 +00:00
}
gsk: Reorganize env vars Get rid of GSK_RENDERING_MODE and add the flags to GSK_DEBUG, following the same pattern we use in gdk now.
2018-01-14 20:11:33 +00:00
#endif
vulkan: Add GskVulkanRender object This is refactoring work. GskVulkanRender is supposed to be the global object for a render operation, ie GskVulkanRenderer.render() will create this object for what it does. The object will be split into stages that perform the operations necessary to create a drawing.
2016-12-07 13:50:52 +00:00
}
GskTexture => GdkTexture We want this thing to replace GdkPixbuf, so it has to live in GDK.
2017-11-02 20:39:00 +00:00
GdkTexture *
vulkan: Implement gsk_renderer_render_texture()
2016-12-22 18:01:07 +00:00
gsk_vulkan_render_download_target (GskVulkanRender *self)
{
gsk/vulkan/render: Download image before reset gsk_vulkan_render_download_target() currently resets the uploader objects before downloading the image that it produces. This is problematic because there might be unreleased buffers and images in the command queue. In particular, this can make validation layers complain about the glyph atlas - of all things! - upload buffer being released while still being used by the command queue. Fix that by resetting the uploader after downloading the image.
2023-04-14 19:27:42 +00:00
GdkTexture *texture;
texture = gsk_vulkan_image_download (self->target, self->uploader);
vulkan: Implement gsk_renderer_render_texture()
2016-12-22 18:01:07 +00:00
gsk_vulkan_uploader_reset (self->uploader);
gsk/vulkan/render: Download image before reset gsk_vulkan_render_download_target() currently resets the uploader objects before downloading the image that it produces. This is problematic because there might be unreleased buffers and images in the command queue. In particular, this can make validation layers complain about the glyph atlas - of all things! - upload buffer being released while still being used by the command queue. Fix that by resetting the uploader after downloading the image.
2023-04-14 19:27:42 +00:00
return texture;
vulkan: Implement gsk_renderer_render_texture()
2016-12-22 18:01:07 +00:00
}
vulkan: Keep render objects around That way we can reuse them. We only create a new one if the last render operation hasn't finished executing.
2016-12-08 17:40:35 +00:00
static void
gsk_vulkan_render_cleanup (GskVulkanRender *self)
vulkan: Add GskVulkanRender object This is refactoring work. GskVulkanRender is supposed to be the global object for a render operation, ie GskVulkanRenderer.render() will create this object for what it does. The object will be split into stages that perform the operations necessary to create a drawing.
2016-12-07 13:50:52 +00:00
{
vulkan: Move command pool and fence into render object
2016-12-08 17:03:05 +00:00
VkDevice device = gdk_vulkan_context_get_device (self->vulkan);
vulkan: Keep render objects around That way we can reuse them. We only create a new one if the last render operation hasn't finished executing.
2016-12-08 17:40:35 +00:00
/* 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);
vulkan: Split out command pool This way we can pass the command pool around. And that allows us to allocate and submitcustom buffers. And that is necessary to make staging images work.
2016-12-16 05:10:24 +00:00
vulkan: Add GskVulkanUploader It's the thing that makes sure pixels end up on the GPU.
2016-12-17 03:22:44 +00:00
gsk_vulkan_uploader_reset (self->uploader);
vulkan: Split out command pool This way we can pass the command pool around. And that allows us to allocate and submitcustom buffers. And that is necessary to make staging images work.
2016-12-16 05:10:24 +00:00
gsk_vulkan_command_pool_reset (self->command_pool);
vulkan: Add GskVulkanRenderPass And move the actual rendering code there. A RenderPass is a collection of operations on the same target that get executed one after another. It roughly targets VkRenderPass or rather the subpasses of a VkRenderPass. For now, only the infrastructure is there. No real stuff is happening.
2016-12-08 12:26:36 +00:00
vulkan: Reset descriptor pool We don't want the pool to reference images we're gonna destroy. Drivers don't like that at all.
2017-01-06 15:31:03 +00:00
GSK_VK_CHECK (vkResetDescriptorPool, device,
self->descriptor_pool,
0);
vulkan: Split textures and samplers The idea here is that we can do more complex combinations and use that to support texture-scale nodes or use fancy texture formats (suc as YUV). I'm not sure this is actually necessary, but for now it gives more flexibility.
2023-05-23 03:08:13 +00:00
gsk_descriptor_image_infos_set_size (&self->descriptor_images, 0);
vulkan: Add support for storage buffers And add a default storage buffer that is used for per-frame temporary data. So far nothing is using this code, this is just infrastructure.
2023-05-25 20:21:23 +00:00
gsk_descriptor_buffer_infos_set_size (&self->descriptor_buffers, 0);
vulkan: Redo descriptor set handling First, we collect all the info about descriptor sets into a hash table, then we use its size to determine the amount of sets and allocate those before we finally go ahead and use the hash table's contents to initialize the descriptor sets. And then we're ready to render.
2016-12-09 01:55:47 +00:00
vulkan: Implement multiple render passes Whenever we need a node as a texture, we now start a new render pass that renders the node into a new intermediate texture, and set up a semaphore to make the current render pass wait for it. As part of this reorganization, much of the setup and drawing code moved from gskvulkanrender.c to gskvulkanrenderpass.c.
2017-09-28 00:56:01 +00:00
g_list_free_full (self->render_passes, (GDestroyNotify) gsk_vulkan_render_pass_free);
vulkan: Keep render objects around That way we can reuse them. We only create a new one if the last render operation hasn't finished executing.
2016-12-08 17:40:35 +00:00
self->render_passes = NULL;
vulkan: Turn GskVulkanImage into a GObject This way, we can do real refcounting on them.
2016-12-08 19:19:56 +00:00
g_slist_free_full (self->cleanup_images, g_object_unref);
vulkan: Keep render objects around That way we can reuse them. We only create a new one if the last render operation hasn't finished executing.
2016-12-08 17:40:35 +00:00
self->cleanup_images = NULL;
vulkan: Create framebuffers from GskVulkanRender object Also create them on-demand, as they need to be created per-image and per-framebuffer, so we don't want to create loads of them.
2016-12-08 21:35:16 +00:00
vulkan: Only render minimal region It's faster to render once for every rectangle in the clip region than rendering the outline of the clip region. Especially because this reduces the time necessary to build up the frame data. In widget-factory (where we have 3 rectangles), this leads to a 5x speedup in the rendering time rendering alone. Snapshotting time goes from 10ms to ~1ms, which is another huge improvement.
2016-12-26 23:18:52 +00:00
g_clear_pointer (&self->clip, cairo_region_destroy);
vulkan: Create framebuffers from GskVulkanRender object Also create them on-demand, as they need to be created per-image and per-framebuffer, so we don't want to create loads of them.
2016-12-08 21:35:16 +00:00
g_clear_object (&self->target);
vulkan: Keep render objects around That way we can reuse them. We only create a new one if the last render operation hasn't finished executing.
2016-12-08 17:40:35 +00:00
}
void
gsk_vulkan_render_free (GskVulkanRender *self)
{
VkDevice device;
vulkan: Create pipeline differently for ops Instead of creating a pipeline GObject, just ask for the VkPipeline. And instead of having the Op handle it, just let the renderpass look up/create the relevant pipeline while creating commands so that it can insert vkCmdBindPipeline calls as-needed.
2023-06-29 04:36:17 +00:00
GHashTableIter iter;
gpointer key, value;
vulkan: Add infrastructure for multiple pipelines And use it to draw solid colors with a 2nd pipeline.
2016-12-14 08:40:15 +00:00
guint i;
vulkan: Keep render objects around That way we can reuse them. We only create a new one if the last render operation hasn't finished executing.
2016-12-08 17:40:35 +00:00
gsk_vulkan_render_cleanup (self);
device = gdk_vulkan_context_get_device (self->vulkan);
vulkan: Make the VulkanRender object allocated That way, we can have multiple of those and keep them around for reuse.
2016-12-08 16:46:08 +00:00
vulkan: Create pipeline differently for ops Instead of creating a pipeline GObject, just ask for the VkPipeline. And instead of having the Op handle it, just let the renderpass look up/create the relevant pipeline while creating commands so that it can insert vkCmdBindPipeline calls as-needed.
2023-06-29 04:36:17 +00:00
g_hash_table_iter_init (&iter, self->pipeline_cache);
while (g_hash_table_iter_next (&iter, &key, &value))
{
g_free (key);
vkDestroyPipeline (device, value, NULL);
}
g_hash_table_unref (self->pipeline_cache);
vulkan: Add GskVulkanUploader It's the thing that makes sure pixels end up on the GPU.
2016-12-17 03:22:44 +00:00
g_clear_pointer (&self->uploader, gsk_vulkan_uploader_free);
vulkan: Implement bindless texture rendering Instead of having a descriptor set per operation, we just have one descriptor set and bind all our images into it. Then the shaders get to use an index into the large texture array instead. Getting this to work - because it's a Vulkan extension that needs to be manually enabled, even though it's officially part of Vulkan 1.2 - is insane.
2023-05-20 00:56:02 +00:00
vulkan: Only use a single pipeline layout There's no need to use 3 different ones when they are compatible.
2023-05-12 18:49:31 +00:00
vkDestroyPipelineLayout (device,
self->pipeline_layout,
NULL);
vulkan: Split PipelineLayout into its own object This way, we can share the layout between different pipelines.
2016-12-14 07:00:58 +00:00
vulkan: Move remaining structs to VulkanRender object It now gets to maintain things.
2016-12-08 23:06:59 +00:00
vkDestroyDescriptorPool (device,
self->descriptor_pool,
NULL);
vulkan: Split textures and samplers The idea here is that we can do more complex combinations and use that to support texture-scale nodes or use fancy texture formats (suc as YUV). I'm not sure this is actually necessary, but for now it gives more flexibility.
2023-05-23 03:08:13 +00:00
gsk_descriptor_image_infos_clear (&self->descriptor_images);
vulkan: Add support for storage buffers And add a default storage buffer that is used for per-frame temporary data. So far nothing is using this code, this is just infrastructure.
2023-05-25 20:21:23 +00:00
gsk_descriptor_buffer_infos_clear (&self->descriptor_buffers);
vulkan: Move remaining structs to VulkanRender object It now gets to maintain things.
2016-12-08 23:06:59 +00:00
vulkan: Use 3 descriptor sets, not 3 bindings It turns out variable length is only supported for the last binding in a set, not for every binding. So we need to create one set for each of our arrays. [ VUID-VkDescriptorSetLayoutBindingFlagsCreateInfo-pBindingFlags-03004 ] Object 0: handle = 0x33a9f10, type = VK_OBJECT_TYPE_DEVICE; | MessageID = 0xd3f353a | vkCreateDescriptorSetLayout(): pBindings[0] has VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT but 0 is the largest value of all the bindings. The Vulkan spec states: If an element of pBindingFlags includes VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT, then all other elements of VkDescriptorSetLayoutCreateInfo::pBindings must have a smaller value of binding (https://www.khronos.org/registry/vulkan/specs/1.3-extensions/html/vkspec.html#VUID-VkDescriptorSetLayoutBindingFlagsCreateInfo-pBindingFlags-03004)
2023-06-20 13:39:29 +00:00
for (i = 0; i < N_DESCRIPTOR_SETS; i++)
vkDestroyDescriptorSetLayout (device,
self->descriptor_set_layouts[i],
NULL);
vulkan: Move descriptor set layout to the render object We want to maintain a single descriptor set layout while introducing multiple pipeline layouts, so split this off.
2017-09-22 14:02:27 +00:00
vulkan: Move command pool and fence into render object
2016-12-08 17:03:05 +00:00
vkDestroyFence (device,
self->fence,
NULL);
vulkan: Split out command pool This way we can pass the command pool around. And that allows us to allocate and submitcustom buffers. And that is necessary to make staging images work.
2016-12-16 05:10:24 +00:00
vulkan: Split textures and samplers The idea here is that we can do more complex combinations and use that to support texture-scale nodes or use fancy texture formats (suc as YUV). I'm not sure this is actually necessary, but for now it gives more flexibility.
2023-05-23 03:08:13 +00:00
for (i = 0; i < G_N_ELEMENTS (self->samplers); i++)
{
vkDestroySampler (device,
self->samplers[i],
NULL);
}
vulkan: Add a repeating sampler None of the render ops use it, yet.
2017-09-30 03:01:34 +00:00
vulkan: Split out command pool This way we can pass the command pool around. And that allows us to allocate and submitcustom buffers. And that is necessary to make staging images work.
2016-12-16 05:10:24 +00:00
gsk_vulkan_command_pool_free (self->command_pool);
vulkan: Move command pool and fence into render object
2016-12-08 17:03:05 +00:00
gsk: Stop using g_slice
2023-03-03 11:48:49 +00:00
g_free (self);
vulkan: Add GskVulkanRender object This is refactoring work. GskVulkanRender is supposed to be the global object for a render operation, ie GskVulkanRenderer.render() will create this object for what it does. The object will be split into stages that perform the operations necessary to create a drawing.
2016-12-07 13:50:52 +00:00
}
vulkan: Make the GskVulkanRender struct private
2016-12-08 16:55:32 +00:00
vulkan: Keep render objects around That way we can reuse them. We only create a new one if the last render operation hasn't finished executing.
2016-12-08 17:40:35 +00:00
gboolean
gsk_vulkan_render_is_busy (GskVulkanRender *self)
{
return vkGetFenceStatus (gdk_vulkan_context_get_device (self->vulkan), self->fence) != VK_SUCCESS;
}
void
vulkan: Implement gsk_renderer_render_texture()
2016-12-22 18:01:07 +00:00
gsk_vulkan_render_reset (GskVulkanRender *self,
GskVulkanImage *target,
gsk: move begin/end_frame vfuncs into the renderers
2018-03-28 13:01:34 +00:00
const graphene_rect_t *rect,
const cairo_region_t *clip)
vulkan: Keep render objects around That way we can reuse them. We only create a new one if the last render operation hasn't finished executing.
2016-12-08 17:40:35 +00:00
{
gsk_vulkan_render_cleanup (self);
gsk: move begin/end_frame vfuncs into the renderers
2018-03-28 13:01:34 +00:00
gsk_vulkan_render_setup (self, target, rect, clip);
vulkan: Keep render objects around That way we can reuse them. We only create a new one if the last render operation hasn't finished executing.
2016-12-08 17:40:35 +00:00
}
vulkan: Make the GskVulkanRender struct private
2016-12-08 16:55:32 +00:00
GskRenderer *
gsk_vulkan_render_get_renderer (GskVulkanRender *self)
{
return self->renderer;
}
Reference in New Issue Copy Permalink