AuroraMiddleware/gtk2
1
0
Fork 0
forked from AuroraMiddleware/gtk
Code Issues Pull Requests Projects Releases Wiki Activity
d3239c953d
gtk2/gsk/vulkan/gskvulkanrender.c

777 lines
31 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;
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: 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: Add a repeating sampler None of the render ops use it, yet.
2017-09-30 03:01:34 +00:00
VkSampler repeating_sampler;
vulkan: Move sampler creation down This is in preparation of allowing multiple samplers.
2017-09-30 02:38:59 +00:00
vulkan: Implement multiple render passes Whenever we need a node as a texture, we now start a new render pass that renders the node into a new intermediate texture, and set up a semaphore to make the current render pass wait for it. As part of this reorganization, much of the setup and drawing code moved from gskvulkanrender.c to gskvulkanrenderpass.c.
2017-09-28 00:56:01 +00:00
GList *render_passes;
vulkan: Make the GskVulkanRender struct private
2016-12-08 16:55:32 +00:00
GSList *cleanup_images;
gsk: Add a profile counter for vulkan render passes This is interesting now that we have multiple render passes.
2017-09-28 12:29:14 +00:00
GQuark render_pass_counter;
vulkan: Measure gpu time Since this value is only meaningful if we wait for the rendering to end, we only keep this timer if GSK_RENDERING_MODE=sync is enabled.
2017-09-28 14:27:58 +00:00
GQuark gpu_time_timer;
vulkan: Make the GskVulkanRender struct private
2016-12-08 16:55:32 +00:00
};
vulkan: 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
{
GdkSurface: Rename various functions and variables This is an automatic rename of various things related to the window->surface rename. Public symbols changed by this is: GDK_MODE_WINDOW gdk_device_get_window_at_position gdk_device_get_window_at_position_double gdk_device_get_last_event_window gdk_display_get_monitor_at_window gdk_drag_context_get_source_window gdk_drag_context_get_dest_window gdk_drag_context_get_drag_window gdk_draw_context_get_window gdk_drawing_context_get_window gdk_gl_context_get_window gdk_synthesize_window_state gdk_surface_get_window_type gdk_x11_display_set_window_scale gsk_renderer_new_for_window gsk_renderer_get_window gtk_text_view_buffer_to_window_coords gtk_tree_view_convert_widget_to_bin_window_coords gtk_tree_view_convert_tree_to_bin_window_coords The commands that generated this are: git sed -f g "GDK window" "GDK surface" git sed -f g window_impl surface_impl (cd gdk; git sed -f g impl_window impl_surface) git sed -f g WINDOW_IMPL SURFACE_IMPL git sed -f g GDK_MODE_WINDOW GDK_MODE_SURFACE git sed -f g gdk_draw_context_get_window gdk_draw_context_get_surface git sed -f g gdk_drawing_context_get_window gdk_drawing_context_get_surface git sed -f g gdk_gl_context_get_window gdk_gl_context_get_surface git sed -f g gsk_renderer_get_window gsk_renderer_get_surface git sed -f g gsk_renderer_new_for_window gsk_renderer_new_for_surface (cd gdk; git sed -f g window_type surface_type) git sed -f g gdk_surface_get_window_type gdk_surface_get_surface_type git sed -f g window_at_position surface_at_position git sed -f g event_window event_surface git sed -f g window_coord surface_coord git sed -f g window_state surface_state git sed -f g window_cursor surface_cursor git sed -f g window_scale surface_scale git sed -f g window_events surface_events git sed -f g monitor_at_window monitor_at_surface git sed -f g window_under_pointer surface_under_pointer (cd gdk; git sed -f g for_window for_surface) git sed -f g window_anchor surface_anchor git sed -f g WINDOW_IS_TOPLEVEL SURFACE_IS_TOPLEVEL git sed -f g native_window native_surface git sed -f g source_window source_surface git sed -f g dest_window dest_surface git sed -f g drag_window drag_surface git sed -f g input_window input_surface git checkout NEWS* po-properties po docs/reference/gtk/migrating-3to4.xml
2018-03-20 11:05:26 +00:00
GdkSurface *window = gsk_renderer_get_surface (self->renderer);
vulkan: Only render minimal region It's faster to render once for every rectangle in the clip region than rendering the outline of the clip region. Especially because this reduces the time necessary to build up the frame data. In widget-factory (where we have 3 rectangles), this leads to a 5x speedup in the rendering time rendering alone. Snapshotting time goes from 10ms to ~1ms, which is another huge improvement.
2016-12-26 23:18:52 +00:00
self->target = g_object_ref (target);
vulkan: Add GskVulkanRenderPass And move the actual rendering code there. A RenderPass is a collection of operations on the same target that get executed one after another. It roughly targets VkRenderPass or rather the subpasses of a VkRenderPass. For now, only the infrastructure is there. No real stuff is happening.
2016-12-08 12:26:36 +00:00
vulkan: Implement gsk_renderer_render_texture()
2016-12-22 18:01:07 +00:00
if (rect)
{
Small simplification Just keep the viewport as a graphene_rect_t, we don't need to use the Vulkan type here.
2017-09-30 14:42:32 +00:00
self->viewport = *rect;
vulkan: Implement gsk_renderer_render_texture()
2016-12-22 18:01:07 +00:00
self->scale_factor = 1;
}
else
{
GdkSurface: Rename various functions and variables This is an automatic rename of various things related to the window->surface rename. Public symbols changed by this is: GDK_MODE_WINDOW gdk_device_get_window_at_position gdk_device_get_window_at_position_double gdk_device_get_last_event_window gdk_display_get_monitor_at_window gdk_drag_context_get_source_window gdk_drag_context_get_dest_window gdk_drag_context_get_drag_window gdk_draw_context_get_window gdk_drawing_context_get_window gdk_gl_context_get_window gdk_synthesize_window_state gdk_surface_get_window_type gdk_x11_display_set_window_scale gsk_renderer_new_for_window gsk_renderer_get_window gtk_text_view_buffer_to_window_coords gtk_tree_view_convert_widget_to_bin_window_coords gtk_tree_view_convert_tree_to_bin_window_coords The commands that generated this are: git sed -f g "GDK window" "GDK surface" git sed -f g window_impl surface_impl (cd gdk; git sed -f g impl_window impl_surface) git sed -f g WINDOW_IMPL SURFACE_IMPL git sed -f g GDK_MODE_WINDOW GDK_MODE_SURFACE git sed -f g gdk_draw_context_get_window gdk_draw_context_get_surface git sed -f g gdk_drawing_context_get_window gdk_drawing_context_get_surface git sed -f g gdk_gl_context_get_window gdk_gl_context_get_surface git sed -f g gsk_renderer_get_window gsk_renderer_get_surface git sed -f g gsk_renderer_new_for_window gsk_renderer_new_for_surface (cd gdk; git sed -f g window_type surface_type) git sed -f g gdk_surface_get_window_type gdk_surface_get_surface_type git sed -f g window_at_position surface_at_position git sed -f g event_window event_surface git sed -f g window_coord surface_coord git sed -f g window_state surface_state git sed -f g window_cursor surface_cursor git sed -f g window_scale surface_scale git sed -f g window_events surface_events git sed -f g monitor_at_window monitor_at_surface git sed -f g window_under_pointer surface_under_pointer (cd gdk; git sed -f g for_window for_surface) git sed -f g window_anchor surface_anchor git sed -f g WINDOW_IS_TOPLEVEL SURFACE_IS_TOPLEVEL git sed -f g native_window native_surface git sed -f g source_window source_surface git sed -f g dest_window dest_surface git sed -f g drag_window drag_surface git sed -f g input_window input_surface git checkout NEWS* po-properties po docs/reference/gtk/migrating-3to4.xml
2018-03-20 11:05:26 +00:00
self->scale_factor = gdk_surface_get_scale_factor (gsk_renderer_get_surface (self->renderer));
Small simplification Just keep the viewport as a graphene_rect_t, we don't need to use the Vulkan type here.
2017-09-30 14:42:32 +00:00
self->viewport = GRAPHENE_RECT_INIT (0, 0,
GdkWindow -> GdkSurface initial type rename This renames the GdkWindow class and related classes (impl, backend subclasses) to surface. Additionally it renames related types: GdkWindowAttr, GdkWindowPaint, GdkWindowWindowClass, GdkWindowType, GdkWindowTypeHint, GdkWindowHints, GdkWindowState, GdkWindowEdge This is an automatic conversion using the below commands: git sed -f g GdkWindowWindowClass GdkSurfaceSurfaceClass git sed -f g GdkWindow GdkSurface git sed -f g "gdk_window\([ _\(\),;]\|$\)" "gdk_surface\1" # Avoid hitting gdk_windowing git sed -f g "GDK_WINDOW\([ _\(]\|$\)" "GDK_SURFACE\1" # Avoid hitting GDK_WINDOWING git sed "GDK_\([A-Z]*\)IS_WINDOW\([_ (]\|$\)" "GDK_\1IS_SURFACE\2" git sed GDK_TYPE_WINDOW GDK_TYPE_SURFACE git sed -f g GdkPointerWindowInfo GdkPointerSurfaceInfo git sed -f g "BROADWAY_WINDOW" "BROADWAY_SURFACE" git sed -f g "broadway_window" "broadway_surface" git sed -f g "BroadwayWindow" "BroadwaySurface" git sed -f g "WAYLAND_WINDOW" "WAYLAND_SURFACE" git sed -f g "wayland_window" "wayland_surface" git sed -f g "WaylandWindow" "WaylandSurface" git sed -f g "X11_WINDOW" "X11_SURFACE" git sed -f g "x11_window" "x11_surface" git sed -f g "X11Window" "X11Surface" git sed -f g "WIN32_WINDOW" "WIN32_SURFACE" git sed -f g "win32_window" "win32_surface" git sed -f g "Win32Window" "Win32Surface" git sed -f g "QUARTZ_WINDOW" "QUARTZ_SURFACE" git sed -f g "quartz_window" "quartz_surface" git sed -f g "QuartzWindow" "QuartzSurface" git checkout NEWS* po-properties
2018-03-20 10:40:08 +00:00
gdk_surface_get_width (window) * self->scale_factor,
gdk_surface_get_height (window) * self->scale_factor);
gsk: move begin/end_frame vfuncs into the renderers
2018-03-28 13:01:34 +00:00
}
if (clip)
{
vulkan: Always render clip extents Now that we have the full render nodes available, there is not much benefit in fine-grained control over multiple rectangles. In particular, it's causing pain with complex regions. There might be a benefit in clipping to the region's rectangles in cases like widget-factory where the whole diff is made up of the 2 rectangles of spinner and the pulsing progress bar, but it needs a good heuristic for where this is useful.
2018-03-31 06:17:42 +00:00
cairo_rectangle_int_t extents;
cairo_region_get_extents (clip, &extents);
self->clip = cairo_region_create_rectangle (&(cairo_rectangle_int_t) {
extents.x, extents.y,
extents.width, extents.height
});
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: 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 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,
&self->repeating_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);
}
Reshuffle things a little bit Instead of having a function with lots of arguments in GskVulkanRender that we call from GskVulkanRenderPass which then just calls back into GskVulkanRenderPass, just create the new render pass object locally, and an api to add it to the list that GskVulkanRender keeps. This makes it a lot easier to preserve all the relevant parameters from the parent render pass.
2017-09-30 15:04:16 +00:00
void
Cosmetics Factor out a helper function.
2017-09-30 14:37:55 +00:00
gsk_vulkan_render_add_render_pass (GskVulkanRender *self,
GskVulkanRenderPass *pass)
{
self->render_passes = g_list_prepend (self->render_passes, pass);
#ifdef G_ENABLE_DEBUG
gsk_profiler_counter_inc (gsk_renderer_get_profiler (self->renderer), self->render_pass_counter);
#endif
}
vulkan: Add GskVulkanRenderPass And move the actual rendering code there. A RenderPass is a collection of operations on the same target that get executed one after another. It roughly targets VkRenderPass or rather the subpasses of a VkRenderPass. For now, only the infrastructure is there. No real stuff is happening.
2016-12-08 12:26:36 +00:00
void
gsk_vulkan_render_add_node (GskVulkanRender *self,
GskRenderNode *node)
{
vulkan: Implement multiple render passes Whenever we need a node as a texture, we now start a new render pass that renders the node into a new intermediate texture, and set up a semaphore to make the current render pass wait for it. As part of this reorganization, much of the setup and drawing code moved from gskvulkanrender.c to gskvulkanrenderpass.c.
2017-09-28 00:56:01 +00:00
GskVulkanRenderPass *pass;
vulkan: 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,
Small simplification Just keep the viewport as a graphene_rect_t, we don't need to use the Vulkan type here.
2017-09-30 14:42:32 +00:00
&self->viewport,
vulkan: Implement multiple render passes Whenever we need a node as a texture, we now start a new render pass that renders the node into a new intermediate texture, and set up a semaphore to make the current render pass wait for it. As part of this reorganization, much of the setup and drawing code moved from gskvulkanrender.c to gskvulkanrenderpass.c.
2017-09-28 00:56:01 +00:00
self->clip,
VK_NULL_HANDLE);
Cosmetics Factor out a helper function.
2017-09-30 14:37:55 +00:00
gsk_vulkan_render_add_render_pass (self, pass);
gsk: Add a profile counter for vulkan render passes This is interesting now that we have multiple render passes.
2017-09-28 12:29:14 +00:00
vulkan: Implement multiple render passes Whenever we need a node as a texture, we now start a new render pass that renders the node into a new intermediate texture, and set up a semaphore to make the current render pass wait for it. As part of this reorganization, much of the setup and drawing code moved from gskvulkanrender.c to gskvulkanrenderpass.c.
2017-09-28 00:56:01 +00:00
gsk_vulkan_render_pass_add (pass, self, node);
vulkan: Add GskVulkanRenderPass And move the actual rendering code there. A RenderPass is a collection of operations on the same target that get executed one after another. It roughly targets VkRenderPass or rather the subpasses of a VkRenderPass. For now, only the infrastructure is there. No real stuff is happening.
2016-12-08 12:26:36 +00:00
}
vulkan: Implement multiple render passes Whenever we need a node as a texture, we now start a new render pass that renders the node into a new intermediate texture, and set up a semaphore to make the current render pass wait for it. As part of this reorganization, much of the setup and drawing code moved from gskvulkanrender.c to gskvulkanrenderpass.c.
2017-09-28 00:56:01 +00:00
void
gsk_vulkan_render_upload (GskVulkanRender *self)
vulkan: Add GskVulkanRenderPass And move the actual rendering code there. A RenderPass is a collection of operations on the same target that get executed one after another. It roughly targets VkRenderPass or rather the subpasses of a VkRenderPass. For now, only the infrastructure is there. No real stuff is happening.
2016-12-08 12:26:36 +00:00
{
vulkan: Implement multiple render passes Whenever we need a node as a texture, we now start a new render pass that renders the node into a new intermediate texture, and set up a semaphore to make the current render pass wait for it. As part of this reorganization, much of the setup and drawing code moved from gskvulkanrender.c to gskvulkanrenderpass.c.
2017-09-28 00:56:01 +00:00
GList *l;
vulkan: Add GskVulkanRenderPass And move the actual rendering code there. A RenderPass is a collection of operations on the same target that get executed one after another. It roughly targets VkRenderPass or rather the subpasses of a VkRenderPass. For now, only the infrastructure is there. No real stuff is happening.
2016-12-08 12:26:36 +00:00
vulkan: 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 },
Add a forgotten rename When I renamed blend to texture, I overlooked that the color text pipeline also uses this shader. Fix it.
2017-09-30 21:57:36 +00:00
{ "texture", 1, gsk_vulkan_color_text_pipeline_new },
{ "texture-clip", 1, gsk_vulkan_color_text_pipeline_new },
{ "texture-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;
vulkan: Add a repeating sampler None of the render ops use it, yet.
2017-09-30 03:01:34 +00:00
gboolean repeat;
vulkan: Move sampler creation down This is in preparation of allowing multiple samplers.
2017-09-30 02:38:59 +00:00
} HashDescriptorSetIndexEntry;
static guint
desc_set_index_hash (gconstpointer v)
{
const HashDescriptorSetIndexEntry *e = v;
vulkan: Add a repeating sampler None of the render ops use it, yet.
2017-09-30 03:01:34 +00:00
return GPOINTER_TO_UINT (e->image) + e->repeat;
vulkan: Move sampler creation down This is in preparation of allowing multiple samplers.
2017-09-30 02:38:59 +00:00
}
static gboolean
desc_set_index_equal (gconstpointer v1, gconstpointer v2)
{
const HashDescriptorSetIndexEntry *e1 = v1;
const HashDescriptorSetIndexEntry *e2 = v2;
vulkan: Add a repeating sampler None of the render ops use it, yet.
2017-09-30 03:01:34 +00:00
return e1->image == e2->image && e1->repeat == e2->repeat;
vulkan: Move sampler creation down This is in preparation of allowing multiple samplers.
2017-09-30 02:38:59 +00:00
}
vulkan: Redo descriptor set handling First, we collect all the info about descriptor sets into a hash table, then we use its size to determine the amount of sets and allocate those before we finally go ahead and use the hash table's contents to initialize the descriptor sets. And then we're ready to render.
2016-12-09 01:55:47 +00:00
gsize
gsk_vulkan_render_reserve_descriptor_set (GskVulkanRender *self,
vulkan: Add a repeating sampler None of the render ops use it, yet.
2017-09-30 03:01:34 +00:00
GskVulkanImage *source,
gboolean repeat)
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 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: Add a repeating sampler None of the render ops use it, yet.
2017-09-30 03:01:34 +00:00
lookup.repeat = repeat;
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;
vulkan: Add a repeating sampler None of the render ops use it, yet.
2017-09-30 03:01:34 +00:00
entry->repeat = repeat;
vulkan: Move sampler creation down This is in preparation of allowing multiple samplers.
2017-09-30 02:38:59 +00:00
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: Add a repeating sampler None of the render ops use it, yet.
2017-09-30 03:01:34 +00:00
gboolean repeat = entry->repeat;
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: Add a repeating sampler None of the render ops use it, yet.
2017-09-30 03:01:34 +00:00
.sampler = repeat ? self->repeating_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
gsk: Reorganize env vars Get rid of GSK_RENDERING_MODE and add the flags to GSK_DEBUG, following the same pattern we use in gdk now.
2018-01-14 20:11:33 +00:00
if (GSK_RENDERER_DEBUG_CHECK (self->renderer, SYNC))
vulkan: Measure gpu time Since this value is only meaningful if we wait for the rendering to end, we only keep this timer if GSK_RENDERING_MODE=sync is enabled.
2017-09-28 14:27:58 +00:00
gsk_profiler_timer_begin (gsk_renderer_get_profiler (self->renderer), self->gpu_time_timer);
#endif
vulkan: Move sampler creation down This is in preparation of allowing multiple samplers.
2017-09-30 02:38:59 +00:00
gsk_vulkan_render_prepare_descriptor_sets (self);
vulkan: Add GskVulkanRenderPass And move the actual rendering code there. A RenderPass is a collection of operations on the same target that get executed one after another. It roughly targets VkRenderPass or rather the subpasses of a VkRenderPass. For now, only the infrastructure is there. No real stuff is happening.
2016-12-08 12:26:36 +00:00
vulkan: Implement multiple render passes Whenever we need a node as a texture, we now start a new render pass that renders the node into a new intermediate texture, and set up a semaphore to make the current render pass wait for it. As part of this reorganization, much of the setup and drawing code moved from gskvulkanrender.c to gskvulkanrenderpass.c.
2017-09-28 00:56:01 +00:00
for (l = self->render_passes; l; l = l->next)
vulkan: Only render minimal region It's faster to render once for every rectangle in the clip region than rendering the outline of the clip region. Especially because this reduces the time necessary to build up the frame data. In widget-factory (where we have 3 rectangles), this leads to a 5x speedup in the rendering time rendering alone. Snapshotting time goes from 10ms to ~1ms, which is another huge improvement.
2016-12-26 23:18:52 +00:00
{
vulkan: 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
gsk: Reorganize env vars Get rid of GSK_RENDERING_MODE and add the flags to GSK_DEBUG, following the same pattern we use in gdk now.
2018-01-14 20:11:33 +00:00
#ifdef G_ENABLE_DEBUG
if (GSK_RENDERER_DEBUG_CHECK (self->renderer, SYNC))
vulkan: Don't wait until graphics are done computing We can let the GPU do its stuff without waiting. The GPU knows what it's doing. Which means we now get a lot of time to spend on doing CPU things (read: we're way better in benchmarks). The old behavior is safer, so we want to keep it around for debugging. It can be reenabled with GSK_RENDERING_MODE=sync.
2016-12-08 18:56:56 +00:00
{
vulkan: Measure gpu time Since this value is only meaningful if we wait for the rendering to end, we only keep this timer if GSK_RENDERING_MODE=sync is enabled.
2017-09-28 14:27:58 +00:00
GskProfiler *profiler;
gint64 gpu_time;
vulkan: Don't wait until graphics are done computing We can let the GPU do its stuff without waiting. The GPU knows what it's doing. Which means we now get a lot of time to spend on doing CPU things (read: we're way better in benchmarks). The old behavior is safer, so we want to keep it around for debugging. It can be reenabled with GSK_RENDERING_MODE=sync.
2016-12-08 18:56:56 +00:00
GSK_VK_CHECK (vkWaitForFences, gdk_vulkan_context_get_device (self->vulkan),
1,
&self->fence,
VK_TRUE,
INT64_MAX);
vulkan: Measure gpu time Since this value is only meaningful if we wait for the rendering to end, we only keep this timer if GSK_RENDERING_MODE=sync is enabled.
2017-09-28 14:27:58 +00:00
profiler = gsk_renderer_get_profiler (self->renderer);
gpu_time = gsk_profiler_timer_end (profiler, self->gpu_time_timer);
gsk_profiler_timer_set (profiler, self->gpu_time_timer, gpu_time);
vulkan: Don't wait until graphics are done computing We can let the GPU do its stuff without waiting. The GPU knows what it's doing. Which means we now get a lot of time to spend on doing CPU things (read: we're way better in benchmarks). The old behavior is safer, so we want to keep it around for debugging. It can be reenabled with GSK_RENDERING_MODE=sync.
2016-12-08 18:56:56 +00:00
}
gsk: Reorganize env vars Get rid of GSK_RENDERING_MODE and add the flags to GSK_DEBUG, following the same pattern we use in gdk now.
2018-01-14 20:11:33 +00:00
#endif
vulkan: Add GskVulkanRender object This is refactoring work. GskVulkanRender is supposed to be the global object for a render operation, ie GskVulkanRenderer.render() will create this object for what it does. The object will be split into stages that perform the operations necessary to create a drawing.
2016-12-07 13:50:52 +00:00
}
GskTexture => GdkTexture We want this thing to replace GdkPixbuf, so it has to live in GDK.
2017-11-02 20:39:00 +00:00
GdkTexture *
vulkan: Implement gsk_renderer_render_texture()
2016-12-22 18:01:07 +00:00
gsk_vulkan_render_download_target (GskVulkanRender *self)
{
gsk_vulkan_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: Add a repeating sampler None of the render ops use it, yet.
2017-09-30 03:01:34 +00:00
vkDestroySampler (device,
self->repeating_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,
gsk: move begin/end_frame vfuncs into the renderers
2018-03-28 13:01:34 +00:00
const graphene_rect_t *rect,
const cairo_region_t *clip)
vulkan: Keep render objects around That way we can reuse them. We only create a new one if the last render operation hasn't finished executing.
2016-12-08 17:40:35 +00:00
{
gsk_vulkan_render_cleanup (self);
gsk: move begin/end_frame vfuncs into the renderers
2018-03-28 13:01:34 +00:00
gsk_vulkan_render_setup (self, target, rect, clip);
vulkan: Keep render objects around That way we can reuse them. We only create a new one if the last render operation hasn't finished executing.
2016-12-08 17:40:35 +00:00
}
vulkan: Make the GskVulkanRender struct private
2016-12-08 16:55:32 +00:00
GskRenderer *
gsk_vulkan_render_get_renderer (GskVulkanRender *self)
{
return self->renderer;
}
Reference in New Issue Copy Permalink