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

1115 lines
45 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: Add GskVulkanDownloadOp This op queues a download of an image. The image will only be available once the commands finished executing, so it requires waiting for the render to finish, which makes the API a bit awkward. Included is also a download_png_op() useful for debugging.
2023-07-14 21:22:35 +00:00
#include "gskvulkandownloadopprivate.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: Emit a renderpass op ... instead of doing the equivalent things manually by creating a RenderPass and calling the relevant functions. Now all renderpass operations are indeed stored in ops. Also reshuffle the command emission code, because we no longer need to emit the ops for the base renderpass. As a result we only submit a single command buffer containing all the render passes instead of once per render pass. We also bind vertex buffers and descriptor sets only once now at the start instead of once per renderpass.
2023-07-10 01:42:55 +00:00
#include "gskvulkanrenderpassopprivate.h"
vulkan: Introduce GskVulkanShaderOp It's the new base class for shaders now. We're doing deep inheritance now, woohoo! Also, port all the shader ops to it.
2023-07-15 09:39:18 +00:00
#include "gskvulkanshaderopprivate.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
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: Move the render ops to the Render This is a massive refactoring because it collects all the renderops of all renderpasses into one long array in the Render object. Lots of code in there is still flaky and needs cleanup. That will follow in further commits. Other than that it does work fine though.
2023-07-09 18:28:12 +00:00
#define GDK_ARRAY_NAME gsk_vulkan_render_ops
#define GDK_ARRAY_TYPE_NAME GskVulkanRenderOps
#define GDK_ARRAY_ELEMENT_TYPE guchar
#define GDK_ARRAY_BY_VALUE 1
#include "gdk/gdkarrayimpl.c"
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
vulkan: Put the vertex buffer into the render object Renderpasses get recreated every frame, but we keep render objects around. So if we keep the vertex buffer in the render object, we can also keep it around and just reuse it. Also, we only need one buffer for all the render passes, which is another bonus. The initial buffer size is chosen at 128kB. Maximized Nautilus, gnome-text-editor with an open file and widget-factory take ~100kB when doing a full redraw. Other apps are between 30-50kB usually. So I chose a value that is not too big, but catches ~90% of cases.
2023-07-08 07:04:12 +00:00
#define VERTEX_BUFFER_SIZE_STEP 128 * 1024 /* 128kB */
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 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;
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: Remove unused stuff from render object Neither cleanup images nor multiple renderpasses are used anymore since both of those are now handled inside the render ops.
2023-07-05 05:16:58 +00:00
vulkan: Move the render ops to the Render This is a massive refactoring because it collects all the renderops of all renderpasses into one long array in the Render object. Lots of code in there is still flaky and needs cleanup. That will follow in further commits. Other than that it does work fine though.
2023-07-09 18:28:12 +00:00
GskVulkanRenderOps render_ops;
vulkan: Store a pointer to the first op This is not yet useful, but will be soon.
2023-07-09 21:44:52 +00:00
GskVulkanOp *first_op;
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: Cache VkRenderPasses in render object Instead of recreating the same renderpass object in every frame and for every offscreen, just reuse it. Technically, we can save this per-renderer or even per-display (it should really be cached by VkDevice), but we have no infrastructure for that.
2023-07-08 18:40:48 +00:00
GHashTable *render_pass_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: Put the vertex buffer into the render object Renderpasses get recreated every frame, but we keep render objects around. So if we keep the vertex buffer in the render object, we can also keep it around and just reuse it. Also, we only need one buffer for all the render passes, which is another bonus. The initial buffer size is chosen at 128kB. Maximized Nautilus, gnome-text-editor with an open file and widget-factory take ~100kB when doing a full redraw. Other apps are between 30-50kB usually. So I chose a value that is not too big, but catches ~90% of cases.
2023-07-08 07:04:12 +00:00
GskVulkanBuffer *vertex_buffer;
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
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;
vulkan: Cache VkRenderPasses in render object Instead of recreating the same renderpass object in every frame and for every offscreen, just reuse it. Technically, we can save this per-renderer or even per-display (it should really be cached by VkDevice), but we have no infrastructure for that.
2023-07-08 18:40:48 +00:00
typedef struct _RenderPassCacheKey RenderPassCacheKey;
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
struct _PipelineCacheKey
{
vulkan: Don't intern strings Interning strings is slow, especially if we can instead do direct pointer compares. Also refactor the pipeline lookup code a bit to make use of the refactored code.
2023-07-07 00:38:22 +00:00
const GskVulkanOpClass *op_class;
vulkan: Make clip type an enum and add gsk_vulkan_shader_op_alloc() that sets it properly.
2023-07-15 10:47:35 +00:00
GskVulkanShaderClip clip;
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
VkFormat format;
};
vulkan: Cache VkRenderPasses in render object Instead of recreating the same renderpass object in every frame and for every offscreen, just reuse it. Technically, we can save this per-renderer or even per-display (it should really be cached by VkDevice), but we have no infrastructure for that.
2023-07-08 18:40:48 +00:00
struct _RenderPassCacheKey
{
VkFormat format;
VkImageLayout from_layout;
VkImageLayout to_layout;
};
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
static guint
pipeline_cache_key_hash (gconstpointer data)
{
const PipelineCacheKey *key = data;
vulkan: Don't intern strings Interning strings is slow, especially if we can instead do direct pointer compares. Also refactor the pipeline lookup code a bit to make use of the refactored code.
2023-07-07 00:38:22 +00:00
return GPOINTER_TO_UINT (key->op_class) ^
vulkan: Make clip type an enum and add gsk_vulkan_shader_op_alloc() that sets it properly.
2023-07-15 10:47:35 +00:00
key->clip ^
(key->format << 2);
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
}
static gboolean
pipeline_cache_key_equal (gconstpointer a,
gconstpointer b)
{
const PipelineCacheKey *keya = a;
const PipelineCacheKey *keyb = b;
vulkan: Don't intern strings Interning strings is slow, especially if we can instead do direct pointer compares. Also refactor the pipeline lookup code a bit to make use of the refactored code.
2023-07-07 00:38:22 +00:00
return keya->op_class == keyb->op_class &&
vulkan: Make clip type an enum and add gsk_vulkan_shader_op_alloc() that sets it properly.
2023-07-15 10:47:35 +00:00
keya->clip == keyb->clip &&
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
keya->format == keyb->format;
}
vulkan: Cache VkRenderPasses in render object Instead of recreating the same renderpass object in every frame and for every offscreen, just reuse it. Technically, we can save this per-renderer or even per-display (it should really be cached by VkDevice), but we have no infrastructure for that.
2023-07-08 18:40:48 +00:00
static guint
render_pass_cache_key_hash (gconstpointer data)
{
const RenderPassCacheKey *key = data;
return (key->from_layout << 20) ^
(key->to_layout << 16) ^
(key->format);
}
static gboolean
render_pass_cache_key_equal (gconstpointer a,
gconstpointer b)
{
const RenderPassCacheKey *keya = a;
const RenderPassCacheKey *keyb = b;
return keya->from_layout == keyb->from_layout &&
keya->to_layout == keyb->to_layout &&
keya->format == keyb->format;
}
vulkan: Add infrastructure for printing ops ... and add a GSK_DEBUG=verbose setting making use of it.
2023-07-05 04:32:52 +00:00
static void
gsk_vulkan_render_verbose_print (GskVulkanRender *self,
const char *heading)
{
#ifdef G_ENABLE_DEBUG
if (GSK_RENDERER_DEBUG_CHECK (self->renderer, VERBOSE))
{
vulkan: Move the render ops to the Render This is a massive refactoring because it collects all the renderops of all renderpasses into one long array in the Render object. Lots of code in there is still flaky and needs cleanup. That will follow in further commits. Other than that it does work fine though.
2023-07-09 18:28:12 +00:00
GskVulkanOp *op;
vulkan: Indent verbose prints again This feature was lost when refactoring, restore it.
2023-07-09 21:44:02 +00:00
guint indent = 1;
vulkan: Add infrastructure for printing ops ... and add a GSK_DEBUG=verbose setting making use of it.
2023-07-05 04:32:52 +00:00
GString *string = g_string_new (heading);
g_string_append (string, ":\n");
vulkan: Move the render ops to the Render This is a massive refactoring because it collects all the renderops of all renderpasses into one long array in the Render object. Lots of code in there is still flaky and needs cleanup. That will follow in further commits. Other than that it does work fine though.
2023-07-09 18:28:12 +00:00
vulkan: Store a pointer to the first op This is not yet useful, but will be soon.
2023-07-09 21:44:52 +00:00
for (op = self->first_op; op; op = op->next)
vulkan: Move the render ops to the Render This is a massive refactoring because it collects all the renderops of all renderpasses into one long array in the Render object. Lots of code in there is still flaky and needs cleanup. That will follow in further commits. Other than that it does work fine though.
2023-07-09 18:28:12 +00:00
{
vulkan: Indent verbose prints again This feature was lost when refactoring, restore it.
2023-07-09 21:44:02 +00:00
if (op->op_class->stage == GSK_VULKAN_STAGE_END_PASS)
indent--;
gsk_vulkan_op_print (op, string, indent);
if (op->op_class->stage == GSK_VULKAN_STAGE_BEGIN_PASS)
indent++;
vulkan: Move the render ops to the Render This is a massive refactoring because it collects all the renderops of all renderpasses into one long array in the Render object. Lots of code in there is still flaky and needs cleanup. That will follow in further commits. Other than that it does work fine though.
2023-07-09 18:28:12 +00:00
}
vulkan: Add infrastructure for printing ops ... and add a GSK_DEBUG=verbose setting making use of it.
2023-07-05 04:32:52 +00:00
g_print ("%s\n", string->str);
g_string_free (string, TRUE);
}
#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
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
{
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: Clean up renderpass/offscreen creation Instead of scale and whatnot, pass: 1. The image size 2. The viewport to map to that image size and compute everything else from there. In particular, we set the Vulkan viewport to the image dimensions instead of the viewport size. All of this makes things a lot simpler while keeping the required functionality.
2023-07-21 22:54:03 +00:00
self->viewport = *rect;
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: 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: Move the render ops to the Render This is a massive refactoring because it collects all the renderops of all renderpasses into one long array in the Render object. Lots of code in there is still flaky and needs cleanup. That will follow in further commits. Other than that it does work fine though.
2023-07-09 18:28:12 +00:00
gsk_vulkan_render_ops_init (&self->render_ops);
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: Cache VkRenderPasses in render object Instead of recreating the same renderpass object in every frame and for every offscreen, just reuse it. Technically, we can save this per-renderer or even per-display (it should really be cached by VkDevice), but we have no infrastructure for that.
2023-07-08 18:40:48 +00:00
self->render_pass_cache = g_hash_table_new (render_pass_cache_key_hash, render_pass_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: Move the render ops to the Render This is a massive refactoring because it collects all the renderops of all renderpasses into one long array in the Render object. Lots of code in there is still flaky and needs cleanup. That will follow in further commits. Other than that it does work fine though.
2023-07-09 18:28:12 +00:00
static void
gsk_vulkan_render_seal_ops (GskVulkanRender *self)
{
GskVulkanOp *last, *op;
guint i;
vulkan: Store a pointer to the first op This is not yet useful, but will be soon.
2023-07-09 21:44:52 +00:00
self->first_op = (GskVulkanOp *) gsk_vulkan_render_ops_index (&self->render_ops, 0);
vulkan: Move the render ops to the Render This is a massive refactoring because it collects all the renderops of all renderpasses into one long array in the Render object. Lots of code in there is still flaky and needs cleanup. That will follow in further commits. Other than that it does work fine though.
2023-07-09 18:28:12 +00:00
vulkan: Store a pointer to the first op This is not yet useful, but will be soon.
2023-07-09 21:44:52 +00:00
last = self->first_op;
vulkan: Move the render ops to the Render This is a massive refactoring because it collects all the renderops of all renderpasses into one long array in the Render object. Lots of code in there is still flaky and needs cleanup. That will follow in further commits. Other than that it does work fine though.
2023-07-09 18:28:12 +00:00
for (i = last->op_class->size; i < gsk_vulkan_render_ops_get_size (&self->render_ops); i += op->op_class->size)
{
op = (GskVulkanOp *) gsk_vulkan_render_ops_index (&self->render_ops, i);
last->next = op;
last = op;
}
}
vulkan: Sort the ops Use the OpClass.stage to order operations: 1. Put upload ops first This way we can ensure they are executed first. 2. Move subpasses for offscreens in front of the pass using them.
2023-07-09 21:45:20 +00:00
typedef struct
{
struct {
GskVulkanOp *first;
GskVulkanOp *last;
} upload, command;
} SortData;
static GskVulkanOp *
gsk_vulkan_render_sort_render_pass (GskVulkanRender *self,
GskVulkanOp *op,
SortData *sort_data)
{
while (op)
{
switch (op->op_class->stage)
{
case GSK_VULKAN_STAGE_UPLOAD:
if (sort_data->upload.first == NULL)
sort_data->upload.first = op;
else
sort_data->upload.last->next = op;
sort_data->upload.last = op;
op = op->next;
break;
case GSK_VULKAN_STAGE_COMMAND:
vulkan: Redo barriers We now store all the relevant state of the image inside the VulkanImage struct, so we can delay barriers for as long as possible. Whenever we want to use an image, we call the new gsk_vulkan_image_transition() and it will add a barrier to the desired state if one is necessary.
2023-07-15 20:19:20 +00:00
case GSK_VULKAN_STAGE_SHADER:
vulkan: Sort the ops Use the OpClass.stage to order operations: 1. Put upload ops first This way we can ensure they are executed first. 2. Move subpasses for offscreens in front of the pass using them.
2023-07-09 21:45:20 +00:00
if (sort_data->command.first == NULL)
sort_data->command.first = op;
else
sort_data->command.last->next = op;
sort_data->command.last = op;
op = op->next;
break;
case GSK_VULKAN_STAGE_BEGIN_PASS:
{
SortData pass_data = { { NULL, NULL }, { op, op } };
op = gsk_vulkan_render_sort_render_pass (self, op->next, &pass_data);
if (pass_data.upload.first)
{
if (sort_data->upload.last == NULL)
sort_data->upload.last = pass_data.upload.last;
else
pass_data.upload.last->next = sort_data->upload.first;
sort_data->upload.first = pass_data.upload.first;
}
if (sort_data->command.last == NULL)
sort_data->command.last = pass_data.command.last;
else
pass_data.command.last->next = sort_data->command.first;
sort_data->command.first = pass_data.command.first;
}
break;
case GSK_VULKAN_STAGE_END_PASS:
sort_data->command.last->next = op;
sort_data->command.last = op;
return op->next;
default:
g_assert_not_reached ();
break;
}
}
return op;
}
static void
gsk_vulkan_render_sort_ops (GskVulkanRender *self)
{
SortData sort_data = { { NULL, }, };
gsk_vulkan_render_sort_render_pass (self, self->first_op, &sort_data);
if (sort_data.upload.first)
{
sort_data.upload.last->next = sort_data.command.first;
self->first_op = sort_data.upload.first;
}
else
self->first_op = sort_data.command.first;
if (sort_data.command.last)
sort_data.command.last->next = NULL;
}
vulkan: Pass the node when setting up Remove the function to add a node from both the GskVulkanRender and the GskVulkanRenderPass. That means they are both now meant to draw exactly one node.
2023-07-05 05:06:17 +00:00
static void
vulkan: Add GskVulkanDownloadOp This op queues a download of an image. The image will only be available once the commands finished executing, so it requires waiting for the render to finish, which makes the API a bit awkward. Included is also a download_png_op() useful for debugging.
2023-07-14 21:22:35 +00:00
gsk_vulkan_render_add_node (GskVulkanRender *self,
GskRenderNode *node,
GskVulkanDownloadFunc download_func,
gpointer download_data)
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: Split renderpass op into 2 Add an explicit begin() and an end() op. For now, this looks like overkill, but it allows doing renderpasses with custom ops that are not meant to render a rendernode. Examples for this are pre/postprocessing passes or 2-pass blur.
2023-07-18 22:31:48 +00:00
GskVulkanRenderPass *render_pass;
vulkan: Pass rectangles where no regions are used The API was using regions because it always had. But all the code ever did was get the extents of the region. So simplify everything by using rectangles everywhere.
2023-07-18 22:08:56 +00:00
cairo_rectangle_int_t extents;
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
vulkan: Pass rectangles where no regions are used The API was using regions because it always had. But all the code ever did was get the extents of the region. So simplify everything by using rectangles everywhere.
2023-07-18 22:08:56 +00:00
cairo_region_get_extents (self->clip, &extents);
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
vulkan: Split renderpass op into 2 Add an explicit begin() and an end() op. For now, this looks like overkill, but it allows doing renderpasses with custom ops that are not meant to render a rendernode. Examples for this are pre/postprocessing passes or 2-pass blur.
2023-07-18 22:31:48 +00:00
gsk_vulkan_render_pass_begin_op (self,
vulkan: Plug a memleak Yay, we no longer leak swapchain images
2023-07-24 03:56:47 +00:00
self->target,
vulkan: Split renderpass op into 2 Add an explicit begin() and an end() op. For now, this looks like overkill, but it allows doing renderpasses with custom ops that are not meant to render a rendernode. Examples for this are pre/postprocessing passes or 2-pass blur.
2023-07-18 22:31:48 +00:00
&extents,
VK_IMAGE_LAYOUT_UNDEFINED,
VK_IMAGE_LAYOUT_PRESENT_SRC_KHR);
render_pass = gsk_vulkan_render_pass_new ();
gsk_vulkan_render_pass_add (render_pass,
self,
vulkan: Clean up renderpass/offscreen creation Instead of scale and whatnot, pass: 1. The image size 2. The viewport to map to that image size and compute everything else from there. In particular, we set the Vulkan viewport to the image dimensions instead of the viewport size. All of this makes things a lot simpler while keeping the required functionality.
2023-07-21 22:54:03 +00:00
gsk_vulkan_image_get_width (self->target),
gsk_vulkan_image_get_height (self->target),
vulkan: Split renderpass op into 2 Add an explicit begin() and an end() op. For now, this looks like overkill, but it allows doing renderpasses with custom ops that are not meant to render a rendernode. Examples for this are pre/postprocessing passes or 2-pass blur.
2023-07-18 22:31:48 +00:00
&extents,
vulkan: Clean up renderpass/offscreen creation Instead of scale and whatnot, pass: 1. The image size 2. The viewport to map to that image size and compute everything else from there. In particular, we set the Vulkan viewport to the image dimensions instead of the viewport size. All of this makes things a lot simpler while keeping the required functionality.
2023-07-21 22:54:03 +00:00
node,
&self->viewport);
vulkan: Split renderpass op into 2 Add an explicit begin() and an end() op. For now, this looks like overkill, but it allows doing renderpasses with custom ops that are not meant to render a rendernode. Examples for this are pre/postprocessing passes or 2-pass blur.
2023-07-18 22:31:48 +00:00
gsk_vulkan_render_pass_free (render_pass);
gsk_vulkan_render_pass_end_op (self,
vulkan: Plug a memleak Yay, we no longer leak swapchain images
2023-07-24 03:56:47 +00:00
self->target,
vulkan: Split renderpass op into 2 Add an explicit begin() and an end() op. For now, this looks like overkill, but it allows doing renderpasses with custom ops that are not meant to render a rendernode. Examples for this are pre/postprocessing passes or 2-pass blur.
2023-07-18 22:31:48 +00:00
VK_IMAGE_LAYOUT_PRESENT_SRC_KHR);
vulkan: Move the render ops to the Render This is a massive refactoring because it collects all the renderops of all renderpasses into one long array in the Render object. Lots of code in there is still flaky and needs cleanup. That will follow in further commits. Other than that it does work fine though.
2023-07-09 18:28:12 +00:00
vulkan: Add GskVulkanDownloadOp This op queues a download of an image. The image will only be available once the commands finished executing, so it requires waiting for the render to finish, which makes the API a bit awkward. Included is also a download_png_op() useful for debugging.
2023-07-14 21:22:35 +00:00
if (download_func)
gsk_vulkan_download_op (self, self->target, download_func, download_data);
vulkan: Move the render ops to the Render This is a massive refactoring because it collects all the renderops of all renderpasses into one long array in the Render object. Lots of code in there is still flaky and needs cleanup. That will follow in further commits. Other than that it does work fine though.
2023-07-09 18:28:12 +00:00
gsk_vulkan_render_seal_ops (self);
vulkan: Add infrastructure for printing ops ... and add a GSK_DEBUG=verbose setting making use of it.
2023-07-05 04:32:52 +00:00
gsk_vulkan_render_verbose_print (self, "start of frame");
vulkan: Sort the ops Use the OpClass.stage to order operations: 1. Put upload ops first This way we can ensure they are executed first. 2. Move subpasses for offscreens in front of the pass using them.
2023-07-09 21:45:20 +00:00
gsk_vulkan_render_sort_ops (self);
gsk_vulkan_render_verbose_print (self, "after sort");
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: Introduce GskVulkanShaderOp It's the new base class for shaders now. We're doing deep inheritance now, woohoo! Also, port all the shader ops to it.
2023-07-15 09:39:18 +00:00
VkPipelineLayout
gsk_vulkan_render_get_pipeline_layout (GskVulkanRender *self)
{
return self->pipeline_layout;
}
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
vulkan: Rename function The function name gsk_vulkan_render_get_pipeline() had been used for GskVulkanPipeline. Since those are gone now, we can use that name for VkPipelines.
2023-07-08 18:16:39 +00:00
gsk_vulkan_render_get_pipeline (GskVulkanRender *self,
const GskVulkanOpClass *op_class,
vulkan: Make clip type an enum and add gsk_vulkan_shader_op_alloc() that sets it properly.
2023-07-15 10:47:35 +00:00
GskVulkanShaderClip clip,
vulkan: Rename function The function name gsk_vulkan_render_get_pipeline() had been used for GskVulkanPipeline. Since those are gone now, we can use that name for VkPipelines.
2023-07-08 18:16:39 +00:00
VkRenderPass render_pass)
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
{
vulkan: Introduce GskVulkanShaderOp It's the new base class for shaders now. We're doing deep inheritance now, woohoo! Also, port all the shader ops to it.
2023-07-15 09:39:18 +00:00
const GskVulkanShaderOpClass *shader_op_class = (const GskVulkanShaderOpClass *) op_class;
vulkan: Make clip type an enum and add gsk_vulkan_shader_op_alloc() that sets it properly.
2023-07-15 10:47:35 +00:00
static const char *clip_names[] = { "", "-clip", "-clip-rounded" };
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
PipelineCacheKey cache_key;
VkPipeline pipeline;
GdkDisplay *display;
char *vertex_shader_name, *fragment_shader_name;
cache_key = (PipelineCacheKey) {
vulkan: Don't intern strings Interning strings is slow, especially if we can instead do direct pointer compares. Also refactor the pipeline lookup code a bit to make use of the refactored code.
2023-07-07 00:38:22 +00:00
.op_class = op_class,
vulkan: Make clip type an enum and add gsk_vulkan_shader_op_alloc() that sets it properly.
2023-07-15 10:47:35 +00:00
.clip = clip,
vulkan: Introduce GskVulkanShaderOp It's the new base class for shaders now. We're doing deep inheritance now, woohoo! Also, port all the shader ops to it.
2023-07-15 09:39:18 +00:00
.format = gsk_vulkan_image_get_vk_format (self->target)
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
};
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));
vulkan: Make clip type an enum and add gsk_vulkan_shader_op_alloc() that sets it properly.
2023-07-15 10:47:35 +00:00
vertex_shader_name = g_strconcat ("/org/gtk/libgsk/vulkan/", shader_op_class->shader_name, clip_names[clip], ".vert.spv", NULL);
fragment_shader_name = g_strconcat ("/org/gtk/libgsk/vulkan/", shader_op_class->shader_name, clip_names[clip], ".frag.spv", NULL);
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
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",
},
},
vulkan: Introduce GskVulkanShaderOp It's the new base class for shaders now. We're doing deep inheritance now, woohoo! Also, port all the shader ops to it.
2023-07-15 09:39:18 +00:00
.pVertexInputState = shader_op_class->vertex_input_state,
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
.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: Cache VkRenderPasses in render object Instead of recreating the same renderpass object in every frame and for every offscreen, just reuse it. Technically, we can save this per-renderer or even per-display (it should really be cached by VkDevice), but we have no infrastructure for that.
2023-07-08 18:40:48 +00:00
VkRenderPass
gsk_vulkan_render_get_render_pass (GskVulkanRender *self,
VkFormat format,
VkImageLayout from_layout,
VkImageLayout to_layout)
{
RenderPassCacheKey cache_key;
VkRenderPass render_pass;
cache_key = (RenderPassCacheKey) {
.format = format,
.from_layout = from_layout,
.to_layout = to_layout,
};
render_pass = g_hash_table_lookup (self->render_pass_cache, &cache_key);
if (render_pass)
return render_pass;
GSK_VK_CHECK (vkCreateRenderPass, gdk_vulkan_context_get_device (self->vulkan),
&(VkRenderPassCreateInfo) {
.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO,
.attachmentCount = 1,
.pAttachments = (VkAttachmentDescription[]) {
{
.format = format,
.samples = VK_SAMPLE_COUNT_1_BIT,
.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR,
.storeOp = VK_ATTACHMENT_STORE_OP_STORE,
.initialLayout = from_layout,
.finalLayout = to_layout
}
},
.subpassCount = 1,
.pSubpasses = (VkSubpassDescription []) {
{
.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS,
.inputAttachmentCount = 0,
.colorAttachmentCount = 1,
.pColorAttachments = (VkAttachmentReference []) {
{
.attachment = 0,
.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL
}
},
.pResolveAttachments = (VkAttachmentReference []) {
{
.attachment = VK_ATTACHMENT_UNUSED,
.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL
}
},
.pDepthStencilAttachment = NULL,
}
},
vulkan: Redo barriers We now store all the relevant state of the image inside the VulkanImage struct, so we can delay barriers for as long as possible. Whenever we want to use an image, we call the new gsk_vulkan_image_transition() and it will add a barrier to the desired state if one is necessary.
2023-07-15 20:19:20 +00:00
.dependencyCount = 0,
vulkan: Cache VkRenderPasses in render object Instead of recreating the same renderpass object in every frame and for every offscreen, just reuse it. Technically, we can save this per-renderer or even per-display (it should really be cached by VkDevice), but we have no infrastructure for that.
2023-07-08 18:40:48 +00:00
},
NULL,
&render_pass);
g_hash_table_insert (self->render_pass_cache, g_memdup (&cache_key, sizeof (RenderPassCacheKey)), render_pass);
return render_pass;
}
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: Move the render ops to the Render This is a massive refactoring because it collects all the renderops of all renderpasses into one long array in the Render object. Lots of code in there is still flaky and needs cleanup. That will follow in further commits. Other than that it does work fine though.
2023-07-09 18:28:12 +00:00
GskVulkanOp *op;
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);
vulkan: Store a pointer to the first op This is not yet useful, but will be soon.
2023-07-09 21:44:52 +00:00
for (op = self->first_op; op; op = op->next)
vulkan: Move the render ops to the Render This is a massive refactoring because it collects all the renderops of all renderpasses into one long array in the Render object. Lots of code in there is still flaky and needs cleanup. That will follow in further commits. Other than that it does work fine though.
2023-07-09 18:28:12 +00:00
{
gsk_vulkan_op_reserve_descriptor_sets (op, 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: Put the vertex buffer into the render object Renderpasses get recreated every frame, but we keep render objects around. So if we keep the vertex buffer in the render object, we can also keep it around and just reuse it. Also, we only need one buffer for all the render passes, which is another bonus. The initial buffer size is chosen at 128kB. Maximized Nautilus, gnome-text-editor with an open file and widget-factory take ~100kB when doing a full redraw. Other apps are between 30-50kB usually. So I chose a value that is not too big, but catches ~90% of cases.
2023-07-08 07:04:12 +00:00
static void
gsk_vulkan_render_collect_vertex_buffer (GskVulkanRender *self)
{
vulkan: Move the render ops to the Render This is a massive refactoring because it collects all the renderops of all renderpasses into one long array in the Render object. Lots of code in there is still flaky and needs cleanup. That will follow in further commits. Other than that it does work fine though.
2023-07-09 18:28:12 +00:00
GskVulkanOp *op;
vulkan: Put the vertex buffer into the render object Renderpasses get recreated every frame, but we keep render objects around. So if we keep the vertex buffer in the render object, we can also keep it around and just reuse it. Also, we only need one buffer for all the render passes, which is another bonus. The initial buffer size is chosen at 128kB. Maximized Nautilus, gnome-text-editor with an open file and widget-factory take ~100kB when doing a full redraw. Other apps are between 30-50kB usually. So I chose a value that is not too big, but catches ~90% of cases.
2023-07-08 07:04:12 +00:00
gsize n_bytes;
guchar *data;
vulkan: Move the render ops to the Render This is a massive refactoring because it collects all the renderops of all renderpasses into one long array in the Render object. Lots of code in there is still flaky and needs cleanup. That will follow in further commits. Other than that it does work fine though.
2023-07-09 18:28:12 +00:00
n_bytes = 0;
vulkan: Store a pointer to the first op This is not yet useful, but will be soon.
2023-07-09 21:44:52 +00:00
for (op = self->first_op; op; op = op->next)
vulkan: Move the render ops to the Render This is a massive refactoring because it collects all the renderops of all renderpasses into one long array in the Render object. Lots of code in there is still flaky and needs cleanup. That will follow in further commits. Other than that it does work fine though.
2023-07-09 18:28:12 +00:00
{
n_bytes = gsk_vulkan_op_count_vertex_data (op, n_bytes);
}
vulkan: Put the vertex buffer into the render object Renderpasses get recreated every frame, but we keep render objects around. So if we keep the vertex buffer in the render object, we can also keep it around and just reuse it. Also, we only need one buffer for all the render passes, which is another bonus. The initial buffer size is chosen at 128kB. Maximized Nautilus, gnome-text-editor with an open file and widget-factory take ~100kB when doing a full redraw. Other apps are between 30-50kB usually. So I chose a value that is not too big, but catches ~90% of cases.
2023-07-08 07:04:12 +00:00
if (n_bytes == 0)
return;
if (self->vertex_buffer && gsk_vulkan_buffer_get_size (self->vertex_buffer) < n_bytes)
g_clear_pointer (&self->vertex_buffer, gsk_vulkan_buffer_free);
if (self->vertex_buffer == NULL)
self->vertex_buffer = gsk_vulkan_buffer_new (self->vulkan, round_up (n_bytes, VERTEX_BUFFER_SIZE_STEP));
data = gsk_vulkan_buffer_map (self->vertex_buffer);
vulkan: Store a pointer to the first op This is not yet useful, but will be soon.
2023-07-09 21:44:52 +00:00
for (op = self->first_op; op; op = op->next)
vulkan: Move the render ops to the Render This is a massive refactoring because it collects all the renderops of all renderpasses into one long array in the Render object. Lots of code in there is still flaky and needs cleanup. That will follow in further commits. Other than that it does work fine though.
2023-07-09 18:28:12 +00:00
{
gsk_vulkan_op_collect_vertex_data (op, data);
}
vulkan: Put the vertex buffer into the render object Renderpasses get recreated every frame, but we keep render objects around. So if we keep the vertex buffer in the render object, we can also keep it around and just reuse it. Also, we only need one buffer for all the render passes, which is another bonus. The initial buffer size is chosen at 128kB. Maximized Nautilus, gnome-text-editor with an open file and widget-factory take ~100kB when doing a full redraw. Other apps are between 30-50kB usually. So I chose a value that is not too big, but catches ~90% of cases.
2023-07-08 07:04:12 +00:00
gsk_vulkan_buffer_unmap (self->vertex_buffer);
}
vulkan: Simplify render API Merge reset() and draw() into a single render() function. Also clean up some naming on the way.
2023-07-14 20:21:09 +00:00
static void
gsk_vulkan_render_submit (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: Emit a renderpass op ... instead of doing the equivalent things manually by creating a RenderPass and calling the relevant functions. Now all renderpass operations are indeed stored in ops. Also reshuffle the command emission code, because we no longer need to emit the ops for the base renderpass. As a result we only submit a single command buffer containing all the render passes instead of once per render pass. We also bind vertex buffers and descriptor sets only once now at the start instead of once per renderpass.
2023-07-10 01:42:55 +00:00
VkCommandBuffer command_buffer;
GskVulkanOp *op;
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: Put the vertex buffer into the render object Renderpasses get recreated every frame, but we keep render objects around. So if we keep the vertex buffer in the render object, we can also keep it around and just reuse it. Also, we only need one buffer for all the render passes, which is another bonus. The initial buffer size is chosen at 128kB. Maximized Nautilus, gnome-text-editor with an open file and widget-factory take ~100kB when doing a full redraw. Other apps are between 30-50kB usually. So I chose a value that is not too big, but catches ~90% of cases.
2023-07-08 07:04:12 +00:00
gsk_vulkan_render_collect_vertex_buffer (self);
vulkan: Emit a renderpass op ... instead of doing the equivalent things manually by creating a RenderPass and calling the relevant functions. Now all renderpass operations are indeed stored in ops. Also reshuffle the command emission code, because we no longer need to emit the ops for the base renderpass. As a result we only submit a single command buffer containing all the render passes instead of once per render pass. We also bind vertex buffers and descriptor sets only once now at the start instead of once per renderpass.
2023-07-10 01:42:55 +00:00
command_buffer = gsk_vulkan_command_pool_get_buffer (self->command_pool);
if (self->vertex_buffer)
vkCmdBindVertexBuffers (command_buffer,
0,
1,
(VkBuffer[1]) {
gsk_vulkan_buffer_get_buffer (self->vertex_buffer)
},
(VkDeviceSize[1]) { 0 });
vkCmdBindDescriptorSets (command_buffer,
VK_PIPELINE_BIND_POINT_GRAPHICS,
self->pipeline_layout,
0,
N_DESCRIPTOR_SETS,
self->descriptor_sets,
0,
NULL);
op = self->first_op;
while (op)
{
vulkan: Introduce GskVulkanShaderOp It's the new base class for shaders now. We're doing deep inheritance now, woohoo! Also, port all the shader ops to it.
2023-07-15 09:39:18 +00:00
op = gsk_vulkan_op_command (op, self, VK_NULL_HANDLE, command_buffer);
vulkan: Emit a renderpass op ... instead of doing the equivalent things manually by creating a RenderPass and calling the relevant functions. Now all renderpass operations are indeed stored in ops. Also reshuffle the command emission code, because we no longer need to emit the ops for the base renderpass. As a result we only submit a single command buffer containing all the render passes instead of once per render pass. We also bind vertex buffers and descriptor sets only once now at the start instead of once per renderpass.
2023-07-10 01:42:55 +00:00
}
gsk_vulkan_command_pool_submit_buffer (self->command_pool,
command_buffer,
0,
NULL,
0,
NULL,
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
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
}
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: Move the render ops to the Render This is a massive refactoring because it collects all the renderops of all renderpasses into one long array in the Render object. Lots of code in there is still flaky and needs cleanup. That will follow in further commits. Other than that it does work fine though.
2023-07-09 18:28:12 +00:00
GskVulkanOp *op;
gsize i;
vulkan: Move command pool and fence into render object
2016-12-08 17:03:05 +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
/* 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: Move the render ops to the Render This is a massive refactoring because it collects all the renderops of all renderpasses into one long array in the Render object. Lots of code in there is still flaky and needs cleanup. That will follow in further commits. Other than that it does work fine though.
2023-07-09 18:28:12 +00:00
for (i = 0; i < gsk_vulkan_render_ops_get_size (&self->render_ops); i += op->op_class->size)
{
op = (GskVulkanOp *) gsk_vulkan_render_ops_index (&self->render_ops, i);
gsk_vulkan_op_finish (op);
}
gsk_vulkan_render_ops_set_size (&self->render_ops, 0);
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: 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);
vulkan: Free storage buffer when disposing render object This caused a lot of leaked memory on the GPU when rendering textures. (Read: inside node-editor)
2023-07-17 19:03:13 +00:00
g_clear_pointer (&self->storage_buffer, gsk_vulkan_buffer_free);
vulkan: Put the vertex buffer into the render object Renderpasses get recreated every frame, but we keep render objects around. So if we keep the vertex buffer in the render object, we can also keep it around and just reuse it. Also, we only need one buffer for all the render passes, which is another bonus. The initial buffer size is chosen at 128kB. Maximized Nautilus, gnome-text-editor with an open file and widget-factory take ~100kB when doing a full redraw. Other apps are between 30-50kB usually. So I chose a value that is not too big, but catches ~90% of cases.
2023-07-08 07:04:12 +00:00
g_clear_pointer (&self->vertex_buffer, gsk_vulkan_buffer_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
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: Cache VkRenderPasses in render object Instead of recreating the same renderpass object in every frame and for every offscreen, just reuse it. Technically, we can save this per-renderer or even per-display (it should really be cached by VkDevice), but we have no infrastructure for that.
2023-07-08 18:40:48 +00:00
g_hash_table_iter_init (&iter, self->render_pass_cache);
while (g_hash_table_iter_next (&iter, &key, &value))
{
g_free (key);
vkDestroyRenderPass (device, value, NULL);
}
g_hash_table_unref (self->render_pass_cache);
vulkan: Move the render ops to the Render This is a massive refactoring because it collects all the renderops of all renderpasses into one long array in the Render object. Lots of code in there is still flaky and needs cleanup. That will follow in further commits. Other than that it does work fine though.
2023-07-09 18:28:12 +00:00
gsk_vulkan_render_ops_clear (&self->render_ops);
vulkan: Add GskVulkanUploader It's the thing that makes sure pixels end up on the GPU.
2016-12-17 03:22:44 +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
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: Simplify render API Merge reset() and draw() into a single render() function. Also clean up some naming on the way.
2023-07-14 20:21:09 +00:00
gsk_vulkan_render_render (GskVulkanRender *self,
GskVulkanImage *target,
const graphene_rect_t *rect,
const cairo_region_t *clip,
vulkan: Add GskVulkanDownloadOp This op queues a download of an image. The image will only be available once the commands finished executing, so it requires waiting for the render to finish, which makes the API a bit awkward. Included is also a download_png_op() useful for debugging.
2023-07-14 21:22:35 +00:00
GskRenderNode *node,
GskVulkanDownloadFunc download_func,
gpointer download_data)
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: Pass the node when setting up Remove the function to add a node from both the GskVulkanRender and the GskVulkanRenderPass. That means they are both now meant to draw exactly one node.
2023-07-05 05:06:17 +00:00
vulkan: Add GskVulkanDownloadOp This op queues a download of an image. The image will only be available once the commands finished executing, so it requires waiting for the render to finish, which makes the API a bit awkward. Included is also a download_png_op() useful for debugging.
2023-07-14 21:22:35 +00:00
gsk_vulkan_render_add_node (self, node, download_func, download_data);
vulkan: Simplify render API Merge reset() and draw() into a single render() function. Also clean up some naming on the way.
2023-07-14 20:21:09 +00:00
gsk_vulkan_render_submit (self);
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;
}
vulkan: Move the render ops to the Render This is a massive refactoring because it collects all the renderops of all renderpasses into one long array in the Render object. Lots of code in there is still flaky and needs cleanup. That will follow in further commits. Other than that it does work fine though.
2023-07-09 18:28:12 +00:00
vulkan: Upload cairo images "directly" Instead of using the upload vfunc and going via the code in GskVulkanImage, copy/paste the relevant code into the command() vfunc. This is meant to achieve multiple things: 1. Get rid of GskVulkanUploader and its own command buffer and general non-integration with operations. 2. Get rid of GskVulkanOp:upload() 3. Get the upload/download code machinery for GskVulkanImage and put it with the actual operations. The current code can't do direct upload/download, that will follow in a future commit.
2023-07-11 07:35:01 +00:00
GdkVulkanContext *
gsk_vulkan_render_get_context (GskVulkanRender *self)
{
return self->vulkan;
}
vulkan: Move the render ops to the Render This is a massive refactoring because it collects all the renderops of all renderpasses into one long array in the Render object. Lots of code in there is still flaky and needs cleanup. That will follow in further commits. Other than that it does work fine though.
2023-07-09 18:28:12 +00:00
gpointer
gsk_vulkan_render_alloc_op (GskVulkanRender *self,
gsize size)
{
gsize pos;
pos = gsk_vulkan_render_ops_get_size (&self->render_ops);
gsk_vulkan_render_ops_splice (&self->render_ops,
pos,
0, FALSE,
NULL,
size);
return gsk_vulkan_render_ops_index (&self->render_ops, pos);
}
Reference in New Issue Copy Permalink