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

768 lines
30 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 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 "gskvulkanpipelineprivate.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: Implement blend modes This is another example for a 2-texture shader. So far, only separable blend modes are implemented. The implementation is not optimized, with an if-else cascade in the shader.
2017-09-23 05:59:50 +00:00
#include "gskvulkanblendmodepipelineprivate.h"
A somewhat working blur shader This is a very direct implementation of a Gaussian blur, without any optimizations.
2017-09-03 13:54:47 +00:00
#include "gskvulkanblurpipelineprivate.h"
vulkan: Add shader for border rendering
2017-01-10 13:59:20 +00:00
#include "gskvulkanborderpipelineprivate.h"
vulkan: Add support for unblurred box-shadow
2017-01-18 03:07:09 +00:00
#include "gskvulkanboxshadowpipelineprivate.h"
vulkan: Split color and blend pipelines
2016-12-18 01:18:01 +00:00
#include "gskvulkancolorpipelineprivate.h"
More work on text nodes This commit takes several steps towards rendering text like we want to. The creation of the cairo surface and texture is moved to the backend (in GskVulkanRenderer). We add a mask shader that is used in the next text pipeline to use the texture as a mask, like cairo_mask_surface does. There is a separate color text pipeline that uses the already existing blend shaders to use the texture as a source, like cairo_paint does. The text node api is simplified to have just a single offset, which determines the left end of the text baseline, like all our other text drawing APIs.
2017-09-01 20:58:42 +00:00
#include "gskvulkancolortextpipelineprivate.h"
vulkan: Implement crossfade This is the first shader using two textures. It almost works.
2017-09-22 18:20:57 +00:00
#include "gskvulkancrossfadepipelineprivate.h"
vulkan: Handle opacity nodes Well, "handle" them actually. We still draw the node's child using Cairo, but we apply the opacity manually now.
2016-12-30 05:46:34 +00:00
#include "gskvulkaneffectpipelineprivate.h"
vulkan: Handle linear gradients Note: We interpolate premultiplied colors as per the CSS spec. This i different from Cairo, which interpolates unpremultiplied. So in testcases with translucent gradients, it's actually Cairo that is wrong.
2016-12-26 16:11:13 +00:00
#include "gskvulkanlineargradientpipelineprivate.h"
More work on text nodes This commit takes several steps towards rendering text like we want to. The creation of the cairo surface and texture is moved to the backend (in GskVulkanRenderer). We add a mask shader that is used in the next text pipeline to use the texture as a mask, like cairo_mask_surface does. There is a separate color text pipeline that uses the already existing blend shaders to use the texture as a source, like cairo_paint does. The text node api is simplified to have just a single offset, which determines the left end of the text baseline, like all our other text drawing APIs.
2017-09-01 20:58:42 +00:00
#include "gskvulkantextpipelineprivate.h"
vulkan: Rename blend pipeline to texture This is what it does, and the name blend is easily confused with blend-mode.
2017-09-30 02:24:53 +00:00
#include "gskvulkantexturepipelineprivate.h"
vulkan: Drop GskVulkanPipelineLayout We already move the descriptor set layout out of it, so we can just as well keep the pipeline layouts in the render object as well, and get rid of this extra object. Update all callers.
2017-09-22 17:30:26 +00:00
#include "gskvulkanpushconstantsprivate.h"
vulkan: Split color and blend pipelines
2016-12-18 01:18:01 +00:00
vulkan: Redo descriptor set handling First, we collect all the info about descriptor sets into a hash table, then we use its size to determine the amount of sets and allocate those before we finally go ahead and use the hash table's contents to initialize the descriptor sets. And then we're ready to render.
2016-12-09 01:55:47 +00:00
#define DESCRIPTOR_POOL_MAXSETS 128
#define DESCRIPTOR_POOL_MAXSETS_INCREASE 128
vulkan: Make the GskVulkanRender struct private
2016-12-08 16:55:32 +00:00
struct _GskVulkanRender
{
GskRenderer *renderer;
GdkVulkanContext *vulkan;
int scale_factor;
vulkan: Implement gsk_renderer_render_texture()
2016-12-22 18:01:07 +00:00
VkRect2D 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: 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
GHashTable *framebuffers;
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: Move remaining structs to VulkanRender object It now gets to maintain things.
2016-12-08 23:06:59 +00:00
VkRenderPass render_pass;
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
VkDescriptorSetLayout descriptor_set_layout;
vulkan: Drop GskVulkanPipelineLayout We already move the descriptor set layout out of it, so we can just as well keep the pipeline layouts in the render object as well, and get rid of this extra object. Update all callers.
2017-09-22 17:30:26 +00:00
VkPipelineLayout pipeline_layout[3]; /* indexed by number of textures */
vulkan: Add GskVulkanUploader It's the thing that makes sure pixels end up on the GPU.
2016-12-17 03:22:44 +00:00
GskVulkanUploader *uploader;
vulkan: Redo descriptor set handling First, we collect all the info about descriptor sets into a hash table, then we use its size to determine the amount of sets and allocate those before we finally go ahead and use the hash table's contents to initialize the descriptor sets. And then we're ready to render.
2016-12-09 01:55:47 +00:00
GHashTable *descriptor_set_indexes;
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: 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
uint32_t descriptor_pool_maxsets;
Allow different pipeline layouts These are differentiated by the number of textures; currently we have shaders with 0 and 1 textures.
2017-09-22 14:35:19 +00:00
VkDescriptorSet *descriptor_sets;
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 n_descriptor_sets;
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
GskVulkanPipeline *pipelines[GSK_VULKAN_N_PIPELINES];
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: Move sampler creation down This is in preparation of allowing multiple samplers.
2017-09-30 02:38:59 +00:00
VkSampler sampler;
vulkan: Implement multiple render passes Whenever we need a node as a texture, we now start a new render pass that renders the node into a new intermediate texture, and set up a semaphore to make the current render pass wait for it. As part of this reorganization, much of the setup and drawing code moved from gskvulkanrender.c to gskvulkanrenderpass.c.
2017-09-28 00:56:01 +00:00
GList *render_passes;
vulkan: Make the GskVulkanRender struct private
2016-12-08 16:55:32 +00:00
GSList *cleanup_images;
gsk: Add a profile counter for vulkan render passes This is interesting now that we have multiple render passes.
2017-09-28 12:29:14 +00:00
GQuark render_pass_counter;
vulkan: Measure gpu time Since this value is only meaningful if we wait for the rendering to end, we only keep this timer if GSK_RENDERING_MODE=sync is enabled.
2017-09-28 14:27:58 +00:00
GQuark gpu_time_timer;
vulkan: Make the GskVulkanRender struct private
2016-12-08 16:55:32 +00:00
};
vulkan: 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,
const graphene_rect_t *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
{
GdkWindow *window = gsk_renderer_get_window (self->renderer);
vulkan: Only render minimal region It's faster to render once for every rectangle in the clip region than rendering the outline of the clip region. Especially because this reduces the time necessary to build up the frame data. In widget-factory (where we have 3 rectangles), this leads to a 5x speedup in the rendering time rendering alone. Snapshotting time goes from 10ms to ~1ms, which is another huge improvement.
2016-12-26 23:18:52 +00:00
self->target = g_object_ref (target);
vulkan: Add GskVulkanRenderPass And move the actual rendering code there. A RenderPass is a collection of operations on the same target that get executed one after another. It roughly targets VkRenderPass or rather the subpasses of a VkRenderPass. For now, only the infrastructure is there. No real stuff is happening.
2016-12-08 12:26:36 +00:00
vulkan: Implement gsk_renderer_render_texture()
2016-12-22 18:01:07 +00:00
if (rect)
{
vulkan: Fix coordinate setup This makes rendering textures work when the top left of the rendered texture is not at (0, 0).
2016-12-26 13:49:34 +00:00
self->viewport = (VkRect2D) { { rect->origin.x, rect->origin.y }, { rect->size.width, rect->size.height } };
vulkan: Implement gsk_renderer_render_texture()
2016-12-22 18:01:07 +00:00
self->scale_factor = 1;
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->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
}
else
{
self->scale_factor = gsk_renderer_get_scale_factor (self->renderer);
self->viewport.offset = (VkOffset2D) { 0, 0 };
self->viewport.extent.width = gdk_window_get_width (window) * self->scale_factor;
self->viewport.extent.height = gdk_window_get_height (window) * self->scale_factor;
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->clip = gdk_drawing_context_get_clip (gsk_renderer_get_drawing_context (self->renderer));
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: Move sampler creation down This is in preparation of allowing multiple samplers.
2017-09-30 02:38:59 +00:00
static guint desc_set_index_hash (gconstpointer v);
static gboolean desc_set_index_equal (gconstpointer v1, gconstpointer v2);
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
self = g_slice_new0 (GskVulkanRender);
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: 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
self->framebuffers = g_hash_table_new (g_direct_hash, g_direct_equal);
vulkan: Move sampler creation down This is in preparation of allowing multiple samplers.
2017-09-30 02:38:59 +00:00
self->descriptor_set_indexes = g_hash_table_new_full (desc_set_index_hash, desc_set_index_equal, NULL, g_free);
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: 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
self->descriptor_pool_maxsets = DESCRIPTOR_POOL_MAXSETS;
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: 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
.maxSets = self->descriptor_pool_maxsets,
vulkan: Move remaining structs to VulkanRender object It now gets to maintain things.
2016-12-08 23:06:59 +00:00
.poolSizeCount = 1,
.pPoolSizes = (VkDescriptorPoolSize[1]) {
{
.type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
vulkanrender: Create descriptor pools with correct descriptor number
2017-01-06 04:39:03 +00:00
.descriptorCount = self->descriptor_pool_maxsets
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);
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 = gdk_vulkan_context_get_image_format (self->vulkan),
.samples = VK_SAMPLE_COUNT_1_BIT,
vulkan: Enable alpha blending We will need that once we actually composite stuff.
2016-12-09 04:51:51 +00:00
.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR,
vulkan: Move remaining structs to VulkanRender object It now gets to maintain things.
2016-12-08 23:06:59 +00:00
.storeOp = VK_ATTACHMENT_STORE_OP_STORE,
.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED,
.finalLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,
}
},
.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,
}
},
.dependencyCount = 0
},
NULL,
&self->render_pass);
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
GSK_VK_CHECK (vkCreateDescriptorSetLayout, device,
&(VkDescriptorSetLayoutCreateInfo) {
.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
.bindingCount = 1,
.pBindings = (VkDescriptorSetLayoutBinding[1]) {
{
.binding = 0,
.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
.descriptorCount = 1,
.stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT
}
}
},
NULL,
&self->descriptor_set_layout);
Allow different pipeline layouts These are differentiated by the number of textures; currently we have shaders with 0 and 1 textures.
2017-09-22 14:35:19 +00:00
for (guint i = 0; i < 3; i++)
{
VkDescriptorSetLayout layouts[3] = {
self->descriptor_set_layout,
self->descriptor_set_layout,
self->descriptor_set_layout
};
vulkan: Drop GskVulkanPipelineLayout We already move the descriptor set layout out of it, so we can just as well keep the pipeline layouts in the render object as well, and get rid of this extra object. Update all callers.
2017-09-22 17:30:26 +00:00
GSK_VK_CHECK (vkCreatePipelineLayout, device,
&(VkPipelineLayoutCreateInfo) {
.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
.setLayoutCount = i,
.pSetLayouts = layouts,
gsk: Fix a prefix mishap There shouldn't be any gst_ functions in here...
2017-09-23 17:15:30 +00:00
.pushConstantRangeCount = gsk_vulkan_push_constants_get_range_count (),
.pPushConstantRanges = gsk_vulkan_push_constants_get_ranges ()
vulkan: Drop GskVulkanPipelineLayout We already move the descriptor set layout out of it, so we can just as well keep the pipeline layouts in the render object as well, and get rid of this extra object. Update all callers.
2017-09-22 17:30:26 +00:00
},
NULL,
&self->pipeline_layout[i]);
Allow different pipeline layouts These are differentiated by the number of textures; currently we have shaders with 0 and 1 textures.
2017-09-22 14:35:19 +00:00
}
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,
.addressModeU = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER,
.addressModeV = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER,
.addressModeW = VK_SAMPLER_ADDRESS_MODE_REPEAT,
.borderColor = VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK,
.unnormalizedCoordinates = VK_FALSE,
.maxAnisotropy = 1.0,
},
NULL,
&self->sampler);
vulkan: Add GskVulkanUploader It's the thing that makes sure pixels end up on the GPU.
2016-12-17 03:22:44 +00:00
self->uploader = gsk_vulkan_uploader_new (self->vulkan, self->command_pool);
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 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
typedef struct {
VkFramebuffer framebuffer;
} HashFramebufferEntry;
static void
gsk_vulkan_render_remove_framebuffer_from_image (gpointer data,
GObject *image)
{
GskVulkanRender *self = data;
HashFramebufferEntry *fb;
fb = g_hash_table_lookup (self->framebuffers, image);
g_hash_table_remove (self->framebuffers, image);
vkDestroyFramebuffer (gdk_vulkan_context_get_device (self->vulkan),
fb->framebuffer,
NULL);
g_slice_free (HashFramebufferEntry, fb);
}
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
VkFramebuffer
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
gsk_vulkan_render_get_framebuffer (GskVulkanRender *self,
GskVulkanImage *image)
{
HashFramebufferEntry *fb;
fb = g_hash_table_lookup (self->framebuffers, image);
if (fb)
return fb->framebuffer;
fb = g_slice_new0 (HashFramebufferEntry);
GSK_VK_CHECK (vkCreateFramebuffer, gdk_vulkan_context_get_device (self->vulkan),
&(VkFramebufferCreateInfo) {
.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO,
.renderPass = self->render_pass,
.attachmentCount = 1,
.pAttachments = (VkImageView[1]) {
gsk_vulkan_image_get_image_view (image)
},
.width = gsk_vulkan_image_get_width (image),
.height = gsk_vulkan_image_get_height (image),
.layers = 1
},
NULL,
&fb->framebuffer);
g_hash_table_insert (self->framebuffers, image, fb);
g_object_weak_ref (G_OBJECT (image), gsk_vulkan_render_remove_framebuffer_from_image, self);
return fb->framebuffer;
}
vulkan: Add GskVulkanRenderPass And move the actual rendering code there. A RenderPass is a collection of operations on the same target that get executed one after another. It roughly targets VkRenderPass or rather the subpasses of a VkRenderPass. For now, only the infrastructure is there. No real stuff is happening.
2016-12-08 12:26:36 +00:00
void
gsk_vulkan_render_add_cleanup_image (GskVulkanRender *self,
GskVulkanImage *image)
{
self->cleanup_images = g_slist_prepend (self->cleanup_images, image);
}
void
gsk_vulkan_render_add_node (GskVulkanRender *self,
GskRenderNode *node)
{
vulkan: Implement multiple render passes Whenever we need a node as a texture, we now start a new render pass that renders the node into a new intermediate texture, and set up a semaphore to make the current render pass wait for it. As part of this reorganization, much of the setup and drawing code moved from gskvulkanrender.c to gskvulkanrenderpass.c.
2017-09-28 00:56:01 +00:00
GskVulkanRenderPass *pass;
vulkan: Fix setup for dependent render passes We were not correctly preserving the modelview transform.
2017-09-29 19:45:37 +00:00
graphene_matrix_t mv;
graphene_matrix_init_scale (&mv, self->scale_factor, self->scale_factor, 1.0);
vulkan: Implement multiple render passes Whenever we need a node as a texture, we now start a new render pass that renders the node into a new intermediate texture, and set up a semaphore to make the current render pass wait for it. As part of this reorganization, much of the setup and drawing code moved from gskvulkanrender.c to gskvulkanrenderpass.c.
2017-09-28 00:56:01 +00:00
pass = gsk_vulkan_render_pass_new (self->vulkan,
self->target,
self->scale_factor,
vulkan: Fix setup for dependent render passes We were not correctly preserving the modelview transform.
2017-09-29 19:45:37 +00:00
&mv,
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
&GRAPHENE_RECT_INIT (
self->viewport.offset.x, self->viewport.offset.y,
self->viewport.extent.width, self->viewport.extent.height
),
self->clip,
VK_NULL_HANDLE);
self->render_passes = g_list_prepend (self->render_passes, pass);
gsk: Add a profile counter for vulkan render passes This is interesting now that we have multiple render passes.
2017-09-28 12:29:14 +00:00
#ifdef G_ENABLE_DEBUG
gsk_profiler_counter_inc (gsk_renderer_get_profiler (self->renderer), self->render_pass_counter);
#endif
vulkan: Implement multiple render passes Whenever we need a node as a texture, we now start a new render pass that renders the node into a new intermediate texture, and set up a semaphore to make the current render pass wait for it. As part of this reorganization, much of the setup and drawing code moved from gskvulkanrender.c to gskvulkanrenderpass.c.
2017-09-28 00:56:01 +00:00
gsk_vulkan_render_pass_add (pass, self, node);
vulkan: Add GskVulkanRenderPass And move the actual rendering code there. A RenderPass is a collection of operations on the same target that get executed one after another. It roughly targets VkRenderPass or rather the subpasses of a VkRenderPass. For now, only the infrastructure is there. No real stuff is happening.
2016-12-08 12:26:36 +00:00
}
void
vulkan: Implement multiple render passes Whenever we need a node as a texture, we now start a new render pass that renders the node into a new intermediate texture, and set up a semaphore to make the current render pass wait for it. As part of this reorganization, much of the setup and drawing code moved from gskvulkanrender.c to gskvulkanrenderpass.c.
2017-09-28 00:56:01 +00:00
gsk_vulkan_render_add_node_for_texture (GskVulkanRender *self,
GskRenderNode *node,
vulkan: Fix setup for dependent render passes We were not correctly preserving the modelview transform.
2017-09-29 19:45:37 +00:00
const graphene_matrix_t *mv,
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
const graphene_rect_t *bounds,
GskVulkanImage *target,
VkSemaphore semaphore)
vulkan: Add GskVulkanRenderPass And move the actual rendering code there. A RenderPass is a collection of operations on the same target that get executed one after another. It roughly targets VkRenderPass or rather the subpasses of a VkRenderPass. For now, only the infrastructure is there. No real stuff is happening.
2016-12-08 12:26:36 +00:00
{
vulkan: Implement multiple render passes Whenever we need a node as a texture, we now start a new render pass that renders the node into a new intermediate texture, and set up a semaphore to make the current render pass wait for it. As part of this reorganization, much of the setup and drawing code moved from gskvulkanrender.c to gskvulkanrenderpass.c.
2017-09-28 00:56:01 +00:00
GskVulkanRenderPass *pass;
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: 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
clip = cairo_region_create_rectangle (&(cairo_rectangle_int_t) {
0, 0,
gsk_vulkan_image_get_width (target),
gsk_vulkan_image_get_height (target)
});
vulkan: Batch upload image barriers together Doesn't seem to help much though...
2016-12-17 03:54:19 +00:00
vulkan: Implement multiple render passes Whenever we need a node as a texture, we now start a new render pass that renders the node into a new intermediate texture, and set up a semaphore to make the current render pass wait for it. As part of this reorganization, much of the setup and drawing code moved from gskvulkanrender.c to gskvulkanrenderpass.c.
2017-09-28 00:56:01 +00:00
pass = gsk_vulkan_render_pass_new (self->vulkan,
target,
1,
vulkan: Fix setup for dependent render passes We were not correctly preserving the modelview transform.
2017-09-29 19:45:37 +00:00
mv,
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
bounds,
clip,
semaphore);
vulkan: Add GskVulkanRenderPass And move the actual rendering code there. A RenderPass is a collection of operations on the same target that get executed one after another. It roughly targets VkRenderPass or rather the subpasses of a VkRenderPass. For now, only the infrastructure is there. No real stuff is happening.
2016-12-08 12:26:36 +00:00
vulkan: Implement multiple render passes Whenever we need a node as a texture, we now start a new render pass that renders the node into a new intermediate texture, and set up a semaphore to make the current render pass wait for it. As part of this reorganization, much of the setup and drawing code moved from gskvulkanrender.c to gskvulkanrenderpass.c.
2017-09-28 00:56:01 +00:00
cairo_region_destroy (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: Implement multiple render passes Whenever we need a node as a texture, we now start a new render pass that renders the node into a new intermediate texture, and set up a semaphore to make the current render pass wait for it. As part of this reorganization, much of the setup and drawing code moved from gskvulkanrender.c to gskvulkanrenderpass.c.
2017-09-28 00:56:01 +00:00
self->render_passes = g_list_prepend (self->render_passes, pass);
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: 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
gsk_profiler_counter_inc (gsk_renderer_get_profiler (self->renderer), self->render_pass_counter);
#endif
vulkan: Implement multiple render passes Whenever we need a node as a texture, we now start a new render pass that renders the node into a new intermediate texture, and set up a semaphore to make the current render pass wait for it. As part of this reorganization, much of the setup and drawing code moved from gskvulkanrender.c to gskvulkanrenderpass.c.
2017-09-28 00:56:01 +00:00
gsk_vulkan_render_pass_add (pass, self, node);
vulkan: Add GskVulkanRenderPass And move the actual rendering code there. A RenderPass is a collection of operations on the same target that get executed one after another. It roughly targets VkRenderPass or rather the subpasses of a VkRenderPass. For now, only the infrastructure is there. No real stuff is happening.
2016-12-08 12:26:36 +00:00
}
vulkan: Implement multiple render passes Whenever we need a node as a texture, we now start a new render pass that renders the node into a new intermediate texture, and set up a semaphore to make the current render pass wait for it. As part of this reorganization, much of the setup and drawing code moved from gskvulkanrender.c to gskvulkanrenderpass.c.
2017-09-28 00:56:01 +00:00
void
gsk_vulkan_render_upload (GskVulkanRender *self)
vulkan: Add GskVulkanRenderPass And move the actual rendering code there. A RenderPass is a collection of operations on the same target that get executed one after another. It roughly targets VkRenderPass or rather the subpasses of a VkRenderPass. For now, only the infrastructure is there. No real stuff is happening.
2016-12-08 12:26:36 +00:00
{
vulkan: Implement multiple render passes Whenever we need a node as a texture, we now start a new render pass that renders the node into a new intermediate texture, and set up a semaphore to make the current render pass wait for it. As part of this reorganization, much of the setup and drawing code moved from gskvulkanrender.c to gskvulkanrenderpass.c.
2017-09-28 00:56:01 +00:00
GList *l;
vulkan: Add GskVulkanRenderPass And move the actual rendering code there. A RenderPass is a collection of operations on the same target that get executed one after another. It roughly targets VkRenderPass or rather the subpasses of a VkRenderPass. For now, only the infrastructure is there. No real stuff is happening.
2016-12-08 12:26:36 +00:00
vulkan: Implement multiple render passes Whenever we need a node as a texture, we now start a new render pass that renders the node into a new intermediate texture, and set up a semaphore to make the current render pass wait for it. As part of this reorganization, much of the setup and drawing code moved from gskvulkanrender.c to gskvulkanrenderpass.c.
2017-09-28 00:56:01 +00:00
/* gsk_vulkan_render_pass_upload may call gsk_vulkan_render_add_node_for_texture,
* prepending new render passes to the list. Therefore, we walk the list from
* the end.
*/
for (l = g_list_last (self->render_passes); l; l = l->prev)
vulkan: Add GskVulkanRenderPass And move the actual rendering code there. A RenderPass is a collection of operations on the same target that get executed one after another. It roughly targets VkRenderPass or rather the subpasses of a VkRenderPass. For now, only the infrastructure is there. No real stuff is happening.
2016-12-08 12:26:36 +00:00
{
vulkan: Implement multiple render passes Whenever we need a node as a texture, we now start a new render pass that renders the node into a new intermediate texture, and set up a semaphore to make the current render pass wait for it. As part of this reorganization, much of the setup and drawing code moved from gskvulkanrender.c to gskvulkanrenderpass.c.
2017-09-28 00:56:01 +00:00
GskVulkanRenderPass *pass = l->data;
gsk_vulkan_render_pass_upload (pass, self, self->uploader);
vulkan: Add GskVulkanRenderPass And move the actual rendering code there. A RenderPass is a collection of operations on the same target that get executed one after another. It roughly targets VkRenderPass or rather the subpasses of a VkRenderPass. For now, only the infrastructure is there. No real stuff is happening.
2016-12-08 12:26:36 +00:00
}
vulkan: Implement multiple render passes Whenever we need a node as a texture, we now start a new render pass that renders the node into a new intermediate texture, and set up a semaphore to make the current render pass wait for it. As part of this reorganization, much of the setup and drawing code moved from gskvulkanrender.c to gskvulkanrenderpass.c.
2017-09-28 00:56:01 +00:00
gsk_vulkan_uploader_upload (self->uploader);
vulkan: Add GskVulkanRenderPass And move the actual rendering code there. A RenderPass is a collection of operations on the same target that get executed one after another. It roughly targets VkRenderPass or rather the subpasses of a VkRenderPass. For now, only the infrastructure is there. No real stuff is happening.
2016-12-08 12:26:36 +00:00
}
vulkan: Add infrastructure for multiple pipelines And use it to draw solid colors with a 2nd pipeline.
2016-12-14 08:40:15 +00:00
GskVulkanPipeline *
gsk_vulkan_render_get_pipeline (GskVulkanRender *self,
GskVulkanPipelineType type)
{
static const struct {
const char *name;
Allow different pipeline layouts These are differentiated by the number of textures; currently we have shaders with 0 and 1 textures.
2017-09-22 14:35:19 +00:00
guint num_textures;
vulkan: Drop GskVulkanPipelineLayout We already move the descriptor set layout out of it, so we can just as well keep the pipeline layouts in the render object as well, and get rid of this extra object. Update all callers.
2017-09-22 17:30:26 +00:00
GskVulkanPipeline * (* create_func) (GdkVulkanContext *context, VkPipelineLayout layout, const char *name, VkRenderPass render_pass);
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
} pipeline_info[GSK_VULKAN_N_PIPELINES] = {
vulkan: Rename blend pipeline to texture This is what it does, and the name blend is easily confused with blend-mode.
2017-09-30 02:24:53 +00:00
{ "texture", 1, gsk_vulkan_texture_pipeline_new },
{ "texture-clip", 1, gsk_vulkan_texture_pipeline_new },
{ "texture-clip-rounded", 1, gsk_vulkan_texture_pipeline_new },
Allow different pipeline layouts These are differentiated by the number of textures; currently we have shaders with 0 and 1 textures.
2017-09-22 14:35:19 +00:00
{ "color", 0, gsk_vulkan_color_pipeline_new },
{ "color-clip", 0, gsk_vulkan_color_pipeline_new },
{ "color-clip-rounded", 0, gsk_vulkan_color_pipeline_new },
{ "linear", 0, gsk_vulkan_linear_gradient_pipeline_new },
{ "linear-clip", 0, gsk_vulkan_linear_gradient_pipeline_new },
{ "linear-clip-rounded", 0, gsk_vulkan_linear_gradient_pipeline_new },
{ "color-matrix", 1, gsk_vulkan_effect_pipeline_new },
{ "color-matrix-clip", 1, gsk_vulkan_effect_pipeline_new },
{ "color-matrix-clip-rounded", 1, gsk_vulkan_effect_pipeline_new },
{ "border", 0, gsk_vulkan_border_pipeline_new },
{ "border-clip", 0, gsk_vulkan_border_pipeline_new },
{ "border-clip-rounded", 0, gsk_vulkan_border_pipeline_new },
{ "inset-shadow", 0, gsk_vulkan_box_shadow_pipeline_new },
{ "inset-shadow-clip", 0, gsk_vulkan_box_shadow_pipeline_new },
{ "inset-shadow-clip-rounded", 0, gsk_vulkan_box_shadow_pipeline_new },
{ "outset-shadow", 0, gsk_vulkan_box_shadow_pipeline_new },
{ "outset-shadow-clip", 0, gsk_vulkan_box_shadow_pipeline_new },
{ "outset-shadow-clip-rounded", 0, gsk_vulkan_box_shadow_pipeline_new },
{ "blur", 1, gsk_vulkan_blur_pipeline_new },
{ "blur-clip", 1, gsk_vulkan_blur_pipeline_new },
{ "blur-clip-rounded", 1, gsk_vulkan_blur_pipeline_new },
{ "mask", 1, gsk_vulkan_text_pipeline_new },
{ "mask-clip", 1, gsk_vulkan_text_pipeline_new },
{ "mask-clip-rounded", 1, gsk_vulkan_text_pipeline_new },
{ "blend", 1, gsk_vulkan_color_text_pipeline_new },
{ "blend-clip", 1, gsk_vulkan_color_text_pipeline_new },
{ "blend-clip-rounded", 1, gsk_vulkan_color_text_pipeline_new },
vulkan: Implement crossfade This is the first shader using two textures. It almost works.
2017-09-22 18:20:57 +00:00
{ "crossfade", 2, gsk_vulkan_cross_fade_pipeline_new },
{ "crossfade-clip", 2, gsk_vulkan_cross_fade_pipeline_new },
{ "crossfade-clip-rounded", 2, gsk_vulkan_cross_fade_pipeline_new },
vulkan: Implement blend modes This is another example for a 2-texture shader. So far, only separable blend modes are implemented. The implementation is not optimized, with an if-else cascade in the shader.
2017-09-23 05:59:50 +00:00
{ "blendmode", 2, gsk_vulkan_blend_mode_pipeline_new },
{ "blendmode-clip", 2, gsk_vulkan_blend_mode_pipeline_new },
{ "blendmode-clip-rounded", 2, gsk_vulkan_blend_mode_pipeline_new },
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
};
g_return_val_if_fail (type < GSK_VULKAN_N_PIPELINES, NULL);
if (self->pipelines[type] == NULL)
vulkan: Drop GskVulkanPipelineLayout We already move the descriptor set layout out of it, so we can just as well keep the pipeline layouts in the render object as well, and get rid of this extra object. Update all callers.
2017-09-22 17:30:26 +00:00
self->pipelines[type] = pipeline_info[type].create_func (self->vulkan,
self->pipeline_layout[pipeline_info[type].num_textures],
pipeline_info[type].name,
self->render_pass);
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
return self->pipelines[type];
}
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
VkDescriptorSet
gsk_vulkan_render_get_descriptor_set (GskVulkanRender *self,
gsize id)
{
g_assert (id < self->n_descriptor_sets);
return self->descriptor_sets[id];
}
vulkan: Move sampler creation down This is in preparation of allowing multiple samplers.
2017-09-30 02:38:59 +00:00
typedef struct {
gsize index;
GskVulkanImage *image;
} HashDescriptorSetIndexEntry;
static guint
desc_set_index_hash (gconstpointer v)
{
const HashDescriptorSetIndexEntry *e = v;
return GPOINTER_TO_UINT (e->image);
}
static gboolean
desc_set_index_equal (gconstpointer v1, gconstpointer v2)
{
const HashDescriptorSetIndexEntry *e1 = v1;
const HashDescriptorSetIndexEntry *e2 = v2;
return e1->image == e2->image;
}
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
gsk_vulkan_render_reserve_descriptor_set (GskVulkanRender *self,
GskVulkanImage *source)
{
vulkan: Move sampler creation down This is in preparation of allowing multiple samplers.
2017-09-30 02:38:59 +00:00
HashDescriptorSetIndexEntry lookup;
HashDescriptorSetIndexEntry *entry;
vulkan: Redo descriptor set handling First, we collect all the info about descriptor sets into a hash table, then we use its size to determine the amount of sets and allocate those before we finally go ahead and use the hash table's contents to initialize the descriptor sets. And then we're ready to render.
2016-12-09 01:55:47 +00:00
vulkan: Implement multiple render passes Whenever we need a node as a texture, we now start a new render pass that renders the node into a new intermediate texture, and set up a semaphore to make the current render pass wait for it. As part of this reorganization, much of the setup and drawing code moved from gskvulkanrender.c to gskvulkanrenderpass.c.
2017-09-28 00:56:01 +00:00
g_assert (source != NULL);
vulkan: Move sampler creation down This is in preparation of allowing multiple samplers.
2017-09-30 02:38:59 +00:00
lookup.image = source;
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: Move sampler creation down This is in preparation of allowing multiple samplers.
2017-09-30 02:38:59 +00:00
entry = g_hash_table_lookup (self->descriptor_set_indexes, &lookup);
if (entry)
return entry->index;
entry = g_new (HashDescriptorSetIndexEntry, 1);
entry->image = source;
entry->index = g_hash_table_size (self->descriptor_set_indexes);
g_hash_table_add (self->descriptor_set_indexes, entry);
return entry->index;
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
{
GHashTableIter iter;
vulkan: Move sampler creation down This is in preparation of allowing multiple samplers.
2017-09-30 02:38:59 +00:00
gpointer key;
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: Implement multiple render passes Whenever we need a node as a texture, we now start a new render pass that renders the node into a new intermediate texture, and set up a semaphore to make the current render pass wait for it. As part of this reorganization, much of the setup and drawing code moved from gskvulkanrender.c to gskvulkanrenderpass.c.
2017-09-28 00:56:01 +00:00
GList *l;
vulkan: Redo descriptor set handling First, we collect all the info about descriptor sets into a hash table, then we use its size to determine the amount of sets and allocate those before we finally go ahead and use the hash table's contents to initialize the descriptor sets. And then we're ready to render.
2016-12-09 01:55:47 +00:00
guint i, needed_sets;
device = gdk_vulkan_context_get_device (self->vulkan);
for (l = self->render_passes; l; l = l->next)
{
vulkan: Implement multiple render passes Whenever we need a node as a texture, we now start a new render pass that renders the node into a new intermediate texture, and set up a semaphore to make the current render pass wait for it. As part of this reorganization, much of the setup and drawing code moved from gskvulkanrender.c to gskvulkanrenderpass.c.
2017-09-28 00:56:01 +00:00
GskVulkanRenderPass *pass = l->data;
gsk_vulkan_render_pass_reserve_descriptor_sets (pass, self);
vulkan: Redo descriptor set handling First, we collect all the info about descriptor sets into a hash table, then we use its size to determine the amount of sets and allocate those before we finally go ahead and use the hash table's contents to initialize the descriptor sets. And then we're ready to render.
2016-12-09 01:55:47 +00:00
}
needed_sets = g_hash_table_size (self->descriptor_set_indexes);
if (needed_sets > self->n_descriptor_sets)
{
vulkan: Don't limit number of descriptor sets If we need more than we have reserved as maximum, recreate the descriptor pool with a higher maximum.
2016-12-09 05:09:52 +00:00
if (needed_sets > self->descriptor_pool_maxsets)
{
guint added_sets = needed_sets - self->descriptor_pool_maxsets;
added_sets = added_sets + DESCRIPTOR_POOL_MAXSETS_INCREASE - 1;
added_sets -= added_sets % DESCRIPTOR_POOL_MAXSETS_INCREASE;
vkDestroyDescriptorPool (device,
self->descriptor_pool,
NULL);
self->descriptor_pool_maxsets += added_sets;
GSK_VK_CHECK (vkCreateDescriptorPool, device,
&(VkDescriptorPoolCreateInfo) {
.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO,
.maxSets = self->descriptor_pool_maxsets,
.poolSizeCount = 1,
.pPoolSizes = (VkDescriptorPoolSize[1]) {
{
.type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
vulkanrender: Create descriptor pools with correct descriptor number
2017-01-06 04:39:03 +00:00
.descriptorCount = self->descriptor_pool_maxsets
vulkan: Don't limit number of descriptor sets If we need more than we have reserved as maximum, recreate the descriptor pool with a higher maximum.
2016-12-09 05:09:52 +00:00
}
}
},
NULL,
&self->descriptor_pool);
}
else
{
GSK_VK_CHECK (vkResetDescriptorPool, device,
self->descriptor_pool,
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
self->n_descriptor_sets = needed_sets;
self->descriptor_sets = g_renew (VkDescriptorSet, self->descriptor_sets, needed_sets);
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: 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: 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
VkDescriptorSetLayout *layouts = g_newa (VkDescriptorSetLayout, needed_sets);
for (i = 0; i < needed_sets; i++)
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
layouts[i] = self->descriptor_set_layout;
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: 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,
.descriptorSetCount = needed_sets,
.pSetLayouts = layouts
},
self->descriptor_sets);
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
g_hash_table_iter_init (&iter, self->descriptor_set_indexes);
vulkan: Move sampler creation down This is in preparation of allowing multiple samplers.
2017-09-30 02:38:59 +00:00
while (g_hash_table_iter_next (&iter, &key, 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: Move sampler creation down This is in preparation of allowing multiple samplers.
2017-09-30 02:38:59 +00:00
HashDescriptorSetIndexEntry *entry = key;
GskVulkanImage *image = entry->image;
gsize id = entry->index;
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
vkUpdateDescriptorSets (device,
1,
(VkWriteDescriptorSet[1]) {
{
.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
.dstSet = self->descriptor_sets[id],
.dstBinding = 0,
.dstArrayElement = 0,
.descriptorCount = 1,
.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
.pImageInfo = &(VkDescriptorImageInfo) {
vulkan: Move sampler creation down This is in preparation of allowing multiple samplers.
2017-09-30 02:38:59 +00:00
.sampler = self->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
.imageView = gsk_vulkan_image_get_image_view (image),
.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL
}
}
},
0, NULL);
}
}
vulkan: Add GskVulkanRenderPass And move the actual rendering code there. A RenderPass is a collection of operations on the same target that get executed one after another. It roughly targets VkRenderPass or rather the subpasses of a VkRenderPass. For now, only the infrastructure is there. No real stuff is happening.
2016-12-08 12:26:36 +00:00
void
vulkan: Move sampler creation down This is in preparation of allowing multiple samplers.
2017-09-30 02:38:59 +00:00
gsk_vulkan_render_draw (GskVulkanRender *self)
vulkan: Add GskVulkanRenderPass And move the actual rendering code there. A RenderPass is a collection of operations on the same target that get executed one after another. It roughly targets VkRenderPass or rather the subpasses of a VkRenderPass. For now, only the infrastructure is there. No real stuff is happening.
2016-12-08 12:26:36 +00:00
{
vulkan: Implement multiple render passes Whenever we need a node as a texture, we now start a new render pass that renders the node into a new intermediate texture, and set up a semaphore to make the current render pass wait for it. As part of this reorganization, much of the setup and drawing code moved from gskvulkanrender.c to gskvulkanrenderpass.c.
2017-09-28 00:56:01 +00:00
GList *l;
vulkan: Add GskVulkanRenderPass And move the actual rendering code there. A RenderPass is a collection of operations on the same target that get executed one after another. It roughly targets VkRenderPass or rather the subpasses of a VkRenderPass. For now, only the infrastructure is there. No real stuff is happening.
2016-12-08 12:26:36 +00:00
vulkan: Measure gpu time Since this value is only meaningful if we wait for the rendering to end, we only keep this timer if GSK_RENDERING_MODE=sync is enabled.
2017-09-28 14:27:58 +00:00
#ifdef G_ENABLE_DEBUG
if (GSK_RENDER_MODE_CHECK (SYNC))
gsk_profiler_timer_begin (gsk_renderer_get_profiler (self->renderer), self->gpu_time_timer);
#endif
vulkan: Move sampler creation down This is in preparation of allowing multiple samplers.
2017-09-30 02:38:59 +00:00
gsk_vulkan_render_prepare_descriptor_sets (self);
vulkan: Add GskVulkanRenderPass And move the actual rendering code there. A RenderPass is a collection of operations on the same target that get executed one after another. It roughly targets VkRenderPass or rather the subpasses of a VkRenderPass. For now, only the infrastructure is there. No real stuff is happening.
2016-12-08 12:26:36 +00:00
vulkan: Implement multiple render passes Whenever we need a node as a texture, we now start a new render pass that renders the node into a new intermediate texture, and set up a semaphore to make the current render pass wait for it. As part of this reorganization, much of the setup and drawing code moved from gskvulkanrender.c to gskvulkanrenderpass.c.
2017-09-28 00:56:01 +00:00
for (l = self->render_passes; l; l = l->next)
vulkan: Only render minimal region It's faster to render once for every rectangle in the clip region than rendering the outline of the clip region. Especially because this reduces the time necessary to build up the frame data. In widget-factory (where we have 3 rectangles), this leads to a 5x speedup in the rendering time rendering alone. Snapshotting time goes from 10ms to ~1ms, which is another huge improvement.
2016-12-26 23:18:52 +00:00
{
vulkan: Implement multiple render passes Whenever we need a node as a texture, we now start a new render pass that renders the node into a new intermediate texture, and set up a semaphore to make the current render pass wait for it. As part of this reorganization, much of the setup and drawing code moved from gskvulkanrender.c to gskvulkanrenderpass.c.
2017-09-28 00:56:01 +00:00
GskVulkanRenderPass *pass = l->data;
VkCommandBuffer command_buffer;
gsize wait_semaphore_count;
gsize signal_semaphore_count;
VkSemaphore *wait_semaphores;
VkSemaphore *signal_semaphores;
wait_semaphore_count = gsk_vulkan_render_pass_get_wait_semaphores (pass, &wait_semaphores);
signal_semaphore_count = gsk_vulkan_render_pass_get_signal_semaphores (pass, &signal_semaphores);
command_buffer = gsk_vulkan_command_pool_get_buffer (self->command_pool);
gsk_vulkan_render_pass_draw (pass, self, 3, self->pipeline_layout, command_buffer);
gsk_vulkan_command_pool_submit_buffer (self->command_pool,
command_buffer,
wait_semaphore_count,
wait_semaphores,
signal_semaphore_count,
signal_semaphores,
l->next != NULL ? VK_NULL_HANDLE : self->fence);
vulkan: Only render minimal region It's faster to render once for every rectangle in the clip region than rendering the outline of the clip region. Especially because this reduces the time necessary to build up the frame data. In widget-factory (where we have 3 rectangles), this leads to a 5x speedup in the rendering time rendering alone. Snapshotting time goes from 10ms to ~1ms, which is another huge improvement.
2016-12-26 23:18:52 +00:00
}
vulkan: Add GskVulkanRenderPass And move the actual rendering code there. A RenderPass is a collection of operations on the same target that get executed one after another. It roughly targets VkRenderPass or rather the subpasses of a VkRenderPass. For now, only the infrastructure is there. No real stuff is happening.
2016-12-08 12:26:36 +00:00
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
if (GSK_RENDER_MODE_CHECK (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
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
}
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: Implement gsk_renderer_render_texture()
2016-12-22 18:01:07 +00:00
GskTexture *
gsk_vulkan_render_download_target (GskVulkanRender *self)
{
gsk_vulkan_uploader_reset (self->uploader);
return gsk_vulkan_image_download (self->target, self->uploader);
}
vulkan: Keep render objects around That way we can reuse them. We only create a new one if the last render operation hasn't finished executing.
2016-12-08 17:40:35 +00:00
static void
gsk_vulkan_render_cleanup (GskVulkanRender *self)
vulkan: Add GskVulkanRender object This is refactoring work. GskVulkanRender is supposed to be the global object for a render operation, ie GskVulkanRenderer.render() will create this object for what it does. The object will be split into stages that perform the operations necessary to create a drawing.
2016-12-07 13:50:52 +00:00
{
vulkan: Move command pool and fence into render object
2016-12-08 17:03:05 +00:00
VkDevice device = gdk_vulkan_context_get_device (self->vulkan);
vulkan: Keep render objects around That way we can reuse them. We only create a new one if the last render operation hasn't finished executing.
2016-12-08 17:40:35 +00:00
/* XXX: Wait for fence here or just in reset()? */
GSK_VK_CHECK (vkWaitForFences, device,
1,
&self->fence,
VK_TRUE,
INT64_MAX);
GSK_VK_CHECK (vkResetFences, device,
1,
&self->fence);
vulkan: Split out command pool This way we can pass the command pool around. And that allows us to allocate and submitcustom buffers. And that is necessary to make staging images work.
2016-12-16 05:10:24 +00:00
vulkan: Add GskVulkanUploader It's the thing that makes sure pixels end up on the GPU.
2016-12-17 03:22:44 +00:00
gsk_vulkan_uploader_reset (self->uploader);
vulkan: Split out command pool This way we can pass the command pool around. And that allows us to allocate and submitcustom buffers. And that is necessary to make staging images work.
2016-12-16 05:10:24 +00:00
gsk_vulkan_command_pool_reset (self->command_pool);
vulkan: Add GskVulkanRenderPass And move the actual rendering code there. A RenderPass is a collection of operations on the same target that get executed one after another. It roughly targets VkRenderPass or rather the subpasses of a VkRenderPass. For now, only the infrastructure is there. No real stuff is happening.
2016-12-08 12:26:36 +00:00
vulkan: 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
g_hash_table_remove_all (self->descriptor_set_indexes);
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: Redo descriptor set handling First, we collect all the info about descriptor sets into a hash table, then we use its size to determine the amount of sets and allocate those before we finally go ahead and use the hash table's contents to initialize the descriptor sets. And then we're ready to render.
2016-12-09 01:55:47 +00:00
vulkan: Implement multiple render passes Whenever we need a node as a texture, we now start a new render pass that renders the node into a new intermediate texture, and set up a semaphore to make the current render pass wait for it. As part of this reorganization, much of the setup and drawing code moved from gskvulkanrender.c to gskvulkanrenderpass.c.
2017-09-28 00:56:01 +00:00
g_list_free_full (self->render_passes, (GDestroyNotify) gsk_vulkan_render_pass_free);
vulkan: Keep render objects around That way we can reuse them. We only create a new one if the last render operation hasn't finished executing.
2016-12-08 17:40:35 +00:00
self->render_passes = NULL;
vulkan: Turn GskVulkanImage into a GObject This way, we can do real refcounting on them.
2016-12-08 19:19:56 +00:00
g_slist_free_full (self->cleanup_images, g_object_unref);
vulkan: Keep render objects around That way we can reuse them. We only create a new one if the last render operation hasn't finished executing.
2016-12-08 17:40:35 +00:00
self->cleanup_images = NULL;
vulkan: Create framebuffers from GskVulkanRender object Also create them on-demand, as they need to be created per-image and per-framebuffer, so we don't want to create loads of them.
2016-12-08 21:35:16 +00:00
vulkan: Only render minimal region It's faster to render once for every rectangle in the clip region than rendering the outline of the clip region. Especially because this reduces the time necessary to build up the frame data. In widget-factory (where we have 3 rectangles), this leads to a 5x speedup in the rendering time rendering alone. Snapshotting time goes from 10ms to ~1ms, which is another huge improvement.
2016-12-26 23:18:52 +00:00
g_clear_pointer (&self->clip, cairo_region_destroy);
vulkan: Create framebuffers from GskVulkanRender object Also create them on-demand, as they need to be created per-image and per-framebuffer, so we don't want to create loads of them.
2016-12-08 21:35:16 +00:00
g_clear_object (&self->target);
vulkan: Keep render objects around That way we can reuse them. We only create a new one if the last render operation hasn't finished executing.
2016-12-08 17:40:35 +00:00
}
void
gsk_vulkan_render_free (GskVulkanRender *self)
{
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
GHashTableIter iter;
gpointer key, value;
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
VkDevice device;
vulkan: Add infrastructure for multiple pipelines And use it to draw solid colors with a 2nd pipeline.
2016-12-14 08:40:15 +00:00
guint i;
vulkan: Keep render objects around That way we can reuse them. We only create a new one if the last render operation hasn't finished executing.
2016-12-08 17:40:35 +00:00
gsk_vulkan_render_cleanup (self);
device = gdk_vulkan_context_get_device (self->vulkan);
vulkan: Make the VulkanRender object allocated That way, we can have multiple of those and keep them around for reuse.
2016-12-08 16:46:08 +00:00
vulkan: Create 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_hash_table_iter_init (&iter, self->framebuffers);
while (g_hash_table_iter_next (&iter, &key, &value))
{
HashFramebufferEntry *fb = value;
vkDestroyFramebuffer (gdk_vulkan_context_get_device (self->vulkan),
fb->framebuffer,
NULL);
g_slice_free (HashFramebufferEntry, fb);
g_object_weak_unref (G_OBJECT (key), gsk_vulkan_render_remove_framebuffer_from_image, self);
g_hash_table_iter_remove (&iter);
}
g_hash_table_unref (self->framebuffers);
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
for (i = 0; i < GSK_VULKAN_N_PIPELINES; i++)
g_clear_object (&self->pipelines[i]);
vulkan: Move remaining structs to VulkanRender object It now gets to maintain things.
2016-12-08 23:06:59 +00:00
vulkan: Add GskVulkanUploader It's the thing that makes sure pixels end up on the GPU.
2016-12-17 03:22:44 +00:00
g_clear_pointer (&self->uploader, gsk_vulkan_uploader_free);
Allow different pipeline layouts These are differentiated by the number of textures; currently we have shaders with 0 and 1 textures.
2017-09-22 14:35:19 +00:00
for (i = 0; i < 3; i++)
vulkan: Drop GskVulkanPipelineLayout We already move the descriptor set layout out of it, so we can just as well keep the pipeline layouts in the render object as well, and get rid of this extra object. Update all callers.
2017-09-22 17:30:26 +00:00
vkDestroyPipelineLayout (device,
self->pipeline_layout[i],
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
vkDestroyRenderPass (device,
self->render_pass,
NULL);
vkDestroyDescriptorPool (device,
self->descriptor_pool,
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
g_free (self->descriptor_sets);
g_hash_table_unref (self->descriptor_set_indexes);
vulkan: Move remaining structs to VulkanRender object It now gets to maintain things.
2016-12-08 23:06:59 +00:00
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
vkDestroyDescriptorSetLayout (device,
self->descriptor_set_layout,
NULL);
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: Move sampler creation down This is in preparation of allowing multiple samplers.
2017-09-30 02:38:59 +00:00
vkDestroySampler (device,
self->sampler,
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
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
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
g_slice_free (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: Make the GskVulkanRender struct private
2016-12-08 16:55:32 +00:00
vulkan: Keep render objects around That way we can reuse them. We only create a new one if the last render operation hasn't finished executing.
2016-12-08 17:40:35 +00:00
gboolean
gsk_vulkan_render_is_busy (GskVulkanRender *self)
{
return vkGetFenceStatus (gdk_vulkan_context_get_device (self->vulkan), self->fence) != VK_SUCCESS;
}
void
vulkan: Implement gsk_renderer_render_texture()
2016-12-22 18:01:07 +00:00
gsk_vulkan_render_reset (GskVulkanRender *self,
GskVulkanImage *target,
const graphene_rect_t *rect)
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: 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 (self, target, rect);
vulkan: Keep render objects around That way we can reuse them. We only create a new one if the last render operation hasn't finished executing.
2016-12-08 17:40:35 +00:00
}
vulkan: Make the GskVulkanRender struct private
2016-12-08 16:55:32 +00:00
GskRenderer *
gsk_vulkan_render_get_renderer (GskVulkanRender *self)
{
return self->renderer;
}
Reference in New Issue Copy Permalink