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

1929 lines
88 KiB
C
Raw Normal View History

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 "config.h"
#include "gskvulkanrenderpassprivate.h"
gsk: Add debug category for fallbacks ... and use it for the cases in Vulkan where we fall back to Cairo.
2016-12-23 23:52:07 +00:00
#include "gskdebugprivate.h"
gsk: report fallback pixels as a profile counter This makes the value show up in the inspector without any extra work. We report the number per-frame, since that makes the most sense.
2017-09-26 01:02:21 +00:00
#include "gskprofilerprivate.h"
gsk: Add GskVulkanClip This is now tracking the clips added by the clip nodes. If any particular node can't deal with a clip, it falls back to Cairo rendering. But if it can, it will render it directly.
2016-12-23 20:36:17 +00:00
#include "gskrendernodeprivate.h"
#include "gskrenderer.h"
gsk: report fallback pixels as a profile counter This makes the value show up in the inspector without any extra work. We report the number per-frame, since that makes the most sense.
2017-09-26 01:02:21 +00:00
#include "gskrendererprivate.h"
gsk: Add GskVulkanClip This is now tracking the clips added by the clip nodes. If any particular node can't deal with a clip, it falls back to Cairo rendering. But if it can, it will render it directly.
2016-12-23 20:36:17 +00:00
#include "gskroundedrectprivate.h"
rendernode: Make the transform node take a GskTransform This is an attempt to push GskTransform deeper into the stack.
2019-03-01 05:35:55 +00:00
#include "gsktransform.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"
gsk: Add GskVulkanClip This is now tracking the clips added by the clip nodes. If any particular node can't deal with a clip, it falls back to Cairo rendering. But if it can, it will render it directly.
2016-12-23 20:36:17 +00:00
#include "gskvulkanclipprivate.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: 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 "gskvulkanimageprivate.h"
vulkan: Add infrastructure for push constants THe code includes fragment push constants for colors, but that code is so far unused.
2016-12-14 06:21:21 +00:00
#include "gskvulkanpushconstantsprivate.h"
vulkan: Implement texture caching And with this change, the GPU looks bored again.
2016-12-09 06:23:04 +00:00
#include "gskvulkanrendererprivate.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 "gskprivate.h"
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
#define ORTHO_NEAR_PLANE -10000
#define ORTHO_FAR_PLANE 10000
vulkan: Split render ops into seperate structs This makes it a lot clearer which members are relevant for each different operation.
2016-12-14 06:34:18 +00:00
typedef union _GskVulkanOp GskVulkanOp;
typedef struct _GskVulkanOpRender GskVulkanOpRender;
vulkan: Better glyph cache api Move the glyph caching api to something that can support using multiple textures. We now split the text render ops into multiple ops for different textures, and make each op render just a substring of the text node's glyph string.
2017-09-19 22:53:32 +00:00
typedef struct _GskVulkanOpText GskVulkanOpText;
vulkan: Split render ops into seperate structs This makes it a lot clearer which members are relevant for each different operation.
2016-12-14 06:34:18 +00:00
typedef struct _GskVulkanOpPushConstants GskVulkanOpPushConstants;
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
typedef enum {
vulkan: Split render ops into seperate structs This makes it a lot clearer which members are relevant for each different operation.
2016-12-14 06:34:18 +00:00
/* GskVulkanOpRender */
vulkan: Add more node operations Add SURFACE and TEXTURE operations. This way, we actually render more than one node every frame because not everything is a fallback node anymore that gets composited with its children into a cairo surface.
2016-12-09 04:59:19 +00:00
GSK_VULKAN_OP_FALLBACK,
gsk: Add GskVulkanClip This is now tracking the clips added by the clip nodes. If any particular node can't deal with a clip, it falls back to Cairo rendering. But if it can, it will render it directly.
2016-12-23 20:36:17 +00:00
GSK_VULKAN_OP_FALLBACK_CLIP,
GSK_VULKAN_OP_FALLBACK_ROUNDED_CLIP,
gsk: gsk_render_node_set_transform() => GskTransformNode Instead of having a setter for the transform, have a GskTransformNode. Most of the oprations that GTK does do not require a transform, so it doesn't make sense to have it as a primary attribute. Also, changing the transform requires updating the uniforms of the GL renderer, so we're happy if we can avoid that.
2016-12-12 23:11:06 +00:00
GSK_VULKAN_OP_TEXTURE,
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
GSK_VULKAN_OP_COLOR,
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
GSK_VULKAN_OP_LINEAR_GRADIENT,
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
GSK_VULKAN_OP_OPACITY,
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
GSK_VULKAN_OP_BLUR,
vulkan: Add support for color matrix nodes @keyframes weee { 100% { filter: hue-rotate(1turn); } } .background { animation: linear infinite 3s weee; }
2016-12-31 13:14:26 +00:00
GSK_VULKAN_OP_COLOR_MATRIX,
vulkan: Add shader for border rendering
2017-01-10 13:59:20 +00:00
GSK_VULKAN_OP_BORDER,
vulkan: Add support for unblurred box-shadow
2017-01-18 03:07:09 +00:00
GSK_VULKAN_OP_INSET_SHADOW,
GSK_VULKAN_OP_OUTSET_SHADOW,
Support repeat nodes in vulkan We can use the texture pipeline for this, with a repeating sampler.
2017-09-30 02:41:00 +00:00
GSK_VULKAN_OP_REPEAT,
Cosmetics Go back to a single GskVulkanOpRender that can handle 0, 1 or 2 sources.
2017-09-23 13:47:05 +00:00
GSK_VULKAN_OP_CROSS_FADE,
GSK_VULKAN_OP_BLEND_MODE,
vulkan: Implement crossfade This is the first shader using two textures. It almost works.
2017-09-22 18:20:57 +00:00
/* GskVulkanOpText */
GSK_VULKAN_OP_TEXT,
GSK_VULKAN_OP_COLOR_TEXT,
vulkan: Split render ops into seperate structs This makes it a lot clearer which members are relevant for each different operation.
2016-12-14 06:34:18 +00:00
/* GskVulkanOpPushConstants */
vulkan: Implement crossfade This is the first shader using two textures. It almost works.
2017-09-22 18:20:57 +00:00
GSK_VULKAN_OP_PUSH_VERTEX_CONSTANTS,
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
} GskVulkanOpType;
Cosmetics Go back to a single GskVulkanOpRender that can handle 0, 1 or 2 sources.
2017-09-23 13:47:05 +00:00
/* render ops with 0, 1 or 2 sources */
vulkan: Split render ops into seperate structs This makes it a lot clearer which members are relevant for each different operation.
2016-12-14 06:34:18 +00:00
struct _GskVulkanOpRender
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
{
GskVulkanOpType type;
GskRenderNode *node; /* node that's the source of this op */
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 *pipeline; /* pipeline to use */
gsk: Add GskVulkanClip This is now tracking the clips added by the clip nodes. If any particular node can't deal with a clip, it falls back to Cairo rendering. But if it can, it will render it directly.
2016-12-23 20:36:17 +00:00
GskRoundedRect clip; /* clip rect (or random memory if not relevant) */
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
GskVulkanImage *source; /* source image to render */
Cosmetics Go back to a single GskVulkanOpRender that can handle 0, 1 or 2 sources.
2017-09-23 13:47:05 +00:00
GskVulkanImage *source2; /* second source image to render (if relevant) */
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
gsize vertex_offset; /* offset into vertex buffer */
gsize vertex_count; /* number of vertices */
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 descriptor_set_index; /* index into descriptor sets array for the right descriptor set to bind */
Cosmetics Go back to a single GskVulkanOpRender that can handle 0, 1 or 2 sources.
2017-09-23 13:47:05 +00:00
gsize descriptor_set_index2; /* descriptor index for the second source (if relevant) */
Clip intermediate textures In some cases, we were creating gigantic intermediate textures only to clip out a small section afterwards (e.g. in the listbox example in gtk4-demo). This is wasteful if we apply effects on the texture, such as blur or color-matrix. So, clip the dimensions of the intermediate texture with the current clip. To make this feasible, we move the texture coordinate computation out of the pipeline setup functions into the node_as_texture function where this clipping happens. One extra complication we encounter is that the node might get clipped away completely. Since Vulkan does not allow to create empty images, we bail out in this case and not draw anything. With these changes, the listbox example in gtk4-demo goes from 32M pixels of intermediate texture to 320000.
2017-10-01 23:17:39 +00:00
graphene_rect_t source_rect; /* area that source maps to */
graphene_rect_t source2_rect; /* area that source2 maps to */
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: Better glyph cache api Move the glyph caching api to something that can support using multiple textures. We now split the text render ops into multiple ops for different textures, and make each op render just a substring of the text node's glyph string.
2017-09-19 22:53:32 +00:00
struct _GskVulkanOpText
{
GskVulkanOpType type;
GskRenderNode *node; /* node that's the source of this op */
GskVulkanPipeline *pipeline; /* pipeline to use */
GskRoundedRect clip; /* clip rect (or random memory if not relevant) */
GskVulkanImage *source; /* source image to render */
gsize vertex_offset; /* offset into vertex buffer */
gsize vertex_count; /* number of vertices */
gsize descriptor_set_index; /* index into descriptor sets array for the right descriptor set to bind */
Make the glyph cache grow as needed Make it possible to have more than one texture in the glyph cache, and create new ones when we run out of space in the existing ones.
2017-09-20 03:32:07 +00:00
guint texture_index; /* index of the texture in the glyph cache */
guint start_glyph; /* the first glyph in nodes glyphstring that we render */
guint num_glyphs; /* number of *non-empty* glyphs (== instances) we render */
gsk: Scale glyphs in the glyph cache Pass a scale factor when caching glyphs or looking them up in the cache. The glyphs in the cache are rendered with subpixel precision determined by the scale. Update all callers to pass a scale factor according to the window scale. This lets us render crisp glyphs on hidpi systems.
2017-10-28 17:13:31 +00:00
float scale;
vulkan: Better glyph cache api Move the glyph caching api to something that can support using multiple textures. We now split the text render ops into multiple ops for different textures, and make each op render just a substring of the text node's glyph string.
2017-09-19 22:53:32 +00:00
};
vulkan: Split render ops into seperate structs This makes it a lot clearer which members are relevant for each different operation.
2016-12-14 06:34:18 +00:00
struct _GskVulkanOpPushConstants
{
GskVulkanOpType type;
GskRenderNode *node; /* node that's the source of this op */
GskVulkanPushConstants constants; /* new constants to push */
};
union _GskVulkanOp
{
GskVulkanOpType type;
GskVulkanOpRender render;
vulkan: Better glyph cache api Move the glyph caching api to something that can support using multiple textures. We now split the text render ops into multiple ops for different textures, and make each op render just a substring of the text node's glyph string.
2017-09-19 22:53:32 +00:00
GskVulkanOpText text;
vulkan: Implement crossfade This is the first shader using two textures. It almost works.
2017-09-22 18:20:57 +00:00
GskVulkanOpPushConstants constants;
vulkan: Split render ops into seperate structs This makes it a lot clearer which members are relevant for each different operation.
2016-12-14 06:34:18 +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
struct _GskVulkanRenderPass
{
GdkVulkanContext *vulkan;
GArray *render_ops;
gsk: count fallback pixels Always helps to have some measure of progress.
2017-09-25 13:25:29 +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
GskVulkanImage *target;
int scale_factor;
graphene_rect_t viewport;
cairo_region_t *clip;
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_t p;
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
VkRenderPass render_pass;
VkSemaphore signal_semaphore;
GArray *wait_semaphores;
GskVulkanBuffer *vertex_data;
gsk: report fallback pixels as a profile counter This makes the value show up in the inspector without any extra work. We report the number per-frame, since that makes the most sense.
2017-09-26 01:02:21 +00:00
GQuark fallback_pixels;
vulkan: Add a counter for intermediate textures Count how many pixels of intermediate textures we create. If we can count it, we can optimize it.
2017-09-30 14:39:04 +00:00
GQuark texture_pixels;
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
};
GskVulkanRenderPass *
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_new (GdkVulkanContext *context,
GskVulkanImage *target,
int 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
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
graphene_rect_t *viewport,
cairo_region_t *clip,
VkSemaphore signal_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
{
GskVulkanRenderPass *self;
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
VkImageLayout final_layout;
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 = g_slice_new0 (GskVulkanRenderPass);
self->vulkan = g_object_ref (context);
vulkan: Split render ops into seperate structs This makes it a lot clearer which members are relevant for each different operation.
2016-12-14 06:34:18 +00:00
self->render_ops = g_array_new (FALSE, FALSE, sizeof (GskVulkanOp));
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->target = g_object_ref (target);
self->scale_factor = scale_factor;
self->clip = cairo_region_copy (clip);
vulkan: Fix setup for dependent render passes We were not correctly preserving the modelview transform.
2017-09-29 19:45:37 +00:00
self->viewport = *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
vulkan: Fix setup for dependent render passes We were not correctly preserving the modelview transform.
2017-09-29 19:45:37 +00:00
self->mv = *mv;
graphene_matrix_init_ortho (&self->p,
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
viewport->origin.x, viewport->origin.x + viewport->size.width,
viewport->origin.y, viewport->origin.y + viewport->size.height,
ORTHO_NEAR_PLANE,
ORTHO_FAR_PLANE);
if (signal_semaphore != VK_NULL_HANDLE) // this is a dependent pass
final_layout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
else
final_layout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
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,
.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR,
.storeOp = VK_ATTACHMENT_STORE_OP_STORE,
vulkan/renderpass: Use GENERAL for initial layout UNDEFINED initial layouts may not preserve the contents of the attachment after transitioning the layout. We want them to be preserved because we do partial rendering. Use GENERAL as the initial layout for render passes.
2019-10-04 20:55:25 +00:00
.initialLayout = VK_IMAGE_LAYOUT_GENERAL,
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
.finalLayout = final_layout
}
},
.subpassCount = 1,
.pSubpasses = (VkSubpassDescription []) {
{
.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS,
.inputAttachmentCount = 0,
.colorAttachmentCount = 1,
.pColorAttachments = (VkAttachmentReference []) {
{
.attachment = 0,
.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL
}
},
.pResolveAttachments = (VkAttachmentReference []) {
{
.attachment = VK_ATTACHMENT_UNUSED,
.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL
}
},
.pDepthStencilAttachment = NULL,
}
},
.dependencyCount = 0
},
NULL,
&self->render_pass);
self->signal_semaphore = signal_semaphore;
self->wait_semaphores = g_array_new (FALSE, FALSE, sizeof (VkSemaphore));
self->vertex_data = NULL;
gsk: report fallback pixels as a profile counter This makes the value show up in the inspector without any extra work. We report the number per-frame, since that makes the most sense.
2017-09-26 01:02:21 +00:00
#ifdef G_ENABLE_DEBUG
self->fallback_pixels = g_quark_from_static_string ("fallback-pixels");
vulkan: Add a counter for intermediate textures Count how many pixels of intermediate textures we create. If we can count it, we can optimize it.
2017-09-30 14:39:04 +00:00
self->texture_pixels = g_quark_from_static_string ("texture-pixels");
gsk: report fallback pixels as a profile counter This makes the value show up in the inspector without any extra work. We report the number per-frame, since that makes the most sense.
2017-09-26 01:02:21 +00:00
#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
return self;
}
void
gsk_vulkan_render_pass_free (GskVulkanRenderPass *self)
{
g_array_unref (self->render_ops);
g_object_unref (self->vulkan);
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_object_unref (self->target);
cairo_region_destroy (self->clip);
vkDestroyRenderPass (gdk_vulkan_context_get_device (self->vulkan),
self->render_pass,
NULL);
if (self->vertex_data)
gsk_vulkan_buffer_free (self->vertex_data);
if (self->signal_semaphore != VK_NULL_HANDLE)
vkDestroySemaphore (gdk_vulkan_context_get_device (self->vulkan),
self->signal_semaphore,
NULL);
g_array_unref (self->wait_semaphores);
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
g_slice_free (GskVulkanRenderPass, self);
}
gsk: Add debug category for fallbacks ... and use it for the cases in Vulkan where we fall back to Cairo.
2016-12-23 23:52:07 +00:00
#define FALLBACK(...) G_STMT_START { \
gsk: make logging per-renderer Add a setter for per-renderer debug flags, and use them where possible. Some places don't have easy access to a renderer, so this is not complete. Also, use g_message instead of g_print throughout.
2018-01-14 14:52:52 +00:00
GSK_RENDERER_NOTE (gsk_vulkan_render_get_renderer (render), FALLBACK, g_message (__VA_ARGS__)); \
gsk: Add debug category for fallbacks ... and use it for the cases in Vulkan where we fall back to Cairo.
2016-12-23 23:52:07 +00:00
goto fallback; \
}G_STMT_END
gsk: Mark internal symbol as static Nothing uses this function outside of GskVulkaneRenderPass.
2017-04-26 16:27:24 +00:00
static void
vulkan: Add infrastructure for push constants THe code includes fragment push constants for colors, but that code is so far unused.
2016-12-14 06:21:21 +00:00
gsk_vulkan_render_pass_add_node (GskVulkanRenderPass *self,
GskVulkanRender *render,
const GskVulkanPushConstants *constants,
GskRenderNode *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: Split render ops into seperate structs This makes it a lot clearer which members are relevant for each different operation.
2016-12-14 06:34:18 +00:00
GskVulkanOp op = {
.render.node = 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: Add proof-of-concept clip implementation We can now clip to cicular rounded rectangles when drawing colors.
2016-12-24 05:16:54 +00:00
GskVulkanPipelineType pipeline_type;
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: Remove gsk_render_node_is_surface/texture() Use gsk_render_node_get_node_type() instead.
2016-12-11 01:33:58 +00:00
switch (gsk_render_node_get_node_type (node))
vulkan: Add more node operations Add SURFACE and TEXTURE operations. This way, we actually render more than one node every frame because not everything is a fallback node anymore that gets composited with its children into a cairo surface.
2016-12-09 04:59:19 +00:00
{
gsk: Remove gsk_render_node_is_surface/texture() Use gsk_render_node_get_node_type() instead.
2016-12-11 01:33:58 +00:00
case GSK_NOT_A_RENDER_NODE:
g_assert_not_reached ();
gsk: Add GskVulkanClip This is now tracking the clips added by the clip nodes. If any particular node can't deal with a clip, it falls back to Cairo rendering. But if it can, it will render it directly.
2016-12-23 20:36:17 +00:00
return;
Support GLShaderNode in backends For vulkan/broadway this just means to ignore it, but for the gl backend we support (with up to 4 texture inputs, which is similar to what shadertoy does, so should be widely supported).
2020-09-18 16:03:30 +00:00
case GSK_GL_SHADER_NODE:
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
case GSK_SHADOW_NODE:
gsk: Add a radial gradient node Only a fallback implementation for now. Fixes #2262
2020-09-12 02:55:37 +00:00
case GSK_RADIAL_GRADIENT_NODE:
case GSK_REPEATING_RADIAL_GRADIENT_NODE:
gsk: Add GskConicGradientNode
2020-12-02 23:47:54 +00:00
case GSK_CONIC_GRADIENT_NODE:
gsk: Add fallback code to renderers This code makes renderers fall back to Cairo rendering if they don't know how to handle a render node's type. This allows adding new render nodes with impunity.
2016-12-13 03:20:04 +00:00
default:
Turn GskRenderNode into a derivable type Language bindings—especially ones based on introspection—cannot deal with custom type hiearchies. Luckily for us, GType has a derivable type with low overhead: GTypeInstance. By turning GskRenderNode into a GTypeInstance, and creating derived types for each class of node, we can provide an introspectable API to our non-C API consumers, with no functional change to the C API itself.
2020-04-07 22:33:54 +00:00
FALLBACK ("Unsupported node '%s'", g_type_name_from_instance ((GTypeInstance *) node));
gsk: Add fallback code to renderers This code makes renderers fall back to Cairo rendering if they don't know how to handle a render node's type. This allows adding new render nodes with impunity.
2016-12-13 03:20:04 +00:00
Support repeat nodes in vulkan We can use the texture pipeline for this, with a repeating sampler.
2017-09-30 02:41:00 +00:00
case GSK_REPEAT_NODE:
if (gsk_vulkan_clip_contains_rect (&constants->clip, &node->bounds))
pipeline_type = GSK_VULKAN_PIPELINE_TEXTURE;
else if (constants->clip.type == GSK_VULKAN_CLIP_RECT)
pipeline_type = GSK_VULKAN_PIPELINE_TEXTURE_CLIP;
else if (constants->clip.type == GSK_VULKAN_CLIP_ROUNDED_CIRCULAR)
pipeline_type = GSK_VULKAN_PIPELINE_TEXTURE_CLIP_ROUNDED;
else
gsk: make logging per-renderer Add a setter for per-renderer debug flags, and use them where possible. Some places don't have easy access to a renderer, so this is not complete. Also, use g_message instead of g_print throughout.
2018-01-14 14:52:52 +00:00
FALLBACK ("Repeat nodes can't deal with clip type %u", constants->clip.type);
Support repeat nodes in vulkan We can use the texture pipeline for this, with a repeating sampler.
2017-09-30 02:41:00 +00:00
op.type = GSK_VULKAN_OP_REPEAT;
op.render.pipeline = gsk_vulkan_render_get_pipeline (render, pipeline_type);
g_array_append_val (self->render_ops, op);
return;
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
case GSK_BLEND_NODE:
if (gsk_vulkan_clip_contains_rect (&constants->clip, &node->bounds))
pipeline_type = GSK_VULKAN_PIPELINE_BLEND_MODE;
else if (constants->clip.type == GSK_VULKAN_CLIP_RECT)
pipeline_type = GSK_VULKAN_PIPELINE_BLEND_MODE_CLIP;
else if (constants->clip.type == GSK_VULKAN_CLIP_ROUNDED_CIRCULAR)
pipeline_type = GSK_VULKAN_PIPELINE_BLEND_MODE_CLIP_ROUNDED;
else
gsk: make logging per-renderer Add a setter for per-renderer debug flags, and use them where possible. Some places don't have easy access to a renderer, so this is not complete. Also, use g_message instead of g_print throughout.
2018-01-14 14:52:52 +00:00
FALLBACK ("Blend nodes can't deal with clip type %u", constants->clip.type);
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
op.type = GSK_VULKAN_OP_BLEND_MODE;
op.render.pipeline = gsk_vulkan_render_get_pipeline (render, pipeline_type);
g_array_append_val (self->render_ops, op);
return;
vulkan: Implement crossfade This is the first shader using two textures. It almost works.
2017-09-22 18:20:57 +00:00
case GSK_CROSS_FADE_NODE:
if (gsk_vulkan_clip_contains_rect (&constants->clip, &node->bounds))
pipeline_type = GSK_VULKAN_PIPELINE_CROSS_FADE;
else if (constants->clip.type == GSK_VULKAN_CLIP_RECT)
pipeline_type = GSK_VULKAN_PIPELINE_CROSS_FADE_CLIP;
else if (constants->clip.type == GSK_VULKAN_CLIP_ROUNDED_CIRCULAR)
pipeline_type = GSK_VULKAN_PIPELINE_CROSS_FADE_CLIP_ROUNDED;
else
gsk: make logging per-renderer Add a setter for per-renderer debug flags, and use them where possible. Some places don't have easy access to a renderer, so this is not complete. Also, use g_message instead of g_print throughout.
2018-01-14 14:52:52 +00:00
FALLBACK ("Cross fade nodes can't deal with clip type %u", constants->clip.type);
vulkan: Implement crossfade This is the first shader using two textures. It almost works.
2017-09-22 18:20:57 +00:00
op.type = GSK_VULKAN_OP_CROSS_FADE;
op.render.pipeline = gsk_vulkan_render_get_pipeline (render, pipeline_type);
g_array_append_val (self->render_ops, op);
return;
vulkan: Add support for unblurred box-shadow
2017-01-18 03:07:09 +00:00
case GSK_INSET_SHADOW_NODE:
if (gsk_inset_shadow_node_get_blur_radius (node) > 0)
gsk: make logging per-renderer Add a setter for per-renderer debug flags, and use them where possible. Some places don't have easy access to a renderer, so this is not complete. Also, use g_message instead of g_print throughout.
2018-01-14 14:52:52 +00:00
FALLBACK ("Blur support not implemented for inset shadows");
vulkan: Add support for unblurred box-shadow
2017-01-18 03:07:09 +00:00
else if (gsk_vulkan_clip_contains_rect (&constants->clip, &node->bounds))
pipeline_type = GSK_VULKAN_PIPELINE_INSET_SHADOW;
else if (constants->clip.type == GSK_VULKAN_CLIP_RECT)
pipeline_type = GSK_VULKAN_PIPELINE_INSET_SHADOW_CLIP;
else if (constants->clip.type == GSK_VULKAN_CLIP_ROUNDED_CIRCULAR)
pipeline_type = GSK_VULKAN_PIPELINE_INSET_SHADOW_CLIP_ROUNDED;
else
gsk: make logging per-renderer Add a setter for per-renderer debug flags, and use them where possible. Some places don't have easy access to a renderer, so this is not complete. Also, use g_message instead of g_print throughout.
2018-01-14 14:52:52 +00:00
FALLBACK ("Inset shadow nodes can't deal with clip type %u", constants->clip.type);
vulkan: Add support for unblurred box-shadow
2017-01-18 03:07:09 +00:00
op.type = GSK_VULKAN_OP_INSET_SHADOW;
op.render.pipeline = gsk_vulkan_render_get_pipeline (render, pipeline_type);
g_array_append_val (self->render_ops, op);
return;
case GSK_OUTSET_SHADOW_NODE:
if (gsk_outset_shadow_node_get_blur_radius (node) > 0)
gsk: make logging per-renderer Add a setter for per-renderer debug flags, and use them where possible. Some places don't have easy access to a renderer, so this is not complete. Also, use g_message instead of g_print throughout.
2018-01-14 14:52:52 +00:00
FALLBACK ("Blur support not implemented for outset shadows");
vulkan: Add support for unblurred box-shadow
2017-01-18 03:07:09 +00:00
else if (gsk_vulkan_clip_contains_rect (&constants->clip, &node->bounds))
pipeline_type = GSK_VULKAN_PIPELINE_OUTSET_SHADOW;
else if (constants->clip.type == GSK_VULKAN_CLIP_RECT)
pipeline_type = GSK_VULKAN_PIPELINE_OUTSET_SHADOW_CLIP;
else if (constants->clip.type == GSK_VULKAN_CLIP_ROUNDED_CIRCULAR)
pipeline_type = GSK_VULKAN_PIPELINE_OUTSET_SHADOW_CLIP_ROUNDED;
else
gsk: make logging per-renderer Add a setter for per-renderer debug flags, and use them where possible. Some places don't have easy access to a renderer, so this is not complete. Also, use g_message instead of g_print throughout.
2018-01-14 14:52:52 +00:00
FALLBACK ("Outset shadow nodes can't deal with clip type %u", constants->clip.type);
vulkan: Add support for unblurred box-shadow
2017-01-18 03:07:09 +00:00
op.type = GSK_VULKAN_OP_OUTSET_SHADOW;
op.render.pipeline = gsk_vulkan_render_get_pipeline (render, pipeline_type);
g_array_append_val (self->render_ops, op);
return;
gsk: Remove gsk_render_node_is_surface/texture() Use gsk_render_node_get_node_type() instead.
2016-12-11 01:33:58 +00:00
case GSK_CAIRO_NODE:
rendernode: Rename all gsk_render_node_peek_*() functions Those are getters, they should be gsk_render_node_get_*() functions.
2020-11-16 23:59:36 +00:00
if (gsk_cairo_node_get_surface (node) == NULL)
gsk: Add GskVulkanClip This is now tracking the clips added by the clip nodes. If any particular node can't deal with a clip, it falls back to Cairo rendering. But if it can, it will render it directly.
2016-12-23 20:36:17 +00:00
return;
vulkan: Remove special case for Cairo surfaces This is in preparation for the next commits which switch Cairo nodes to recording surfaces.
2018-03-24 15:41:59 +00:00
/* We're using recording surfaces, so drawing them to an image
* surface and uploading them is the right thing.
* But that's exactly what the fallback code does.
*/
goto fallback;
gsk: Remove gsk_render_node_is_surface/texture() Use gsk_render_node_get_node_type() instead.
2016-12-11 01:33:58 +00:00
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
case GSK_TEXT_NODE:
vulkan: Better glyph cache api Move the glyph caching api to something that can support using multiple textures. We now split the text render ops into multiple ops for different textures, and make each op render just a substring of the text node's glyph string.
2017-09-19 22:53:32 +00:00
{
rendernode: Rename all gsk_render_node_peek_*() functions Those are getters, they should be gsk_render_node_get_*() functions.
2020-11-16 23:59:36 +00:00
const PangoFont *font = gsk_text_node_get_font (node);
const PangoGlyphInfo *glyphs = gsk_text_node_get_glyphs (node, NULL);
gsk: Make text nodes more compact The copy of the PangoGlyphString we do here was showing up in some profiles. To avoid it, allocate the PangoGlyphInfo array as part of the node itself. Update all callers to deal with the slight api change required for this.
2017-10-27 21:13:40 +00:00
guint num_glyphs = gsk_text_node_get_num_glyphs (node);
gsk: Store color bit info in text nodes Keep the 'has color glyphs' info in text nodes, instead of determining it over and over in both the vulkan and gl backends.
2019-10-10 11:31:08 +00:00
gboolean has_color_glyphs = gsk_text_node_has_color_glyphs (node);
vulkan: Better glyph cache api Move the glyph caching api to something that can support using multiple textures. We now split the text render ops into multiple ops for different textures, and make each op render just a substring of the text node's glyph string.
2017-09-19 22:53:32 +00:00
int i;
Make the glyph cache grow as needed Make it possible to have more than one texture in the glyph cache, and create new ones when we run out of space in the existing ones.
2017-09-20 03:32:07 +00:00
guint count;
vulkan: Better glyph cache api Move the glyph caching api to something that can support using multiple textures. We now split the text render ops into multiple ops for different textures, and make each op render just a substring of the text node's glyph string.
2017-09-19 22:53:32 +00:00
guint texture_index;
Replace "gint" with "int"
2020-07-24 13:54:49 +00:00
int x_position;
vulkan: Better glyph cache api Move the glyph caching api to something that can support using multiple textures. We now split the text render ops into multiple ops for different textures, and make each op render just a substring of the text node's glyph string.
2017-09-19 22:53:32 +00:00
GskVulkanRenderer *renderer = GSK_VULKAN_RENDERER (gsk_vulkan_render_get_renderer (render));
gsk: Store color bit info in text nodes Keep the 'has color glyphs' info in text nodes, instead of determining it over and over in both the vulkan and gl backends.
2019-10-10 11:31:08 +00:00
if (has_color_glyphs)
vulkan: Better glyph cache api Move the glyph caching api to something that can support using multiple textures. We now split the text render ops into multiple ops for different textures, and make each op render just a substring of the text node's glyph string.
2017-09-19 22:53:32 +00:00
{
if (gsk_vulkan_clip_contains_rect (&constants->clip, &node->bounds))
pipeline_type = GSK_VULKAN_PIPELINE_COLOR_TEXT;
else if (constants->clip.type == GSK_VULKAN_CLIP_RECT)
pipeline_type = GSK_VULKAN_PIPELINE_COLOR_TEXT_CLIP;
else if (constants->clip.type == GSK_VULKAN_CLIP_ROUNDED_CIRCULAR)
pipeline_type = GSK_VULKAN_PIPELINE_COLOR_TEXT_CLIP_ROUNDED;
else
gsk: make logging per-renderer Add a setter for per-renderer debug flags, and use them where possible. Some places don't have easy access to a renderer, so this is not complete. Also, use g_message instead of g_print throughout.
2018-01-14 14:52:52 +00:00
FALLBACK ("Text nodes can't deal with clip type %u", constants->clip.type);
vulkan: Better glyph cache api Move the glyph caching api to something that can support using multiple textures. We now split the text render ops into multiple ops for different textures, and make each op render just a substring of the text node's glyph string.
2017-09-19 22:53:32 +00:00
op.type = GSK_VULKAN_OP_COLOR_TEXT;
}
else
{
if (gsk_vulkan_clip_contains_rect (&constants->clip, &node->bounds))
pipeline_type = GSK_VULKAN_PIPELINE_TEXT;
else if (constants->clip.type == GSK_VULKAN_CLIP_RECT)
pipeline_type = GSK_VULKAN_PIPELINE_TEXT_CLIP;
else if (constants->clip.type == GSK_VULKAN_CLIP_ROUNDED_CIRCULAR)
pipeline_type = GSK_VULKAN_PIPELINE_TEXT_CLIP_ROUNDED;
else
gsk: make logging per-renderer Add a setter for per-renderer debug flags, and use them where possible. Some places don't have easy access to a renderer, so this is not complete. Also, use g_message instead of g_print throughout.
2018-01-14 14:52:52 +00:00
FALLBACK ("Text nodes can't deal with clip type %u", constants->clip.type);
vulkan: Better glyph cache api Move the glyph caching api to something that can support using multiple textures. We now split the text render ops into multiple ops for different textures, and make each op render just a substring of the text node's glyph string.
2017-09-19 22:53:32 +00:00
op.type = GSK_VULKAN_OP_TEXT;
}
op.text.pipeline = gsk_vulkan_render_get_pipeline (render, pipeline_type);
vulkan: Add a primitive glyph cache This is just a proof of concept - we use a single 1024x1024 surface, and just give up when we run out of space. The cache is populated incrementally, and items are never removed.
2017-09-11 01:55:22 +00:00
Make the glyph cache grow as needed Make it possible to have more than one texture in the glyph cache, and create new ones when we run out of space in the existing ones.
2017-09-20 03:32:07 +00:00
op.text.start_glyph = 0;
op.text.texture_index = G_MAXUINT;
Triival cleanup No need to go to the window, we store a copy of the scale factor in the render pass object.
2017-10-28 18:38:21 +00:00
op.text.scale = self->scale_factor;
Make the glyph cache grow as needed Make it possible to have more than one texture in the glyph cache, and create new ones when we run out of space in the existing ones.
2017-09-20 03:32:07 +00:00
vulkan: implement subpixel positioning Pass the glyph position into the glyph caching functions, not just the glyph index. This allows us to cache different images for different subpixel positions.
2019-07-25 21:50:31 +00:00
x_position = 0;
gsk: Make text nodes more compact The copy of the PangoGlyphString we do here was showing up in some profiles. To avoid it, allocate the PangoGlyphInfo array as part of the node itself. Update all callers to deal with the slight api change required for this.
2017-10-27 21:13:40 +00:00
for (i = 0, count = 0; i < num_glyphs; i++)
vulkan: Better glyph cache api Move the glyph caching api to something that can support using multiple textures. We now split the text render ops into multiple ops for different textures, and make each op render just a substring of the text node's glyph string.
2017-09-19 22:53:32 +00:00
{
gsk: Make text nodes more compact The copy of the PangoGlyphString we do here was showing up in some profiles. To avoid it, allocate the PangoGlyphInfo array as part of the node itself. Update all callers to deal with the slight api change required for this.
2017-10-27 21:13:40 +00:00
const PangoGlyphInfo *gi = &glyphs[i];
Make the glyph cache grow as needed Make it possible to have more than one texture in the glyph cache, and create new ones when we run out of space in the existing ones.
2017-09-20 03:32:07 +00:00
vulkan: implement subpixel positioning Pass the glyph position into the glyph caching functions, not just the glyph index. This allows us to cache different images for different subpixel positions.
2019-07-25 21:50:31 +00:00
texture_index = gsk_vulkan_renderer_cache_glyph (renderer,
(PangoFont *)font,
gi->glyph,
x_position + gi->geometry.x_offset,
gi->geometry.y_offset,
op.text.scale);
gsk: Fix hexbox drawing for the Vulkan renderer Just as in the cairo renderer, we can get this back by using pango_cairo_show_glyph_string for populating the cache.
2018-01-06 01:30:14 +00:00
if (op.text.texture_index == G_MAXUINT)
op.text.texture_index = texture_index;
if (texture_index != op.text.texture_index)
Make the glyph cache grow as needed Make it possible to have more than one texture in the glyph cache, and create new ones when we run out of space in the existing ones.
2017-09-20 03:32:07 +00:00
{
gsk: Fix hexbox drawing for the Vulkan renderer Just as in the cairo renderer, we can get this back by using pango_cairo_show_glyph_string for populating the cache.
2018-01-06 01:30:14 +00:00
op.text.num_glyphs = count;
g_array_append_val (self->render_ops, op);
count = 1;
op.text.start_glyph = i;
op.text.texture_index = texture_index;
Make the glyph cache grow as needed Make it possible to have more than one texture in the glyph cache, and create new ones when we run out of space in the existing ones.
2017-09-20 03:32:07 +00:00
}
gsk: Fix hexbox drawing for the Vulkan renderer Just as in the cairo renderer, we can get this back by using pango_cairo_show_glyph_string for populating the cache.
2018-01-06 01:30:14 +00:00
else
count++;
vulkan: implement subpixel positioning Pass the glyph position into the glyph caching functions, not just the glyph index. This allows us to cache different images for different subpixel positions.
2019-07-25 21:50:31 +00:00
x_position += gi->geometry.width;
Make the glyph cache grow as needed Make it possible to have more than one texture in the glyph cache, and create new ones when we run out of space in the existing ones.
2017-09-20 03:32:07 +00:00
}
vulkan: Better glyph cache api Move the glyph caching api to something that can support using multiple textures. We now split the text render ops into multiple ops for different textures, and make each op render just a substring of the text node's glyph string.
2017-09-19 22:53:32 +00:00
Make the glyph cache grow as needed Make it possible to have more than one texture in the glyph cache, and create new ones when we run out of space in the existing ones.
2017-09-20 03:32:07 +00:00
if (op.text.texture_index != G_MAXUINT && count != 0)
{
op.text.num_glyphs = count;
vulkan: Better glyph cache api Move the glyph caching api to something that can support using multiple textures. We now split the text render ops into multiple ops for different textures, and make each op render just a substring of the text node's glyph string.
2017-09-19 22:53:32 +00:00
g_array_append_val (self->render_ops, op);
}
Make the glyph cache grow as needed Make it possible to have more than one texture in the glyph cache, and create new ones when we run out of space in the existing ones.
2017-09-20 03:32:07 +00:00
vulkan: Better glyph cache api Move the glyph caching api to something that can support using multiple textures. We now split the text render ops into multiple ops for different textures, and make each op render just a substring of the text node's glyph string.
2017-09-19 22:53:32 +00:00
return;
}
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
Partially revert GskTexture → GdkTexture rename Excessive use of sed when moving GskTexture to GDK; the GskTextureNode should still live under the GSK namespace.
2017-11-04 15:03:03 +00:00
case GSK_TEXTURE_NODE:
vulkan: Modernize blend pipeline - Rename from blit => blend - Use instances - Add clip versions
2017-01-01 22:47:53 +00:00
if (gsk_vulkan_clip_contains_rect (&constants->clip, &node->bounds))
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
pipeline_type = GSK_VULKAN_PIPELINE_TEXTURE;
vulkan: Modernize blend pipeline - Rename from blit => blend - Use instances - Add clip versions
2017-01-01 22:47:53 +00:00
else if (constants->clip.type == GSK_VULKAN_CLIP_RECT)
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
pipeline_type = GSK_VULKAN_PIPELINE_TEXTURE_CLIP;
vulkan: Modernize blend pipeline - Rename from blit => blend - Use instances - Add clip versions
2017-01-01 22:47:53 +00:00
else if (constants->clip.type == GSK_VULKAN_CLIP_ROUNDED_CIRCULAR)
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
pipeline_type = GSK_VULKAN_PIPELINE_TEXTURE_CLIP_ROUNDED;
vulkan: Modernize blend pipeline - Rename from blit => blend - Use instances - Add clip versions
2017-01-01 22:47:53 +00:00
else
gsk: make logging per-renderer Add a setter for per-renderer debug flags, and use them where possible. Some places don't have easy access to a renderer, so this is not complete. Also, use g_message instead of g_print throughout.
2018-01-14 14:52:52 +00:00
FALLBACK ("Texture nodes can't deal with clip type %u", constants->clip.type);
vulkan: Add more node operations Add SURFACE and TEXTURE operations. This way, we actually render more than one node every frame because not everything is a fallback node anymore that gets composited with its children into a cairo surface.
2016-12-09 04:59:19 +00:00
op.type = GSK_VULKAN_OP_TEXTURE;
vulkan: Modernize blend pipeline - Rename from blit => blend - Use instances - Add clip versions
2017-01-01 22:47:53 +00:00
op.render.pipeline = gsk_vulkan_render_get_pipeline (render, pipeline_type);
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_array_append_val (self->render_ops, op);
gsk: Add GskVulkanClip This is now tracking the clips added by the clip nodes. If any particular node can't deal with a clip, it falls back to Cairo rendering. But if it can, it will render it directly.
2016-12-23 20:36:17 +00:00
return;
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
case GSK_COLOR_NODE:
vulkan: Add proof-of-concept clip implementation We can now clip to cicular rounded rectangles when drawing colors.
2016-12-24 05:16:54 +00:00
if (gsk_vulkan_clip_contains_rect (&constants->clip, &node->bounds))
pipeline_type = GSK_VULKAN_PIPELINE_COLOR;
vulkan: Add shader for color drawing with rectangle clip
2016-12-25 05:01:54 +00:00
else if (constants->clip.type == GSK_VULKAN_CLIP_RECT)
pipeline_type = GSK_VULKAN_PIPELINE_COLOR_CLIP;
vulkan: Add proof-of-concept clip implementation We can now clip to cicular rounded rectangles when drawing colors.
2016-12-24 05:16:54 +00:00
else if (constants->clip.type == GSK_VULKAN_CLIP_ROUNDED_CIRCULAR)
pipeline_type = GSK_VULKAN_PIPELINE_COLOR_CLIP_ROUNDED;
else
gsk: make logging per-renderer Add a setter for per-renderer debug flags, and use them where possible. Some places don't have easy access to a renderer, so this is not complete. Also, use g_message instead of g_print throughout.
2018-01-14 14:52:52 +00:00
FALLBACK ("Color nodes can't deal with clip type %u", constants->clip.type);
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
op.type = GSK_VULKAN_OP_COLOR;
vulkan: Add proof-of-concept clip implementation We can now clip to cicular rounded rectangles when drawing colors.
2016-12-24 05:16:54 +00:00
op.render.pipeline = gsk_vulkan_render_get_pipeline (render, pipeline_type);
vulkan: Add more node operations Add SURFACE and TEXTURE operations. This way, we actually render more than one node every frame because not everything is a fallback node anymore that gets composited with its children into a cairo surface.
2016-12-09 04:59:19 +00:00
g_array_append_val (self->render_ops, op);
gsk: Add GskVulkanClip This is now tracking the clips added by the clip nodes. If any particular node can't deal with a clip, it falls back to Cairo rendering. But if it can, it will render it directly.
2016-12-23 20:36:17 +00:00
return;
gsk: Remove gsk_render_node_is_surface/texture() Use gsk_render_node_get_node_type() instead.
2016-12-11 01:33:58 +00:00
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
case GSK_LINEAR_GRADIENT_NODE:
case GSK_REPEATING_LINEAR_GRADIENT_NODE:
if (gsk_linear_gradient_node_get_n_color_stops (node) > GSK_VULKAN_LINEAR_GRADIENT_PIPELINE_MAX_COLOR_STOPS)
gsk: make logging per-renderer Add a setter for per-renderer debug flags, and use them where possible. Some places don't have easy access to a renderer, so this is not complete. Also, use g_message instead of g_print throughout.
2018-01-14 14:52:52 +00:00
FALLBACK ("Linear gradient with %zu color stops, hardcoded limit is %u",
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
gsk_linear_gradient_node_get_n_color_stops (node),
GSK_VULKAN_LINEAR_GRADIENT_PIPELINE_MAX_COLOR_STOPS);
if (gsk_vulkan_clip_contains_rect (&constants->clip, &node->bounds))
pipeline_type = GSK_VULKAN_PIPELINE_LINEAR_GRADIENT;
else if (constants->clip.type == GSK_VULKAN_CLIP_RECT)
pipeline_type = GSK_VULKAN_PIPELINE_LINEAR_GRADIENT_CLIP;
else if (constants->clip.type == GSK_VULKAN_CLIP_ROUNDED_CIRCULAR)
pipeline_type = GSK_VULKAN_PIPELINE_LINEAR_GRADIENT_CLIP_ROUNDED;
else
gsk: make logging per-renderer Add a setter for per-renderer debug flags, and use them where possible. Some places don't have easy access to a renderer, so this is not complete. Also, use g_message instead of g_print throughout.
2018-01-14 14:52:52 +00:00
FALLBACK ("Linear gradient nodes can't deal with clip type %u", constants->clip.type);
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
op.type = GSK_VULKAN_OP_LINEAR_GRADIENT;
op.render.pipeline = gsk_vulkan_render_get_pipeline (render, pipeline_type);
g_array_append_val (self->render_ops, op);
return;
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
case GSK_OPACITY_NODE:
if (gsk_vulkan_clip_contains_rect (&constants->clip, &node->bounds))
vulkan: Make the effect renderer take matrix + offset This is in preparation for the new color matrix node. I don't think keeping support for a separate opacity shader is worth it.
2016-12-31 12:24:21 +00:00
pipeline_type = GSK_VULKAN_PIPELINE_COLOR_MATRIX;
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
else if (constants->clip.type == GSK_VULKAN_CLIP_RECT)
vulkan: Make the effect renderer take matrix + offset This is in preparation for the new color matrix node. I don't think keeping support for a separate opacity shader is worth it.
2016-12-31 12:24:21 +00:00
pipeline_type = GSK_VULKAN_PIPELINE_COLOR_MATRIX_CLIP;
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
else if (constants->clip.type == GSK_VULKAN_CLIP_ROUNDED_CIRCULAR)
vulkan: Make the effect renderer take matrix + offset This is in preparation for the new color matrix node. I don't think keeping support for a separate opacity shader is worth it.
2016-12-31 12:24:21 +00:00
pipeline_type = GSK_VULKAN_PIPELINE_COLOR_MATRIX_CLIP_ROUNDED;
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
else
gsk: make logging per-renderer Add a setter for per-renderer debug flags, and use them where possible. Some places don't have easy access to a renderer, so this is not complete. Also, use g_message instead of g_print throughout.
2018-01-14 14:52:52 +00:00
FALLBACK ("Opacity nodes can't deal with clip type %u", constants->clip.type);
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
op.type = GSK_VULKAN_OP_OPACITY;
op.render.pipeline = gsk_vulkan_render_get_pipeline (render, pipeline_type);
g_array_append_val (self->render_ops, op);
return;
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
case GSK_BLUR_NODE:
if (gsk_vulkan_clip_contains_rect (&constants->clip, &node->bounds))
pipeline_type = GSK_VULKAN_PIPELINE_BLUR;
else if (constants->clip.type == GSK_VULKAN_CLIP_RECT)
pipeline_type = GSK_VULKAN_PIPELINE_BLUR_CLIP;
else if (constants->clip.type == GSK_VULKAN_CLIP_ROUNDED_CIRCULAR)
pipeline_type = GSK_VULKAN_PIPELINE_BLUR_CLIP_ROUNDED;
else
gsk: make logging per-renderer Add a setter for per-renderer debug flags, and use them where possible. Some places don't have easy access to a renderer, so this is not complete. Also, use g_message instead of g_print throughout.
2018-01-14 14:52:52 +00:00
FALLBACK ("Blur nodes can't deal with clip type %u", constants->clip.type);
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
op.type = GSK_VULKAN_OP_BLUR;
op.render.pipeline = gsk_vulkan_render_get_pipeline (render, pipeline_type);
g_array_append_val (self->render_ops, op);
return;
vulkan: Add support for color matrix nodes @keyframes weee { 100% { filter: hue-rotate(1turn); } } .background { animation: linear infinite 3s weee; }
2016-12-31 13:14:26 +00:00
case GSK_COLOR_MATRIX_NODE:
if (gsk_vulkan_clip_contains_rect (&constants->clip, &node->bounds))
pipeline_type = GSK_VULKAN_PIPELINE_COLOR_MATRIX;
else if (constants->clip.type == GSK_VULKAN_CLIP_RECT)
pipeline_type = GSK_VULKAN_PIPELINE_COLOR_MATRIX_CLIP;
else if (constants->clip.type == GSK_VULKAN_CLIP_ROUNDED_CIRCULAR)
pipeline_type = GSK_VULKAN_PIPELINE_COLOR_MATRIX_CLIP_ROUNDED;
else
gsk: make logging per-renderer Add a setter for per-renderer debug flags, and use them where possible. Some places don't have easy access to a renderer, so this is not complete. Also, use g_message instead of g_print throughout.
2018-01-14 14:52:52 +00:00
FALLBACK ("Color matrix nodes can't deal with clip type %u", constants->clip.type);
vulkan: Add support for color matrix nodes @keyframes weee { 100% { filter: hue-rotate(1turn); } } .background { animation: linear infinite 3s weee; }
2016-12-31 13:14:26 +00:00
op.type = GSK_VULKAN_OP_COLOR_MATRIX;
op.render.pipeline = gsk_vulkan_render_get_pipeline (render, pipeline_type);
g_array_append_val (self->render_ops, op);
return;
vulkan: Add shader for border rendering
2017-01-10 13:59:20 +00:00
case GSK_BORDER_NODE:
if (gsk_vulkan_clip_contains_rect (&constants->clip, &node->bounds))
pipeline_type = GSK_VULKAN_PIPELINE_BORDER;
else if (constants->clip.type == GSK_VULKAN_CLIP_RECT)
pipeline_type = GSK_VULKAN_PIPELINE_BORDER_CLIP;
else if (constants->clip.type == GSK_VULKAN_CLIP_ROUNDED_CIRCULAR)
pipeline_type = GSK_VULKAN_PIPELINE_BORDER_CLIP_ROUNDED;
else
gsk: make logging per-renderer Add a setter for per-renderer debug flags, and use them where possible. Some places don't have easy access to a renderer, so this is not complete. Also, use g_message instead of g_print throughout.
2018-01-14 14:52:52 +00:00
FALLBACK ("Border nodes can't deal with clip type %u", constants->clip.type);
vulkan: Add shader for border rendering
2017-01-10 13:59:20 +00:00
op.type = GSK_VULKAN_OP_BORDER;
op.render.pipeline = gsk_vulkan_render_get_pipeline (render, pipeline_type);
g_array_append_val (self->render_ops, op);
return;
gsk: Remove gsk_render_node_is_surface/texture() Use gsk_render_node_get_node_type() instead.
2016-12-11 01:33:58 +00:00
case GSK_CONTAINER_NODE:
gsK: Move children handling to GskContainerNode
2016-12-12 18:30:41 +00:00
{
guint i;
for (i = 0; i < gsk_container_node_get_n_children (node); i++)
{
vulkan: Fold clip into push constants As a side effect, the clipping data is now available inside shaders. Not that any shader would use them yet, but they could!
2016-12-24 03:58:51 +00:00
gsk_vulkan_render_pass_add_node (self, render, constants, gsk_container_node_get_child (node, i));
gsK: Move children handling to GskContainerNode
2016-12-12 18:30:41 +00:00
}
}
gsk: Add GskVulkanClip This is now tracking the clips added by the clip nodes. If any particular node can't deal with a clip, it falls back to Cairo rendering. But if it can, it will render it directly.
2016-12-23 20:36:17 +00:00
return;
gsk: Add GskDebugNode
2018-04-23 22:41:48 +00:00
case GSK_DEBUG_NODE:
gsk_vulkan_render_pass_add_node (self, render, constants, gsk_debug_node_get_child (node));
return;
gsk: gsk_render_node_set_transform() => GskTransformNode Instead of having a setter for the transform, have a GskTransformNode. Most of the oprations that GTK does do not require a transform, so it doesn't make sense to have it as a primary attribute. Also, changing the transform requires updating the uniforms of the GL renderer, so we're happy if we can avoid that.
2016-12-12 23:11:06 +00:00
case GSK_TRANSFORM_NODE:
{
Tweak transform node apis Rename the getter to follow the peek naming scheme. Update all callers.
2017-10-20 07:31:14 +00:00
graphene_matrix_t transform, mv;
vulkan: Fold clip into push constants As a side effect, the clipping data is now available inside shaders. Not that any shader would use them yet, but they could!
2016-12-24 03:58:51 +00:00
GskRenderNode *child;
gsk: Add GskVulkanClip This is now tracking the clips added by the clip nodes. If any particular node can't deal with a clip, it falls back to Cairo rendering. But if it can, it will render it directly.
2016-12-23 20:36:17 +00:00
vulkan: Fold clip into push constants As a side effect, the clipping data is now available inside shaders. Not that any shader would use them yet, but they could!
2016-12-24 03:58:51 +00:00
#if 0
vulkan: Fix setup for dependent render passes We were not correctly preserving the modelview transform.
2017-09-29 19:45:37 +00:00
if (!gsk_vulkan_clip_contains_rect (clip, &node->bounds))
gsk: Add debug category for fallbacks ... and use it for the cases in Vulkan where we fall back to Cairo.
2016-12-23 23:52:07 +00:00
FALLBACK ("Transform nodes can't deal with clip type %u\n", clip->type);
vulkan: Fold clip into push constants As a side effect, the clipping data is now available inside shaders. Not that any shader would use them yet, but they could!
2016-12-24 03:58:51 +00:00
#endif
gsk: gsk_render_node_set_transform() => GskTransformNode Instead of having a setter for the transform, have a GskTransformNode. Most of the oprations that GTK does do not require a transform, so it doesn't make sense to have it as a primary attribute. Also, changing the transform requires updating the uniforms of the GL renderer, so we're happy if we can avoid that.
2016-12-12 23:11:06 +00:00
gsk: Remove offset nodes They were a neat idea while they lasted. But now, it's time for categorized transform nodes, where matrices with GSK_MATRIX_CATEGORY_2D_TRANSLATE are the exact replacement. Renderers have not been adapted for this purpose, so they (continue to) run slow paths.
2019-02-20 02:02:23 +00:00
child = gsk_transform_node_get_child (node);
rendernode: Make the transform node take a GskTransform This is an attempt to push GskTransform deeper into the stack.
2019-03-01 05:35:55 +00:00
gsk_transform_to_matrix (gsk_transform_node_get_transform (node), &transform);
Tweak transform node apis Rename the getter to follow the peek naming scheme. Update all callers.
2017-10-20 07:31:14 +00:00
graphene_matrix_init_from_matrix (&mv, &self->mv);
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_multiply (&transform, &mv, &self->mv);
vulkan: Handle simple transforms in the clipping code Requires pushing the GskTransform into the clipping code so that we can actually look at its category.
2021-03-06 00:35:04 +00:00
if (!gsk_vulkan_push_constants_transform (&op.constants.constants, constants, gsk_transform_node_get_transform (node), &child->bounds))
gsk: make logging per-renderer Add a setter for per-renderer debug flags, and use them where possible. Some places don't have easy access to a renderer, so this is not complete. Also, use g_message instead of g_print throughout.
2018-01-14 14:52:52 +00:00
FALLBACK ("Transform nodes can't deal with clip type %u", constants->clip.type);
vulkan: Add infrastructure for push constants THe code includes fragment push constants for colors, but that code is so far unused.
2016-12-14 06:21:21 +00:00
op.type = GSK_VULKAN_OP_PUSH_VERTEX_CONSTANTS;
gsk: gsk_render_node_set_transform() => GskTransformNode Instead of having a setter for the transform, have a GskTransformNode. Most of the oprations that GTK does do not require a transform, so it doesn't make sense to have it as a primary attribute. Also, changing the transform requires updating the uniforms of the GL renderer, so we're happy if we can avoid that.
2016-12-12 23:11:06 +00:00
g_array_append_val (self->render_ops, op);
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
vulkan: Fold clip into push constants As a side effect, the clipping data is now available inside shaders. Not that any shader would use them yet, but they could!
2016-12-24 03:58:51 +00:00
gsk_vulkan_render_pass_add_node (self, render, &op.constants.constants, child);
vulkan: Split render ops into seperate structs This makes it a lot clearer which members are relevant for each different operation.
2016-12-14 06:34:18 +00:00
gsk_vulkan_push_constants_init_copy (&op.constants.constants, constants);
Tweak transform node apis Rename the getter to follow the peek naming scheme. Update all callers.
2017-10-20 07:31:14 +00:00
graphene_matrix_init_from_matrix (&self->mv, &mv);
gsk: gsk_render_node_set_transform() => GskTransformNode Instead of having a setter for the transform, have a GskTransformNode. Most of the oprations that GTK does do not require a transform, so it doesn't make sense to have it as a primary attribute. Also, changing the transform requires updating the uniforms of the GL renderer, so we're happy if we can avoid that.
2016-12-12 23:11:06 +00:00
g_array_append_val (self->render_ops, op);
}
gsk: Add GskVulkanClip This is now tracking the clips added by the clip nodes. If any particular node can't deal with a clip, it falls back to Cairo rendering. But if it can, it will render it directly.
2016-12-23 20:36:17 +00:00
return;
case GSK_CLIP_NODE:
{
rendernode: Rename all gsk_render_node_peek_*() functions Those are getters, they should be gsk_render_node_get_*() functions.
2020-11-16 23:59:36 +00:00
if (!gsk_vulkan_push_constants_intersect_rect (&op.constants.constants, constants, gsk_clip_node_get_clip (node)))
gsk: make logging per-renderer Add a setter for per-renderer debug flags, and use them where possible. Some places don't have easy access to a renderer, so this is not complete. Also, use g_message instead of g_print throughout.
2018-01-14 14:52:52 +00:00
FALLBACK ("Failed to find intersection between clip of type %u and rectangle", constants->clip.type);
gsk: Fix build on Visual Studio One cannot use #if...#endif within macro calls in Visual Studio and possibly other compilers, and there are more uses of VLAs that need to be replaced with g_newa(). There were also checks for the clip type in gskvulkanrenderpass.c which were possibly not done right (using the address of the type value to check for a type value), which triggered errors as one is attempting to compare a pointer type to an enum/int type. https://bugzilla.gnome.org/show_bug.cgi?id=773299
2016-12-28 14:37:01 +00:00
if (op.constants.constants.clip.type == GSK_VULKAN_CLIP_ALL_CLIPPED)
gsk: Add GskVulkanClip This is now tracking the clips added by the clip nodes. If any particular node can't deal with a clip, it falls back to Cairo rendering. But if it can, it will render it directly.
2016-12-23 20:36:17 +00:00
return;
vulkan: Fold clip into push constants As a side effect, the clipping data is now available inside shaders. Not that any shader would use them yet, but they could!
2016-12-24 03:58:51 +00:00
op.type = GSK_VULKAN_OP_PUSH_VERTEX_CONSTANTS;
g_array_append_val (self->render_ops, op);
gsk_vulkan_render_pass_add_node (self, render, &op.constants.constants, gsk_clip_node_get_child (node));
gsk_vulkan_push_constants_init_copy (&op.constants.constants, constants);
g_array_append_val (self->render_ops, op);
gsk: Add GskVulkanClip This is now tracking the clips added by the clip nodes. If any particular node can't deal with a clip, it falls back to Cairo rendering. But if it can, it will render it directly.
2016-12-23 20:36:17 +00:00
}
return;
case GSK_ROUNDED_CLIP_NODE:
{
vulkan: Fold clip into push constants As a side effect, the clipping data is now available inside shaders. Not that any shader would use them yet, but they could!
2016-12-24 03:58:51 +00:00
if (!gsk_vulkan_push_constants_intersect_rounded (&op.constants.constants,
constants,
rendernode: Rename all gsk_render_node_peek_*() functions Those are getters, they should be gsk_render_node_get_*() functions.
2020-11-16 23:59:36 +00:00
gsk_rounded_clip_node_get_clip (node)))
gsk: make logging per-renderer Add a setter for per-renderer debug flags, and use them where possible. Some places don't have easy access to a renderer, so this is not complete. Also, use g_message instead of g_print throughout.
2018-01-14 14:52:52 +00:00
FALLBACK ("Failed to find intersection between clip of type %u and rounded rectangle", constants->clip.type);
gsk: Fix build on Visual Studio One cannot use #if...#endif within macro calls in Visual Studio and possibly other compilers, and there are more uses of VLAs that need to be replaced with g_newa(). There were also checks for the clip type in gskvulkanrenderpass.c which were possibly not done right (using the address of the type value to check for a type value), which triggered errors as one is attempting to compare a pointer type to an enum/int type. https://bugzilla.gnome.org/show_bug.cgi?id=773299
2016-12-28 14:37:01 +00:00
if (op.constants.constants.clip.type == GSK_VULKAN_CLIP_ALL_CLIPPED)
gsk: Add GskVulkanClip This is now tracking the clips added by the clip nodes. If any particular node can't deal with a clip, it falls back to Cairo rendering. But if it can, it will render it directly.
2016-12-23 20:36:17 +00:00
return;
vulkan: Fold clip into push constants As a side effect, the clipping data is now available inside shaders. Not that any shader would use them yet, but they could!
2016-12-24 03:58:51 +00:00
op.type = GSK_VULKAN_OP_PUSH_VERTEX_CONSTANTS;
g_array_append_val (self->render_ops, op);
gsk_vulkan_render_pass_add_node (self, render, &op.constants.constants, gsk_rounded_clip_node_get_child (node));
gsk_vulkan_push_constants_init_copy (&op.constants.constants, constants);
g_array_append_val (self->render_ops, op);
gsk: Add GskVulkanClip This is now tracking the clips added by the clip nodes. If any particular node can't deal with a clip, it falls back to Cairo rendering. But if it can, it will render it directly.
2016-12-23 20:36:17 +00:00
}
return;
}
g_assert_not_reached ();
return;
fallback:
vulkan: Fold clip into push constants As a side effect, the clipping data is now available inside shaders. Not that any shader would use them yet, but they could!
2016-12-24 03:58:51 +00:00
switch (constants->clip.type)
gsk: Add GskVulkanClip This is now tracking the clips added by the clip nodes. If any particular node can't deal with a clip, it falls back to Cairo rendering. But if it can, it will render it directly.
2016-12-23 20:36:17 +00:00
{
case GSK_VULKAN_CLIP_NONE:
op.type = GSK_VULKAN_OP_FALLBACK;
break;
case GSK_VULKAN_CLIP_RECT:
op.type = GSK_VULKAN_OP_FALLBACK_CLIP;
vulkan: Fold clip into push constants As a side effect, the clipping data is now available inside shaders. Not that any shader would use them yet, but they could!
2016-12-24 03:58:51 +00:00
gsk_rounded_rect_init_copy (&op.render.clip, &constants->clip.rect);
gsk: Add GskVulkanClip This is now tracking the clips added by the clip nodes. If any particular node can't deal with a clip, it falls back to Cairo rendering. But if it can, it will render it directly.
2016-12-23 20:36:17 +00:00
break;
case GSK_VULKAN_CLIP_ROUNDED_CIRCULAR:
case GSK_VULKAN_CLIP_ROUNDED:
op.type = GSK_VULKAN_OP_FALLBACK_ROUNDED_CLIP;
vulkan: Fold clip into push constants As a side effect, the clipping data is now available inside shaders. Not that any shader would use them yet, but they could!
2016-12-24 03:58:51 +00:00
gsk_rounded_rect_init_copy (&op.render.clip, &constants->clip.rect);
gsk: Add GskVulkanClip This is now tracking the clips added by the clip nodes. If any particular node can't deal with a clip, it falls back to Cairo rendering. But if it can, it will render it directly.
2016-12-23 20:36:17 +00:00
break;
case GSK_VULKAN_CLIP_ALL_CLIPPED:
default:
g_assert_not_reached ();
return;
vulkan: Add more node operations Add SURFACE and TEXTURE operations. This way, we actually render more than one node every frame because not everything is a fallback node anymore that gets composited with its children into a cairo surface.
2016-12-09 04:59:19 +00:00
}
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
op.render.pipeline = gsk_vulkan_render_get_pipeline (render, GSK_VULKAN_PIPELINE_TEXTURE);
gsk: Add GskVulkanClip This is now tracking the clips added by the clip nodes. If any particular node can't deal with a clip, it falls back to Cairo rendering. But if it can, it will render it directly.
2016-12-23 20:36:17 +00:00
g_array_append_val (self->render_ops, op);
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 debug category for fallbacks ... and use it for the cases in Vulkan where we fall back to Cairo.
2016-12-23 23:52:07 +00:00
#undef FALLBACK
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: gsk_render_node_set_transform() => GskTransformNode Instead of having a setter for the transform, have a GskTransformNode. Most of the oprations that GTK does do not require a transform, so it doesn't make sense to have it as a primary attribute. Also, changing the transform requires updating the uniforms of the GL renderer, so we're happy if we can avoid that.
2016-12-12 23:11:06 +00:00
void
gsk_vulkan_render_pass_add (GskVulkanRenderPass *self,
GskVulkanRender *render,
GskRenderNode *node)
{
vulkan: Split render ops into seperate structs This makes it a lot clearer which members are relevant for each different operation.
2016-12-14 06:34:18 +00:00
GskVulkanOp op = { 0, };
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 mvp;
gsk: gsk_render_node_set_transform() => GskTransformNode Instead of having a setter for the transform, have a GskTransformNode. Most of the oprations that GTK does do not require a transform, so it doesn't make sense to have it as a primary attribute. Also, changing the transform requires updating the uniforms of the GL renderer, so we're happy if we can avoid that.
2016-12-12 23:11:06 +00:00
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_multiply (&self->mv, &self->p, &mvp);
vulkan: Add infrastructure for push constants THe code includes fragment push constants for colors, but that code is so far unused.
2016-12-14 06:21:21 +00:00
op.type = GSK_VULKAN_OP_PUSH_VERTEX_CONSTANTS;
vulkan: Fix setup for dependent render passes We were not correctly preserving the modelview transform.
2017-09-29 19:45:37 +00:00
gsk_vulkan_push_constants_init (&op.constants.constants, &mvp, &self->viewport);
gsk: gsk_render_node_set_transform() => GskTransformNode Instead of having a setter for the transform, have a GskTransformNode. Most of the oprations that GTK does do not require a transform, so it doesn't make sense to have it as a primary attribute. Also, changing the transform requires updating the uniforms of the GL renderer, so we're happy if we can avoid that.
2016-12-12 23:11:06 +00:00
g_array_append_val (self->render_ops, op);
vulkan: Fold clip into push constants As a side effect, the clipping data is now available inside shaders. Not that any shader would use them yet, but they could!
2016-12-24 03:58:51 +00:00
gsk_vulkan_render_pass_add_node (self, render, &op.constants.constants, node);
gsk: gsk_render_node_set_transform() => GskTransformNode Instead of having a setter for the transform, have a GskTransformNode. Most of the oprations that GTK does do not require a transform, so it doesn't make sense to have it as a primary attribute. Also, changing the transform requires updating the uniforms of the GL renderer, so we're happy if we can avoid that.
2016-12-12 23:11:06 +00:00
}
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
static GskVulkanImage *
build: Don't turn off critical warnings -Wint-conversion is important because it checks casts from ints to pointers. -Wdiscarded-qualifiers is important to catch cases where we don't strings when we should.
2017-10-06 14:01:19 +00:00
gsk_vulkan_render_pass_get_node_as_texture (GskVulkanRenderPass *self,
GskVulkanRender *render,
GskVulkanUploader *uploader,
GskRenderNode *node,
const graphene_rect_t *bounds,
GskVulkanClip *current_clip,
graphene_rect_t *tex_rect)
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
{
GskVulkanImage *result;
cairo_surface_t *surface;
cairo_t *cr;
build: Enable -Wswitch-enum and -Wswitch-default This patch makes that work using 1 of 2 options: 1. Add all missing enums to the switch statement or 2. Cast the switch argument to a uint to avoid having to do that (mostly for GdkEventType). I even found a bug while doing that: clearing a GtkImage with a surface did not notify thae surface property. The reason for enabling this flag even though it is tedious at times is that it is very useful when adding values to an enum, because it makes GTK immediately warn about all the switch statements where this enum is relevant. And I expect changes to enums to be frequent during the GTK4 development cycle.
2017-10-06 19:19:42 +00:00
switch ((guint) gsk_render_node_get_node_type (node))
vulkan: Optimize getting textures When we already have a texture or know we need to upload, just do that instead of rendering to Cairo.
2016-12-31 21:58:15 +00:00
{
Partially revert GskTexture → GdkTexture rename Excessive use of sed when moving GskTexture to GDK; the GskTextureNode should still live under the GSK namespace.
2017-11-04 15:03:03 +00:00
case GSK_TEXTURE_NODE:
Clip intermediate textures In some cases, we were creating gigantic intermediate textures only to clip out a small section afterwards (e.g. in the listbox example in gtk4-demo). This is wasteful if we apply effects on the texture, such as blur or color-matrix. So, clip the dimensions of the intermediate texture with the current clip. To make this feasible, we move the texture coordinate computation out of the pipeline setup functions into the node_as_texture function where this clipping happens. One extra complication we encounter is that the node might get clipped away completely. Since Vulkan does not allow to create empty images, we bail out in this case and not draw anything. With these changes, the listbox example in gtk4-demo goes from 32M pixels of intermediate texture to 320000.
2017-10-01 23:17:39 +00:00
if (graphene_rect_equal (bounds, &node->bounds))
vulkan: Optimize getting textures When we already have a texture or know we need to upload, just do that instead of rendering to Cairo.
2016-12-31 21:58:15 +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
result = gsk_vulkan_renderer_ref_texture_image (GSK_VULKAN_RENDERER (gsk_vulkan_render_get_renderer (render)),
Partially revert GskTexture → GdkTexture rename Excessive use of sed when moving GskTexture to GDK; the GskTextureNode should still live under the GSK namespace.
2017-11-04 15:03:03 +00:00
gsk_texture_node_get_texture (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
uploader);
gsk_vulkan_render_add_cleanup_image (render, result);
Clip intermediate textures In some cases, we were creating gigantic intermediate textures only to clip out a small section afterwards (e.g. in the listbox example in gtk4-demo). This is wasteful if we apply effects on the texture, such as blur or color-matrix. So, clip the dimensions of the intermediate texture with the current clip. To make this feasible, we move the texture coordinate computation out of the pipeline setup functions into the node_as_texture function where this clipping happens. One extra complication we encounter is that the node might get clipped away completely. Since Vulkan does not allow to create empty images, we bail out in this case and not draw anything. With these changes, the listbox example in gtk4-demo goes from 32M pixels of intermediate texture to 320000.
2017-10-01 23:17:39 +00:00
*tex_rect = GRAPHENE_RECT_INIT(0, 0, 1, 1);
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
return result;
Clip intermediate textures In some cases, we were creating gigantic intermediate textures only to clip out a small section afterwards (e.g. in the listbox example in gtk4-demo). This is wasteful if we apply effects on the texture, such as blur or color-matrix. So, clip the dimensions of the intermediate texture with the current clip. To make this feasible, we move the texture coordinate computation out of the pipeline setup functions into the node_as_texture function where this clipping happens. One extra complication we encounter is that the node might get clipped away completely. Since Vulkan does not allow to create empty images, we bail out in this case and not draw anything. With these changes, the listbox example in gtk4-demo goes from 32M pixels of intermediate texture to 320000.
2017-10-01 23:17:39 +00:00
}
break;
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 intermediate textures In some cases, we were creating gigantic intermediate textures only to clip out a small section afterwards (e.g. in the listbox example in gtk4-demo). This is wasteful if we apply effects on the texture, such as blur or color-matrix. So, clip the dimensions of the intermediate texture with the current clip. To make this feasible, we move the texture coordinate computation out of the pipeline setup functions into the node_as_texture function where this clipping happens. One extra complication we encounter is that the node might get clipped away completely. Since Vulkan does not allow to create empty images, we bail out in this case and not draw anything. With these changes, the listbox example in gtk4-demo goes from 32M pixels of intermediate texture to 320000.
2017-10-01 23:17:39 +00:00
case GSK_CAIRO_NODE:
vulkan: Remove special case for Cairo surfaces This is in preparation for the next commits which switch Cairo nodes to recording surfaces.
2018-03-24 15:41:59 +00:00
/* We're using recording surfaces, so drawing them to an image
* surface and uploading them is the right thing.
* But that's exactly what the fallback code does.
*/
Clip intermediate textures In some cases, we were creating gigantic intermediate textures only to clip out a small section afterwards (e.g. in the listbox example in gtk4-demo). This is wasteful if we apply effects on the texture, such as blur or color-matrix. So, clip the dimensions of the intermediate texture with the current clip. To make this feasible, we move the texture coordinate computation out of the pipeline setup functions into the node_as_texture function where this clipping happens. One extra complication we encounter is that the node might get clipped away completely. Since Vulkan does not allow to create empty images, we bail out in this case and not draw anything. With these changes, the listbox example in gtk4-demo goes from 32M pixels of intermediate texture to 320000.
2017-10-01 23:17:39 +00:00
break;
vulkan: Optimize getting textures When we already have a texture or know we need to upload, just do that instead of rendering to Cairo.
2016-12-31 21:58:15 +00:00
build: Enable -Wswitch-enum and -Wswitch-default This patch makes that work using 1 of 2 options: 1. Add all missing enums to the switch statement or 2. Cast the switch argument to a uint to avoid having to do that (mostly for GdkEventType). I even found a bug while doing that: clearing a GtkImage with a surface did not notify thae surface property. The reason for enabling this flag even though it is tedious at times is that it is very useful when adding values to an enum, because it makes GTK immediately warn about all the switch statements where this enum is relevant. And I expect changes to enums to be frequent during the GTK4 development cycle.
2017-10-06 19:19:42 +00:00
default:
Clip intermediate textures In some cases, we were creating gigantic intermediate textures only to clip out a small section afterwards (e.g. in the listbox example in gtk4-demo). This is wasteful if we apply effects on the texture, such as blur or color-matrix. So, clip the dimensions of the intermediate texture with the current clip. To make this feasible, we move the texture coordinate computation out of the pipeline setup functions into the node_as_texture function where this clipping happens. One extra complication we encounter is that the node might get clipped away completely. Since Vulkan does not allow to create empty images, we bail out in this case and not draw anything. With these changes, the listbox example in gtk4-demo goes from 32M pixels of intermediate texture to 320000.
2017-10-01 23:17:39 +00:00
{
VkSemaphore semaphore;
graphene_rect_t view;
cairo_region_t *clip;
GskVulkanRenderPass *pass;
graphene_rect_t clipped;
if (current_clip)
graphene_rect_intersection (&current_clip->rect.bounds, bounds, &clipped);
else
clipped = *bounds;
vulkan: Fix setup for dependent render passes We were not correctly preserving the modelview transform.
2017-09-29 19:45:37 +00:00
Clip intermediate textures In some cases, we were creating gigantic intermediate textures only to clip out a small section afterwards (e.g. in the listbox example in gtk4-demo). This is wasteful if we apply effects on the texture, such as blur or color-matrix. So, clip the dimensions of the intermediate texture with the current clip. To make this feasible, we move the texture coordinate computation out of the pipeline setup functions into the node_as_texture function where this clipping happens. One extra complication we encounter is that the node might get clipped away completely. Since Vulkan does not allow to create empty images, we bail out in this case and not draw anything. With these changes, the listbox example in gtk4-demo goes from 32M pixels of intermediate texture to 320000.
2017-10-01 23:17:39 +00:00
if (clipped.size.width == 0 || clipped.size.height == 0)
return NULL;
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 intermediate textures In some cases, we were creating gigantic intermediate textures only to clip out a small section afterwards (e.g. in the listbox example in gtk4-demo). This is wasteful if we apply effects on the texture, such as blur or color-matrix. So, clip the dimensions of the intermediate texture with the current clip. To make this feasible, we move the texture coordinate computation out of the pipeline setup functions into the node_as_texture function where this clipping happens. One extra complication we encounter is that the node might get clipped away completely. Since Vulkan does not allow to create empty images, we bail out in this case and not draw anything. With these changes, the listbox example in gtk4-demo goes from 32M pixels of intermediate texture to 320000.
2017-10-01 23:17:39 +00:00
graphene_matrix_transform_bounds (&self->mv, &clipped, &view);
view.origin.x = floor (view.origin.x);
view.origin.y = floor (view.origin.y);
view.size.width = ceil (view.size.width);
view.size.height = ceil (view.size.height);
result = gsk_vulkan_image_new_for_texture (self->vulkan,
view.size.width,
view.size.height);
vulkan: Implement multiple render passes Whenever we need a node as a texture, we now start a new render pass that renders the node into a new intermediate texture, and set up a semaphore to make the current render pass wait for it. As part of this reorganization, much of the setup and drawing code moved from gskvulkanrender.c to gskvulkanrenderpass.c.
2017-09-28 00:56:01 +00:00
vulkan: Add a counter for intermediate textures Count how many pixels of intermediate textures we create. If we can count it, we can optimize it.
2017-09-30 14:39:04 +00:00
#ifdef G_ENABLE_DEBUG
Clip intermediate textures In some cases, we were creating gigantic intermediate textures only to clip out a small section afterwards (e.g. in the listbox example in gtk4-demo). This is wasteful if we apply effects on the texture, such as blur or color-matrix. So, clip the dimensions of the intermediate texture with the current clip. To make this feasible, we move the texture coordinate computation out of the pipeline setup functions into the node_as_texture function where this clipping happens. One extra complication we encounter is that the node might get clipped away completely. Since Vulkan does not allow to create empty images, we bail out in this case and not draw anything. With these changes, the listbox example in gtk4-demo goes from 32M pixels of intermediate texture to 320000.
2017-10-01 23:17:39 +00:00
{
GskProfiler *profiler = gsk_renderer_get_profiler (gsk_vulkan_render_get_renderer (render));
gsk_profiler_counter_add (profiler,
self->texture_pixels,
view.size.width * view.size.height);
}
vulkan: Add a counter for intermediate textures Count how many pixels of intermediate textures we create. If we can count it, we can optimize it.
2017-09-30 14:39:04 +00:00
#endif
Clip intermediate textures In some cases, we were creating gigantic intermediate textures only to clip out a small section afterwards (e.g. in the listbox example in gtk4-demo). This is wasteful if we apply effects on the texture, such as blur or color-matrix. So, clip the dimensions of the intermediate texture with the current clip. To make this feasible, we move the texture coordinate computation out of the pipeline setup functions into the node_as_texture function where this clipping happens. One extra complication we encounter is that the node might get clipped away completely. Since Vulkan does not allow to create empty images, we bail out in this case and not draw anything. With these changes, the listbox example in gtk4-demo goes from 32M pixels of intermediate texture to 320000.
2017-10-01 23:17:39 +00:00
vkCreateSemaphore (gdk_vulkan_context_get_device (self->vulkan),
&(VkSemaphoreCreateInfo) {
VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO,
NULL,
0
},
NULL,
&semaphore);
g_array_append_val (self->wait_semaphores, semaphore);
clip = cairo_region_create_rectangle (&(cairo_rectangle_int_t) {
0, 0,
gsk_vulkan_image_get_width (result),
gsk_vulkan_image_get_height (result)
});
pass = gsk_vulkan_render_pass_new (self->vulkan,
result,
self->scale_factor,
&self->mv,
&view,
clip,
semaphore);
cairo_region_destroy (clip);
gsk_vulkan_render_add_render_pass (render, pass);
gsk_vulkan_render_pass_add (pass, render, node);
gsk_vulkan_render_add_cleanup_image (render, result);
/* assuming the unclipped bounds should go to texture coordinates 0..1,
* calculate the coordinates for the clipped texture size
*/
tex_rect->origin.x = (bounds->origin.x - clipped.origin.x)/clipped.size.width;
tex_rect->origin.y = (bounds->origin.y - clipped.origin.y)/clipped.size.height;
tex_rect->size.width = bounds->size.width/clipped.size.width;
tex_rect->size.height = bounds->size.height/clipped.size.height;
return result;
}
}
vulkan: Optimize getting textures When we already have a texture or know we need to upload, just do that instead of rendering to Cairo.
2016-12-31 21:58:15 +00:00
gsk: make logging per-renderer Add a setter for per-renderer debug flags, and use them where possible. Some places don't have easy access to a renderer, so this is not complete. Also, use g_message instead of g_print throughout.
2018-01-14 14:52:52 +00:00
GSK_RENDERER_NOTE (gsk_vulkan_render_get_renderer (render), FALLBACK, g_message ("Node as texture not implemented for this case. Using %gx%g fallback surface",
vulkan: Add fallback message for node-as-texture This is mainly to motivate me to implement it.
2017-01-17 05:38:36 +00:00
ceil (bounds->size.width),
gsk: report fallback pixels as a profile counter This makes the value show up in the inspector without any extra work. We report the number per-frame, since that makes the most sense.
2017-09-26 01:02:21 +00:00
ceil (bounds->size.height)));
#ifdef G_ENABLE_DEBUG
{
GskProfiler *profiler = gsk_renderer_get_profiler (gsk_vulkan_render_get_renderer (render));
gsk_profiler_counter_add (profiler,
self->fallback_pixels,
ceil (bounds->size.width) * ceil (bounds->size.height));
}
#endif
vulkan: Add fallback message for node-as-texture This is mainly to motivate me to implement it.
2017-01-17 05:38:36 +00:00
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
/* XXX: We could intersect bounds with clip bounds here */
surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32,
ceil (bounds->size.width),
ceil (bounds->size.height));
cr = cairo_create (surface);
cairo_translate (cr, -bounds->origin.x, -bounds->origin.y);
gsk_render_node_draw (node, cr);
cairo_destroy (cr);
result = gsk_vulkan_image_new_from_data (uploader,
cairo_image_surface_get_data (surface),
cairo_image_surface_get_width (surface),
cairo_image_surface_get_height (surface),
cairo_image_surface_get_stride (surface));
cairo_surface_destroy (surface);
gsk_vulkan_render_add_cleanup_image (render, result);
vulkan: Fix repeat node coordinates We were not treating non-trivial child bounds right at all. This was visible in the css blendmode cmyk example in gtk4-demo, for the normal blendmode.
2017-10-08 12:44:02 +00:00
tex_rect->origin.x = (node->bounds.origin.x - bounds->origin.x)/bounds->size.width;
tex_rect->origin.y = (node->bounds.origin.y - bounds->origin.y)/bounds->size.height;
tex_rect->size.width = node->bounds.size.width/bounds->size.width;
tex_rect->size.height = node->bounds.size.height/bounds->size.height;
Clip intermediate textures In some cases, we were creating gigantic intermediate textures only to clip out a small section afterwards (e.g. in the listbox example in gtk4-demo). This is wasteful if we apply effects on the texture, such as blur or color-matrix. So, clip the dimensions of the intermediate texture with the current clip. To make this feasible, we move the texture coordinate computation out of the pipeline setup functions into the node_as_texture function where this clipping happens. One extra complication we encounter is that the node might get clipped away completely. Since Vulkan does not allow to create empty images, we bail out in this case and not draw anything. With these changes, the listbox example in gtk4-demo goes from 32M pixels of intermediate texture to 320000.
2017-10-01 23:17:39 +00:00
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
return result;
}
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: 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_render_pass_upload_fallback (GskVulkanRenderPass *self,
GskVulkanOpRender *op,
GskVulkanRender *render,
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: 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 bounds member to RenderNode Instead of constantly recalculating this (especially recursively for parents!) we do it only on construction, because everything is immutable anyway. Also, most nodes had a bounds already and can use the new parent member instead. We also do direct access to the node bounds rather than calling gsk_render_node_get_bounds in various places, which means we do less copying.
2016-12-21 10:21:38 +00:00
GskRenderNode *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
cairo_surface_t *surface;
cairo_t *cr;
gsk: Add bounds member to RenderNode Instead of constantly recalculating this (especially recursively for parents!) we do it only on construction, because everything is immutable anyway. Also, most nodes had a bounds already and can use the new parent member instead. We also do direct access to the node bounds rather than calling gsk_render_node_get_bounds in various places, which means we do less copying.
2016-12-21 10:21:38 +00:00
node = op->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
gsk: make logging per-renderer Add a setter for per-renderer debug flags, and use them where possible. Some places don't have easy access to a renderer, so this is not complete. Also, use g_message instead of g_print throughout.
2018-01-14 14:52:52 +00:00
GSK_RENDERER_NOTE (gsk_vulkan_render_get_renderer (render), FALLBACK,
g_message ("Upload op=%s, node %s[%p], bounds %gx%g",
vulkan: Add more debug spew
2017-09-03 15:34:41 +00:00
op->type == GSK_VULKAN_OP_FALLBACK_CLIP ? "fallback-clip" :
(op->type == GSK_VULKAN_OP_FALLBACK_ROUNDED_CLIP ? "fallback-rounded-clip" : "fallback"),
Turn GskRenderNode into a derivable type Language bindings—especially ones based on introspection—cannot deal with custom type hiearchies. Luckily for us, GType has a derivable type with low overhead: GTypeInstance. By turning GskRenderNode into a GTypeInstance, and creating derived types for each class of node, we can provide an introspectable API to our non-C API consumers, with no functional change to the C API itself.
2020-04-07 22:33:54 +00:00
g_type_name_from_instance ((GTypeInstance *) node), node,
vulkan: Add more debug spew
2017-09-03 15:34:41 +00:00
ceil (node->bounds.size.width),
gsk: report fallback pixels as a profile counter This makes the value show up in the inspector without any extra work. We report the number per-frame, since that makes the most sense.
2017-09-26 01:02:21 +00:00
ceil (node->bounds.size.height)));
#ifdef G_ENABLE_DEBUG
{
GskProfiler *profiler = gsk_renderer_get_profiler (gsk_vulkan_render_get_renderer (render));
gsk_profiler_counter_add (profiler,
self->fallback_pixels,
ceil (node->bounds.size.width) * ceil (node->bounds.size.height));
}
#endif
vulkan: Add more debug spew
2017-09-03 15:34:41 +00:00
gsk: Add GskVulkanClip This is now tracking the clips added by the clip nodes. If any particular node can't deal with a clip, it falls back to Cairo rendering. But if it can, it will render it directly.
2016-12-23 20:36:17 +00:00
/* XXX: We could intersect bounds with clip bounds here */
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
surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32,
gsk: Apply scale factor for fallback rendering This fixes blurry text and icons whenever we apply shadows in a hidpi window. Shadow nodes are the last ones that we still use fallback for, and this was causing us to render the text blurry.
2017-10-28 18:38:49 +00:00
ceil (node->bounds.size.width * self->scale_factor),
ceil (node->bounds.size.height * self->scale_factor));
cairo_surface_set_device_scale (surface, self->scale_factor, self->scale_factor);
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
cr = cairo_create (surface);
gsk: Add bounds member to RenderNode Instead of constantly recalculating this (especially recursively for parents!) we do it only on construction, because everything is immutable anyway. Also, most nodes had a bounds already and can use the new parent member instead. We also do direct access to the node bounds rather than calling gsk_render_node_get_bounds in various places, which means we do less copying.
2016-12-21 10:21:38 +00:00
cairo_translate (cr, -node->bounds.origin.x, -node->bounds.origin.y);
gsk: Add GskVulkanClip This is now tracking the clips added by the clip nodes. If any particular node can't deal with a clip, it falls back to Cairo rendering. But if it can, it will render it directly.
2016-12-23 20:36:17 +00:00
if (op->type == GSK_VULKAN_OP_FALLBACK_CLIP)
{
cairo_rectangle (cr,
op->clip.bounds.origin.x, op->clip.bounds.origin.y,
op->clip.bounds.size.width, op->clip.bounds.size.height);
cairo_clip (cr);
}
else if (op->type == GSK_VULKAN_OP_FALLBACK_ROUNDED_CLIP)
{
gsk_rounded_rect_path (&op->clip, cr);
cairo_clip (cr);
}
else
{
g_assert (op->type == GSK_VULKAN_OP_FALLBACK);
}
gsk: Add bounds member to RenderNode Instead of constantly recalculating this (especially recursively for parents!) we do it only on construction, because everything is immutable anyway. Also, most nodes had a bounds already and can use the new parent member instead. We also do direct access to the node bounds rather than calling gsk_render_node_get_bounds in various places, which means we do less copying.
2016-12-21 10:21:38 +00:00
gsk_render_node_draw (node, cr);
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 visible fallback rendering Hook up the "Show fallback rendering" switch for Vulkan. This brings home the sobering truth that the Vulkan renderer is doing *all* fallback, since we switched from offset nodes to transform nodes.
2021-03-05 23:39:22 +00:00
#ifdef G_ENABLE_DEBUG
if (GSK_RENDERER_DEBUG_CHECK (gsk_vulkan_render_get_renderer (render), FALLBACK))
{
cairo_rectangle (cr,
op->clip.bounds.origin.x, op->clip.bounds.origin.y,
op->clip.bounds.size.width, op->clip.bounds.size.height);
if (gsk_render_node_get_node_type (node) == GSK_CAIRO_NODE)
cairo_set_source_rgba (cr, 0.3, 0, 1, 0.25);
else
cairo_set_source_rgba (cr, 1, 0, 0, 0.25);
cairo_fill_preserve (cr);
if (gsk_render_node_get_node_type (node) == GSK_CAIRO_NODE)
cairo_set_source_rgba (cr, 0.3, 0, 1, 1);
else
cairo_set_source_rgba (cr, 1, 0, 0, 1);
cairo_stroke (cr);
}
#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
cairo_destroy (cr);
vulkan: Add GskVulkanUploader It's the thing that makes sure pixels end up on the GPU.
2016-12-17 03:22:44 +00:00
op->source = gsk_vulkan_image_new_from_data (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
cairo_image_surface_get_data (surface),
cairo_image_surface_get_width (surface),
cairo_image_surface_get_height (surface),
cairo_image_surface_get_stride (surface));
Clip intermediate textures In some cases, we were creating gigantic intermediate textures only to clip out a small section afterwards (e.g. in the listbox example in gtk4-demo). This is wasteful if we apply effects on the texture, such as blur or color-matrix. So, clip the dimensions of the intermediate texture with the current clip. To make this feasible, we move the texture coordinate computation out of the pipeline setup functions into the node_as_texture function where this clipping happens. One extra complication we encounter is that the node might get clipped away completely. Since Vulkan does not allow to create empty images, we bail out in this case and not draw anything. With these changes, the listbox example in gtk4-demo goes from 32M pixels of intermediate texture to 320000.
2017-10-01 23:17:39 +00:00
op->source_rect = GRAPHENE_RECT_INIT(0, 0, 1, 1);
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
cairo_surface_destroy (surface);
gsk_vulkan_render_add_cleanup_image (render, op->source);
}
void
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_render_pass_upload (GskVulkanRenderPass *self,
GskVulkanRender *render,
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: Add GskVulkanRenderPass And move the actual rendering code there. A RenderPass is a collection of operations on the same target that get executed one after another. It roughly targets VkRenderPass or rather the subpasses of a VkRenderPass. For now, only the infrastructure is there. No real stuff is happening.
2016-12-08 12:26:36 +00:00
{
vulkan: Split render ops into seperate structs This makes it a lot clearer which members are relevant for each different operation.
2016-12-14 06:34:18 +00:00
GskVulkanOp *op;
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
guint i;
build: Don't turn off critical warnings -Wint-conversion is important because it checks casts from ints to pointers. -Wdiscarded-qualifiers is important to catch cases where we don't strings when we should.
2017-10-06 14:01:19 +00:00
GskVulkanClip *clip = 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
for (i = 0; i < self->render_ops->len; i++)
{
vulkan: Split render ops into seperate structs This makes it a lot clearer which members are relevant for each different operation.
2016-12-14 06:34:18 +00:00
op = &g_array_index (self->render_ops, GskVulkanOp, i);
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
switch (op->type)
{
case GSK_VULKAN_OP_FALLBACK:
gsk: Add GskVulkanClip This is now tracking the clips added by the clip nodes. If any particular node can't deal with a clip, it falls back to Cairo rendering. But if it can, it will render it directly.
2016-12-23 20:36:17 +00:00
case GSK_VULKAN_OP_FALLBACK_CLIP:
case GSK_VULKAN_OP_FALLBACK_ROUNDED_CLIP:
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_render_pass_upload_fallback (self, &op->render, render, 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
break;
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
case GSK_VULKAN_OP_TEXT:
case GSK_VULKAN_OP_COLOR_TEXT:
{
vulkan: Better glyph cache api Move the glyph caching api to something that can support using multiple textures. We now split the text render ops into multiple ops for different textures, and make each op render just a substring of the text node's glyph string.
2017-09-19 22:53:32 +00:00
op->text.source = gsk_vulkan_renderer_ref_glyph_image (GSK_VULKAN_RENDERER (gsk_vulkan_render_get_renderer (render)),
uploader,
op->text.texture_index);
gsk_vulkan_render_add_cleanup_image (render, op->text.source);
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
}
break;
vulkan: Add more node operations Add SURFACE and TEXTURE operations. This way, we actually render more than one node every frame because not everything is a fallback node anymore that gets composited with its children into a cairo surface.
2016-12-09 04:59:19 +00:00
case GSK_VULKAN_OP_TEXTURE:
{
vulkan: Split render ops into seperate structs This makes it a lot clearer which members are relevant for each different operation.
2016-12-14 06:34:18 +00:00
op->render.source = gsk_vulkan_renderer_ref_texture_image (GSK_VULKAN_RENDERER (gsk_vulkan_render_get_renderer (render)),
Partially revert GskTexture → GdkTexture rename Excessive use of sed when moving GskTexture to GDK; the GskTextureNode should still live under the GSK namespace.
2017-11-04 15:03:03 +00:00
gsk_texture_node_get_texture (op->render.node),
vulkan: Add GskVulkanUploader It's the thing that makes sure pixels end up on the GPU.
2016-12-17 03:22:44 +00:00
uploader);
Clip intermediate textures In some cases, we were creating gigantic intermediate textures only to clip out a small section afterwards (e.g. in the listbox example in gtk4-demo). This is wasteful if we apply effects on the texture, such as blur or color-matrix. So, clip the dimensions of the intermediate texture with the current clip. To make this feasible, we move the texture coordinate computation out of the pipeline setup functions into the node_as_texture function where this clipping happens. One extra complication we encounter is that the node might get clipped away completely. Since Vulkan does not allow to create empty images, we bail out in this case and not draw anything. With these changes, the listbox example in gtk4-demo goes from 32M pixels of intermediate texture to 320000.
2017-10-01 23:17:39 +00:00
op->render.source_rect = GRAPHENE_RECT_INIT(0, 0, 1, 1);
vulkan: Split render ops into seperate structs This makes it a lot clearer which members are relevant for each different operation.
2016-12-14 06:34:18 +00:00
gsk_vulkan_render_add_cleanup_image (render, op->render.source);
vulkan: Add more node operations Add SURFACE and TEXTURE operations. This way, we actually render more than one node every frame because not everything is a fallback node anymore that gets composited with its children into a cairo surface.
2016-12-09 04:59:19 +00:00
}
break;
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
case GSK_VULKAN_OP_OPACITY:
{
GskRenderNode *child = gsk_opacity_node_get_child (op->render.node);
Support repeat nodes in vulkan We can use the texture pipeline for this, with a repeating sampler.
2017-09-30 02:41:00 +00:00
op->render.source = gsk_vulkan_render_pass_get_node_as_texture (self,
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
render,
uploader,
child,
Clip intermediate textures In some cases, we were creating gigantic intermediate textures only to clip out a small section afterwards (e.g. in the listbox example in gtk4-demo). This is wasteful if we apply effects on the texture, such as blur or color-matrix. So, clip the dimensions of the intermediate texture with the current clip. To make this feasible, we move the texture coordinate computation out of the pipeline setup functions into the node_as_texture function where this clipping happens. One extra complication we encounter is that the node might get clipped away completely. Since Vulkan does not allow to create empty images, we bail out in this case and not draw anything. With these changes, the listbox example in gtk4-demo goes from 32M pixels of intermediate texture to 320000.
2017-10-01 23:17:39 +00:00
&child->bounds,
clip,
&op->render.source_rect);
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
}
break;
Support repeat nodes in vulkan We can use the texture pipeline for this, with a repeating sampler.
2017-09-30 02:41:00 +00:00
case GSK_VULKAN_OP_REPEAT:
{
GskRenderNode *child = gsk_repeat_node_get_child (op->render.node);
vulkan: Fix repeat node coordinates We were not treating non-trivial child bounds right at all. This was visible in the css blendmode cmyk example in gtk4-demo, for the normal blendmode.
2017-10-08 12:44:02 +00:00
const graphene_rect_t *bounds = &op->render.node->bounds;
rendernode: Rename all gsk_render_node_peek_*() functions Those are getters, they should be gsk_render_node_get_*() functions.
2020-11-16 23:59:36 +00:00
const graphene_rect_t *child_bounds = gsk_repeat_node_get_child_bounds (op->render.node);
Support repeat nodes in vulkan We can use the texture pipeline for this, with a repeating sampler.
2017-09-30 02:41:00 +00:00
op->render.source = gsk_vulkan_render_pass_get_node_as_texture (self,
render,
uploader,
child,
vulkan: Fix repeat node coordinates We were not treating non-trivial child bounds right at all. This was visible in the css blendmode cmyk example in gtk4-demo, for the normal blendmode.
2017-10-08 12:44:02 +00:00
child_bounds,
Clip intermediate textures In some cases, we were creating gigantic intermediate textures only to clip out a small section afterwards (e.g. in the listbox example in gtk4-demo). This is wasteful if we apply effects on the texture, such as blur or color-matrix. So, clip the dimensions of the intermediate texture with the current clip. To make this feasible, we move the texture coordinate computation out of the pipeline setup functions into the node_as_texture function where this clipping happens. One extra complication we encounter is that the node might get clipped away completely. Since Vulkan does not allow to create empty images, we bail out in this case and not draw anything. With these changes, the listbox example in gtk4-demo goes from 32M pixels of intermediate texture to 320000.
2017-10-01 23:17:39 +00:00
NULL,
&op->render.source_rect);
vulkan: Fix repeat node coordinates We were not treating non-trivial child bounds right at all. This was visible in the css blendmode cmyk example in gtk4-demo, for the normal blendmode.
2017-10-08 12:44:02 +00:00
op->render.source_rect.origin.x = (bounds->origin.x - child_bounds->origin.x)/child_bounds->size.width;
op->render.source_rect.origin.y = (bounds->origin.y - child_bounds->origin.y)/child_bounds->size.height;
op->render.source_rect.size.width = bounds->size.width / child_bounds->size.width;
op->render.source_rect.size.height = bounds->size.height / child_bounds->size.height;
Support repeat nodes in vulkan We can use the texture pipeline for this, with a repeating sampler.
2017-09-30 02:41:00 +00:00
}
break;
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
case GSK_VULKAN_OP_BLUR:
{
GskRenderNode *child = gsk_blur_node_get_child (op->render.node);
op->render.source = gsk_vulkan_render_pass_get_node_as_texture (self,
render,
uploader,
child,
Clip intermediate textures In some cases, we were creating gigantic intermediate textures only to clip out a small section afterwards (e.g. in the listbox example in gtk4-demo). This is wasteful if we apply effects on the texture, such as blur or color-matrix. So, clip the dimensions of the intermediate texture with the current clip. To make this feasible, we move the texture coordinate computation out of the pipeline setup functions into the node_as_texture function where this clipping happens. One extra complication we encounter is that the node might get clipped away completely. Since Vulkan does not allow to create empty images, we bail out in this case and not draw anything. With these changes, the listbox example in gtk4-demo goes from 32M pixels of intermediate texture to 320000.
2017-10-01 23:17:39 +00:00
&child->bounds,
clip,
&op->render.source_rect);
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
}
break;
vulkan: Add support for color matrix nodes @keyframes weee { 100% { filter: hue-rotate(1turn); } } .background { animation: linear infinite 3s weee; }
2016-12-31 13:14:26 +00:00
case GSK_VULKAN_OP_COLOR_MATRIX:
{
GskRenderNode *child = gsk_color_matrix_node_get_child (op->render.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
op->render.source = gsk_vulkan_render_pass_get_node_as_texture (self,
vulkan: Add support for color matrix nodes @keyframes weee { 100% { filter: hue-rotate(1turn); } } .background { animation: linear infinite 3s weee; }
2016-12-31 13:14:26 +00:00
render,
uploader,
child,
Clip intermediate textures In some cases, we were creating gigantic intermediate textures only to clip out a small section afterwards (e.g. in the listbox example in gtk4-demo). This is wasteful if we apply effects on the texture, such as blur or color-matrix. So, clip the dimensions of the intermediate texture with the current clip. To make this feasible, we move the texture coordinate computation out of the pipeline setup functions into the node_as_texture function where this clipping happens. One extra complication we encounter is that the node might get clipped away completely. Since Vulkan does not allow to create empty images, we bail out in this case and not draw anything. With these changes, the listbox example in gtk4-demo goes from 32M pixels of intermediate texture to 320000.
2017-10-01 23:17:39 +00:00
&child->bounds,
clip,
&op->render.source_rect);
vulkan: Add support for color matrix nodes @keyframes weee { 100% { filter: hue-rotate(1turn); } } .background { animation: linear infinite 3s weee; }
2016-12-31 13:14:26 +00:00
}
break;
vulkan: Implement crossfade This is the first shader using two textures. It almost works.
2017-09-22 18:20:57 +00:00
case GSK_VULKAN_OP_CROSS_FADE:
{
Cosmetics Go back to a single GskVulkanOpRender that can handle 0, 1 or 2 sources.
2017-09-23 13:47:05 +00:00
GskRenderNode *start = gsk_cross_fade_node_get_start_child (op->render.node);
GskRenderNode *end = gsk_cross_fade_node_get_end_child (op->render.node);
Revise the coordinate handling one more time This makes the new reftests pass and hopefully does not break other things.
2017-10-08 22:36:57 +00:00
const graphene_rect_t *bounds = &op->render.node->bounds;
Cosmetics Go back to a single GskVulkanOpRender that can handle 0, 1 or 2 sources.
2017-09-23 13:47:05 +00:00
op->render.source = gsk_vulkan_render_pass_get_node_as_texture (self,
vulkan: Implement crossfade This is the first shader using two textures. It almost works.
2017-09-22 18:20:57 +00:00
render,
uploader,
Cosmetics Go back to a single GskVulkanOpRender that can handle 0, 1 or 2 sources.
2017-09-23 13:47:05 +00:00
start,
Revise the coordinate handling one more time This makes the new reftests pass and hopefully does not break other things.
2017-10-08 22:36:57 +00:00
&start->bounds,
Clip intermediate textures In some cases, we were creating gigantic intermediate textures only to clip out a small section afterwards (e.g. in the listbox example in gtk4-demo). This is wasteful if we apply effects on the texture, such as blur or color-matrix. So, clip the dimensions of the intermediate texture with the current clip. To make this feasible, we move the texture coordinate computation out of the pipeline setup functions into the node_as_texture function where this clipping happens. One extra complication we encounter is that the node might get clipped away completely. Since Vulkan does not allow to create empty images, we bail out in this case and not draw anything. With these changes, the listbox example in gtk4-demo goes from 32M pixels of intermediate texture to 320000.
2017-10-01 23:17:39 +00:00
clip,
&op->render.source_rect);
Revise the coordinate handling one more time This makes the new reftests pass and hopefully does not break other things.
2017-10-08 22:36:57 +00:00
op->render.source_rect.origin.x = (bounds->origin.x - start->bounds.origin.x)/start->bounds.size.width;
op->render.source_rect.origin.y = (bounds->origin.y - start->bounds.origin.y)/start->bounds.size.height;
op->render.source_rect.size.width = bounds->size.width / start->bounds.size.width;
op->render.source_rect.size.height = bounds->size.height / start->bounds.size.height;
Cosmetics Go back to a single GskVulkanOpRender that can handle 0, 1 or 2 sources.
2017-09-23 13:47:05 +00:00
op->render.source2 = gsk_vulkan_render_pass_get_node_as_texture (self,
render,
uploader,
end,
Revise the coordinate handling one more time This makes the new reftests pass and hopefully does not break other things.
2017-10-08 22:36:57 +00:00
&end->bounds,
Clip intermediate textures In some cases, we were creating gigantic intermediate textures only to clip out a small section afterwards (e.g. in the listbox example in gtk4-demo). This is wasteful if we apply effects on the texture, such as blur or color-matrix. So, clip the dimensions of the intermediate texture with the current clip. To make this feasible, we move the texture coordinate computation out of the pipeline setup functions into the node_as_texture function where this clipping happens. One extra complication we encounter is that the node might get clipped away completely. Since Vulkan does not allow to create empty images, we bail out in this case and not draw anything. With these changes, the listbox example in gtk4-demo goes from 32M pixels of intermediate texture to 320000.
2017-10-01 23:17:39 +00:00
clip,
&op->render.source2_rect);
Revise the coordinate handling one more time This makes the new reftests pass and hopefully does not break other things.
2017-10-08 22:36:57 +00:00
op->render.source2_rect.origin.x = (bounds->origin.x - end->bounds.origin.x)/end->bounds.size.width;
op->render.source2_rect.origin.y = (bounds->origin.y - end->bounds.origin.y)/end->bounds.size.height;
op->render.source2_rect.size.width = bounds->size.width / end->bounds.size.width;
op->render.source2_rect.size.height = bounds->size.height / end->bounds.size.height;
vulkan: Implement crossfade This is the first shader using two textures. It almost works.
2017-09-22 18:20:57 +00:00
}
break;
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
case GSK_VULKAN_OP_BLEND_MODE:
{
Cosmetics Go back to a single GskVulkanOpRender that can handle 0, 1 or 2 sources.
2017-09-23 13:47:05 +00:00
GskRenderNode *top = gsk_blend_node_get_top_child (op->render.node);
GskRenderNode *bottom = gsk_blend_node_get_bottom_child (op->render.node);
Revise coordinate handling for blend nodes This is the same change that was applied to cross-fade nodes.
2017-10-09 00:06:33 +00:00
const graphene_rect_t *bounds = &op->render.node->bounds;
Cosmetics Go back to a single GskVulkanOpRender that can handle 0, 1 or 2 sources.
2017-09-23 13:47:05 +00:00
op->render.source = gsk_vulkan_render_pass_get_node_as_texture (self,
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
render,
uploader,
Cosmetics Go back to a single GskVulkanOpRender that can handle 0, 1 or 2 sources.
2017-09-23 13:47:05 +00:00
top,
Revise coordinate handling for blend nodes This is the same change that was applied to cross-fade nodes.
2017-10-09 00:06:33 +00:00
&top->bounds,
Clip intermediate textures In some cases, we were creating gigantic intermediate textures only to clip out a small section afterwards (e.g. in the listbox example in gtk4-demo). This is wasteful if we apply effects on the texture, such as blur or color-matrix. So, clip the dimensions of the intermediate texture with the current clip. To make this feasible, we move the texture coordinate computation out of the pipeline setup functions into the node_as_texture function where this clipping happens. One extra complication we encounter is that the node might get clipped away completely. Since Vulkan does not allow to create empty images, we bail out in this case and not draw anything. With these changes, the listbox example in gtk4-demo goes from 32M pixels of intermediate texture to 320000.
2017-10-01 23:17:39 +00:00
clip,
&op->render.source_rect);
Revise coordinate handling for blend nodes This is the same change that was applied to cross-fade nodes.
2017-10-09 00:06:33 +00:00
op->render.source_rect.origin.x = (bounds->origin.x - top->bounds.origin.x)/top->bounds.size.width;
op->render.source_rect.origin.y = (bounds->origin.y - top->bounds.origin.y)/top->bounds.size.height;
op->render.source_rect.size.width = bounds->size.width / top->bounds.size.width;
op->render.source_rect.size.height = bounds->size.height / top->bounds.size.height;
Cosmetics Go back to a single GskVulkanOpRender that can handle 0, 1 or 2 sources.
2017-09-23 13:47:05 +00:00
op->render.source2 = gsk_vulkan_render_pass_get_node_as_texture (self,
render,
uploader,
bottom,
Revise coordinate handling for blend nodes This is the same change that was applied to cross-fade nodes.
2017-10-09 00:06:33 +00:00
&bottom->bounds,
Clip intermediate textures In some cases, we were creating gigantic intermediate textures only to clip out a small section afterwards (e.g. in the listbox example in gtk4-demo). This is wasteful if we apply effects on the texture, such as blur or color-matrix. So, clip the dimensions of the intermediate texture with the current clip. To make this feasible, we move the texture coordinate computation out of the pipeline setup functions into the node_as_texture function where this clipping happens. One extra complication we encounter is that the node might get clipped away completely. Since Vulkan does not allow to create empty images, we bail out in this case and not draw anything. With these changes, the listbox example in gtk4-demo goes from 32M pixels of intermediate texture to 320000.
2017-10-01 23:17:39 +00:00
clip,
&op->render.source2_rect);
Revise coordinate handling for blend nodes This is the same change that was applied to cross-fade nodes.
2017-10-09 00:06:33 +00:00
op->render.source2_rect.origin.x = (bounds->origin.x - bottom->bounds.origin.x)/bottom->bounds.size.width;
op->render.source2_rect.origin.y = (bounds->origin.y - bottom->bounds.origin.y)/bottom->bounds.size.height;
op->render.source2_rect.size.width = bounds->size.width / bottom->bounds.size.width;
op->render.source2_rect.size.height = bounds->size.height / bottom->bounds.size.height;
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
}
break;
Clip intermediate textures In some cases, we were creating gigantic intermediate textures only to clip out a small section afterwards (e.g. in the listbox example in gtk4-demo). This is wasteful if we apply effects on the texture, such as blur or color-matrix. So, clip the dimensions of the intermediate texture with the current clip. To make this feasible, we move the texture coordinate computation out of the pipeline setup functions into the node_as_texture function where this clipping happens. One extra complication we encounter is that the node might get clipped away completely. Since Vulkan does not allow to create empty images, we bail out in this case and not draw anything. With these changes, the listbox example in gtk4-demo goes from 32M pixels of intermediate texture to 320000.
2017-10-01 23:17:39 +00:00
case GSK_VULKAN_OP_PUSH_VERTEX_CONSTANTS:
clip = &op->constants.constants.clip;
break;
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
default:
g_assert_not_reached ();
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
case GSK_VULKAN_OP_COLOR:
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
case GSK_VULKAN_OP_LINEAR_GRADIENT:
vulkan: Add shader for border rendering
2017-01-10 13:59:20 +00:00
case GSK_VULKAN_OP_BORDER:
vulkan: Add support for unblurred box-shadow
2017-01-18 03:07:09 +00:00
case GSK_VULKAN_OP_INSET_SHADOW:
case GSK_VULKAN_OP_OUTSET_SHADOW:
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
break;
}
}
}
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
static gsize
vulkan: Move vertex data tracking to the pipeline subclass That way, different pipelines can draw different kinds of data.
2016-12-18 00:45:07 +00:00
gsk_vulkan_render_pass_count_vertex_data (GskVulkanRenderPass *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: Move vertex data tracking to the pipeline subclass That way, different pipelines can draw different kinds of data.
2016-12-18 00:45:07 +00:00
GskVulkanOp *op;
gsize n_bytes;
guint i;
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: Move vertex data tracking to the pipeline subclass That way, different pipelines can draw different kinds of data.
2016-12-18 00:45:07 +00:00
n_bytes = 0;
for (i = 0; i < self->render_ops->len; i++)
{
op = &g_array_index (self->render_ops, GskVulkanOp, i);
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: Move vertex data tracking to the pipeline subclass That way, different pipelines can draw different kinds of data.
2016-12-18 00:45:07 +00:00
switch (op->type)
{
case GSK_VULKAN_OP_FALLBACK:
gsk: Add GskVulkanClip This is now tracking the clips added by the clip nodes. If any particular node can't deal with a clip, it falls back to Cairo rendering. But if it can, it will render it directly.
2016-12-23 20:36:17 +00:00
case GSK_VULKAN_OP_FALLBACK_CLIP:
case GSK_VULKAN_OP_FALLBACK_ROUNDED_CLIP:
vulkan: Move vertex data tracking to the pipeline subclass That way, different pipelines can draw different kinds of data.
2016-12-18 00:45:07 +00:00
case GSK_VULKAN_OP_TEXTURE:
Support repeat nodes in vulkan We can use the texture pipeline for this, with a repeating sampler.
2017-09-30 02:41:00 +00:00
case GSK_VULKAN_OP_REPEAT:
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
op->render.vertex_count = gsk_vulkan_texture_pipeline_count_vertex_data (GSK_VULKAN_TEXTURE_PIPELINE (op->render.pipeline));
vulkan: Move vertex data tracking to the pipeline subclass That way, different pipelines can draw different kinds of data.
2016-12-18 00:45:07 +00:00
n_bytes += op->render.vertex_count;
break;
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
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
case GSK_VULKAN_OP_TEXT:
vulkan: Better glyph cache api Move the glyph caching api to something that can support using multiple textures. We now split the text render ops into multiple ops for different textures, and make each op render just a substring of the text node's glyph string.
2017-09-19 22:53:32 +00:00
op->text.vertex_count = gsk_vulkan_text_pipeline_count_vertex_data (GSK_VULKAN_TEXT_PIPELINE (op->text.pipeline),
op->text.num_glyphs);
n_bytes += op->text.vertex_count;
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
break;
case GSK_VULKAN_OP_COLOR_TEXT:
vulkan: Better glyph cache api Move the glyph caching api to something that can support using multiple textures. We now split the text render ops into multiple ops for different textures, and make each op render just a substring of the text node's glyph string.
2017-09-19 22:53:32 +00:00
op->text.vertex_count = gsk_vulkan_color_text_pipeline_count_vertex_data (GSK_VULKAN_COLOR_TEXT_PIPELINE (op->render.pipeline),
op->text.num_glyphs);
n_bytes += op->text.vertex_count;
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
break;
vulkan: Split color and blend pipelines
2016-12-18 01:18:01 +00:00
case GSK_VULKAN_OP_COLOR:
op->render.vertex_count = gsk_vulkan_color_pipeline_count_vertex_data (GSK_VULKAN_COLOR_PIPELINE (op->render.pipeline));
n_bytes += op->render.vertex_count;
break;
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
case GSK_VULKAN_OP_LINEAR_GRADIENT:
op->render.vertex_count = gsk_vulkan_linear_gradient_pipeline_count_vertex_data (GSK_VULKAN_LINEAR_GRADIENT_PIPELINE (op->render.pipeline));
n_bytes += op->render.vertex_count;
break;
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
case GSK_VULKAN_OP_OPACITY:
vulkan: Add support for color matrix nodes @keyframes weee { 100% { filter: hue-rotate(1turn); } } .background { animation: linear infinite 3s weee; }
2016-12-31 13:14:26 +00:00
case GSK_VULKAN_OP_COLOR_MATRIX:
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
op->render.vertex_count = gsk_vulkan_effect_pipeline_count_vertex_data (GSK_VULKAN_EFFECT_PIPELINE (op->render.pipeline));
n_bytes += op->render.vertex_count;
break;
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
case GSK_VULKAN_OP_BLUR:
op->render.vertex_count = gsk_vulkan_blur_pipeline_count_vertex_data (GSK_VULKAN_BLUR_PIPELINE (op->render.pipeline));
n_bytes += op->render.vertex_count;
break;
vulkan: Add shader for border rendering
2017-01-10 13:59:20 +00:00
case GSK_VULKAN_OP_BORDER:
op->render.vertex_count = gsk_vulkan_border_pipeline_count_vertex_data (GSK_VULKAN_BORDER_PIPELINE (op->render.pipeline));
n_bytes += op->render.vertex_count;
break;
vulkan: Add support for unblurred box-shadow
2017-01-18 03:07:09 +00:00
case GSK_VULKAN_OP_INSET_SHADOW:
case GSK_VULKAN_OP_OUTSET_SHADOW:
op->render.vertex_count = gsk_vulkan_box_shadow_pipeline_count_vertex_data (GSK_VULKAN_BOX_SHADOW_PIPELINE (op->render.pipeline));
n_bytes += op->render.vertex_count;
break;
vulkan: Implement crossfade This is the first shader using two textures. It almost works.
2017-09-22 18:20:57 +00:00
case GSK_VULKAN_OP_CROSS_FADE:
Cosmetics Go back to a single GskVulkanOpRender that can handle 0, 1 or 2 sources.
2017-09-23 13:47:05 +00:00
op->render.vertex_count = gsk_vulkan_cross_fade_pipeline_count_vertex_data (GSK_VULKAN_CROSS_FADE_PIPELINE (op->render.pipeline));
n_bytes += op->render.vertex_count;
vulkan: Implement crossfade This is the first shader using two textures. It almost works.
2017-09-22 18:20:57 +00:00
break;
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
case GSK_VULKAN_OP_BLEND_MODE:
Cosmetics Go back to a single GskVulkanOpRender that can handle 0, 1 or 2 sources.
2017-09-23 13:47:05 +00:00
op->render.vertex_count = gsk_vulkan_blend_mode_pipeline_count_vertex_data (GSK_VULKAN_BLEND_MODE_PIPELINE (op->render.pipeline));
n_bytes += op->render.vertex_count;
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
break;
vulkan: Move vertex data tracking to the pipeline subclass That way, different pipelines can draw different kinds of data.
2016-12-18 00:45:07 +00:00
default:
g_assert_not_reached ();
vulkan: Implement multiple render passes Whenever we need a node as a texture, we now start a new render pass that renders the node into a new intermediate texture, and set up a semaphore to make the current render pass wait for it. As part of this reorganization, much of the setup and drawing code moved from gskvulkanrender.c to gskvulkanrenderpass.c.
2017-09-28 00:56:01 +00:00
vulkan: Move vertex data tracking to the pipeline subclass That way, different pipelines can draw different kinds of data.
2016-12-18 00:45:07 +00:00
case GSK_VULKAN_OP_PUSH_VERTEX_CONSTANTS:
continue;
}
}
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: Move vertex data tracking to the pipeline subclass That way, different pipelines can draw different kinds of data.
2016-12-18 00:45:07 +00:00
return n_bytes;
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
static gsize
vulkan: Move vertex data tracking to the pipeline subclass That way, different pipelines can draw different kinds of data.
2016-12-18 00:45:07 +00:00
gsk_vulkan_render_pass_collect_vertex_data (GskVulkanRenderPass *self,
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
GskVulkanRender *render,
vulkan: Move vertex data tracking to the pipeline subclass That way, different pipelines can draw different kinds of data.
2016-12-18 00:45:07 +00:00
guchar *data,
gsize offset,
gsize total)
vulkan: Add GskVulkanRenderPass And move the actual rendering code there. A RenderPass is a collection of operations on the same target that get executed one after another. It roughly targets VkRenderPass or rather the subpasses of a VkRenderPass. For now, only the infrastructure is there. No real stuff is happening.
2016-12-08 12:26:36 +00:00
{
vulkan: Split render ops into seperate structs This makes it a lot clearer which members are relevant for each different operation.
2016-12-14 06:34:18 +00:00
GskVulkanOp *op;
vulkan: Move vertex data tracking to the pipeline subclass That way, different pipelines can draw different kinds of data.
2016-12-18 00:45:07 +00:00
gsize n_bytes;
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
guint i;
vulkan: Move vertex data tracking to the pipeline subclass That way, different pipelines can draw different kinds of data.
2016-12-18 00:45:07 +00:00
n_bytes = 0;
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
for (i = 0; i < self->render_ops->len; i++)
{
vulkan: Split render ops into seperate structs This makes it a lot clearer which members are relevant for each different operation.
2016-12-14 06:34:18 +00:00
op = &g_array_index (self->render_ops, GskVulkanOp, i);
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
switch (op->type)
{
case GSK_VULKAN_OP_FALLBACK:
gsk: Add GskVulkanClip This is now tracking the clips added by the clip nodes. If any particular node can't deal with a clip, it falls back to Cairo rendering. But if it can, it will render it directly.
2016-12-23 20:36:17 +00:00
case GSK_VULKAN_OP_FALLBACK_CLIP:
case GSK_VULKAN_OP_FALLBACK_ROUNDED_CLIP:
vulkan: Add more node operations Add SURFACE and TEXTURE operations. This way, we actually render more than one node every frame because not everything is a fallback node anymore that gets composited with its children into a cairo surface.
2016-12-09 04:59:19 +00:00
case GSK_VULKAN_OP_TEXTURE:
vulkan: Move vertex data tracking to the pipeline subclass That way, different pipelines can draw different kinds of data.
2016-12-18 00:45:07 +00:00
{
op->render.vertex_offset = offset + n_bytes;
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
gsk_vulkan_texture_pipeline_collect_vertex_data (GSK_VULKAN_TEXTURE_PIPELINE (op->render.pipeline),
Support repeat nodes in vulkan We can use the texture pipeline for this, with a repeating sampler.
2017-09-30 02:41:00 +00:00
data + n_bytes + offset,
&op->render.node->bounds,
Clip intermediate textures In some cases, we were creating gigantic intermediate textures only to clip out a small section afterwards (e.g. in the listbox example in gtk4-demo). This is wasteful if we apply effects on the texture, such as blur or color-matrix. So, clip the dimensions of the intermediate texture with the current clip. To make this feasible, we move the texture coordinate computation out of the pipeline setup functions into the node_as_texture function where this clipping happens. One extra complication we encounter is that the node might get clipped away completely. Since Vulkan does not allow to create empty images, we bail out in this case and not draw anything. With these changes, the listbox example in gtk4-demo goes from 32M pixels of intermediate texture to 320000.
2017-10-01 23:17:39 +00:00
&op->render.source_rect);
Support repeat nodes in vulkan We can use the texture pipeline for this, with a repeating sampler.
2017-09-30 02:41:00 +00:00
n_bytes += op->render.vertex_count;
}
break;
case GSK_VULKAN_OP_REPEAT:
{
op->render.vertex_offset = offset + n_bytes;
gsk_vulkan_texture_pipeline_collect_vertex_data (GSK_VULKAN_TEXTURE_PIPELINE (op->render.pipeline),
data + n_bytes + offset,
&op->render.node->bounds,
Clip intermediate textures In some cases, we were creating gigantic intermediate textures only to clip out a small section afterwards (e.g. in the listbox example in gtk4-demo). This is wasteful if we apply effects on the texture, such as blur or color-matrix. So, clip the dimensions of the intermediate texture with the current clip. To make this feasible, we move the texture coordinate computation out of the pipeline setup functions into the node_as_texture function where this clipping happens. One extra complication we encounter is that the node might get clipped away completely. Since Vulkan does not allow to create empty images, we bail out in this case and not draw anything. With these changes, the listbox example in gtk4-demo goes from 32M pixels of intermediate texture to 320000.
2017-10-01 23:17:39 +00:00
&op->render.source_rect);
vulkan: Move vertex data tracking to the pipeline subclass That way, different pipelines can draw different kinds of data.
2016-12-18 00:45:07 +00:00
n_bytes += op->render.vertex_count;
}
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
break;
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
case GSK_VULKAN_OP_TEXT:
{
vulkan: Better glyph cache api Move the glyph caching api to something that can support using multiple textures. We now split the text render ops into multiple ops for different textures, and make each op render just a substring of the text node's glyph string.
2017-09-19 22:53:32 +00:00
op->text.vertex_offset = offset + n_bytes;
gsk_vulkan_text_pipeline_collect_vertex_data (GSK_VULKAN_TEXT_PIPELINE (op->text.pipeline),
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
data + n_bytes + offset,
GSK_VULKAN_RENDERER (gsk_vulkan_render_get_renderer (render)),
vulkan: Better glyph cache api Move the glyph caching api to something that can support using multiple textures. We now split the text render ops into multiple ops for different textures, and make each op render just a substring of the text node's glyph string.
2017-09-19 22:53:32 +00:00
&op->text.node->bounds,
rendernode: Rename all gsk_render_node_peek_*() functions Those are getters, they should be gsk_render_node_get_*() functions.
2020-11-16 23:59:36 +00:00
(PangoFont *)gsk_text_node_get_font (op->text.node),
gsk: Make text nodes more compact The copy of the PangoGlyphString we do here was showing up in some profiles. To avoid it, allocate the PangoGlyphInfo array as part of the node itself. Update all callers to deal with the slight api change required for this.
2017-10-27 21:13:40 +00:00
gsk_text_node_get_num_glyphs (op->text.node),
rendernode: Rename all gsk_render_node_peek_*() functions Those are getters, they should be gsk_render_node_get_*() functions.
2020-11-16 23:59:36 +00:00
gsk_text_node_get_glyphs (op->text.node, NULL),
gsk_text_node_get_color (op->text.node),
rendernode: Take a graphene_point_t for the offset ... instead of 2 floats.
2019-05-19 02:08:29 +00:00
gsk_text_node_get_offset (op->text.node),
vulkan: Better glyph cache api Move the glyph caching api to something that can support using multiple textures. We now split the text render ops into multiple ops for different textures, and make each op render just a substring of the text node's glyph string.
2017-09-19 22:53:32 +00:00
op->text.start_glyph,
gsk: Scale glyphs in the glyph cache Pass a scale factor when caching glyphs or looking them up in the cache. The glyphs in the cache are rendered with subpixel precision determined by the scale. Update all callers to pass a scale factor according to the window scale. This lets us render crisp glyphs on hidpi systems.
2017-10-28 17:13:31 +00:00
op->text.num_glyphs,
op->text.scale);
vulkan: Better glyph cache api Move the glyph caching api to something that can support using multiple textures. We now split the text render ops into multiple ops for different textures, and make each op render just a substring of the text node's glyph string.
2017-09-19 22:53:32 +00:00
n_bytes += op->text.vertex_count;
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
}
break;
case GSK_VULKAN_OP_COLOR_TEXT:
{
vulkan: Better glyph cache api Move the glyph caching api to something that can support using multiple textures. We now split the text render ops into multiple ops for different textures, and make each op render just a substring of the text node's glyph string.
2017-09-19 22:53:32 +00:00
op->text.vertex_offset = offset + n_bytes;
gsk_vulkan_color_text_pipeline_collect_vertex_data (GSK_VULKAN_COLOR_TEXT_PIPELINE (op->text.pipeline),
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
data + n_bytes + offset,
GSK_VULKAN_RENDERER (gsk_vulkan_render_get_renderer (render)),
vulkan: Better glyph cache api Move the glyph caching api to something that can support using multiple textures. We now split the text render ops into multiple ops for different textures, and make each op render just a substring of the text node's glyph string.
2017-09-19 22:53:32 +00:00
&op->text.node->bounds,
rendernode: Rename all gsk_render_node_peek_*() functions Those are getters, they should be gsk_render_node_get_*() functions.
2020-11-16 23:59:36 +00:00
(PangoFont *)gsk_text_node_get_font (op->text.node),
gsk: Make text nodes more compact The copy of the PangoGlyphString we do here was showing up in some profiles. To avoid it, allocate the PangoGlyphInfo array as part of the node itself. Update all callers to deal with the slight api change required for this.
2017-10-27 21:13:40 +00:00
gsk_text_node_get_num_glyphs (op->text.node),
rendernode: Rename all gsk_render_node_peek_*() functions Those are getters, they should be gsk_render_node_get_*() functions.
2020-11-16 23:59:36 +00:00
gsk_text_node_get_glyphs (op->text.node, NULL),
rendernode: Take a graphene_point_t for the offset ... instead of 2 floats.
2019-05-19 02:08:29 +00:00
gsk_text_node_get_offset (op->text.node),
vulkan: Better glyph cache api Move the glyph caching api to something that can support using multiple textures. We now split the text render ops into multiple ops for different textures, and make each op render just a substring of the text node's glyph string.
2017-09-19 22:53:32 +00:00
op->text.start_glyph,
gsk: Scale glyphs in the glyph cache Pass a scale factor when caching glyphs or looking them up in the cache. The glyphs in the cache are rendered with subpixel precision determined by the scale. Update all callers to pass a scale factor according to the window scale. This lets us render crisp glyphs on hidpi systems.
2017-10-28 17:13:31 +00:00
op->text.num_glyphs,
op->text.scale);
vulkan: Better glyph cache api Move the glyph caching api to something that can support using multiple textures. We now split the text render ops into multiple ops for different textures, and make each op render just a substring of the text node's glyph string.
2017-09-19 22:53:32 +00:00
n_bytes += op->text.vertex_count;
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
}
break;
vulkan: Split color and blend pipelines
2016-12-18 01:18:01 +00:00
case GSK_VULKAN_OP_COLOR:
{
op->render.vertex_offset = offset + n_bytes;
gsk_vulkan_color_pipeline_collect_vertex_data (GSK_VULKAN_COLOR_PIPELINE (op->render.pipeline),
data + n_bytes + offset,
gsk: Fix build of 22110ef5a480fbddf9d20f510a64f4524a52718f
2016-12-21 17:15:50 +00:00
&op->render.node->bounds,
rendernode: Rename all gsk_render_node_peek_*() functions Those are getters, they should be gsk_render_node_get_*() functions.
2020-11-16 23:59:36 +00:00
gsk_color_node_get_color (op->render.node));
vulkan: Split color and blend pipelines
2016-12-18 01:18:01 +00:00
n_bytes += op->render.vertex_count;
}
break;
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
case GSK_VULKAN_OP_LINEAR_GRADIENT:
{
op->render.vertex_offset = offset + n_bytes;
gsk_vulkan_linear_gradient_pipeline_collect_vertex_data (GSK_VULKAN_LINEAR_GRADIENT_PIPELINE (op->render.pipeline),
data + n_bytes + offset,
&op->render.node->bounds,
rendernode: Rename all gsk_render_node_peek_*() functions Those are getters, they should be gsk_render_node_get_*() functions.
2020-11-16 23:59:36 +00:00
gsk_linear_gradient_node_get_start (op->render.node),
gsk_linear_gradient_node_get_end (op->render.node),
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
gsk_render_node_get_node_type (op->render.node) == GSK_REPEATING_LINEAR_GRADIENT_NODE,
gsk_linear_gradient_node_get_n_color_stops (op->render.node),
rendernode: Rename all gsk_render_node_peek_*() functions Those are getters, they should be gsk_render_node_get_*() functions.
2020-11-16 23:59:36 +00:00
gsk_linear_gradient_node_get_color_stops (op->render.node, NULL));
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
n_bytes += op->render.vertex_count;
}
break;
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
case GSK_VULKAN_OP_OPACITY:
{
vulkan: Make the effect renderer take matrix + offset This is in preparation for the new color matrix node. I don't think keeping support for a separate opacity shader is worth it.
2016-12-31 12:24:21 +00:00
graphene_matrix_t color_matrix;
graphene_vec4_t color_offset;
Clip intermediate textures In some cases, we were creating gigantic intermediate textures only to clip out a small section afterwards (e.g. in the listbox example in gtk4-demo). This is wasteful if we apply effects on the texture, such as blur or color-matrix. So, clip the dimensions of the intermediate texture with the current clip. To make this feasible, we move the texture coordinate computation out of the pipeline setup functions into the node_as_texture function where this clipping happens. One extra complication we encounter is that the node might get clipped away completely. Since Vulkan does not allow to create empty images, we bail out in this case and not draw anything. With these changes, the listbox example in gtk4-demo goes from 32M pixels of intermediate texture to 320000.
2017-10-01 23:17:39 +00:00
vulkan: Make the effect renderer take matrix + offset This is in preparation for the new color matrix node. I don't think keeping support for a separate opacity shader is worth it.
2016-12-31 12:24:21 +00:00
graphene_matrix_init_from_float (&color_matrix,
(float[16]) {
Clip intermediate textures In some cases, we were creating gigantic intermediate textures only to clip out a small section afterwards (e.g. in the listbox example in gtk4-demo). This is wasteful if we apply effects on the texture, such as blur or color-matrix. So, clip the dimensions of the intermediate texture with the current clip. To make this feasible, we move the texture coordinate computation out of the pipeline setup functions into the node_as_texture function where this clipping happens. One extra complication we encounter is that the node might get clipped away completely. Since Vulkan does not allow to create empty images, we bail out in this case and not draw anything. With these changes, the listbox example in gtk4-demo goes from 32M pixels of intermediate texture to 320000.
2017-10-01 23:17:39 +00:00
1.0, 0.0, 0.0, 0.0,
0.0, 1.0, 0.0, 0.0,
0.0, 0.0, 1.0, 0.0,
vulkan: Make the effect renderer take matrix + offset This is in preparation for the new color matrix node. I don't think keeping support for a separate opacity shader is worth it.
2016-12-31 12:24:21 +00:00
0.0, 0.0, 0.0, gsk_opacity_node_get_opacity (op->render.node)
});
graphene_vec4_init (&color_offset, 0.0, 0.0, 0.0, 0.0);
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
op->render.vertex_offset = offset + n_bytes;
Clip intermediate textures In some cases, we were creating gigantic intermediate textures only to clip out a small section afterwards (e.g. in the listbox example in gtk4-demo). This is wasteful if we apply effects on the texture, such as blur or color-matrix. So, clip the dimensions of the intermediate texture with the current clip. To make this feasible, we move the texture coordinate computation out of the pipeline setup functions into the node_as_texture function where this clipping happens. One extra complication we encounter is that the node might get clipped away completely. Since Vulkan does not allow to create empty images, we bail out in this case and not draw anything. With these changes, the listbox example in gtk4-demo goes from 32M pixels of intermediate texture to 320000.
2017-10-01 23:17:39 +00:00
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
gsk_vulkan_effect_pipeline_collect_vertex_data (GSK_VULKAN_EFFECT_PIPELINE (op->render.pipeline),
data + n_bytes + offset,
&op->render.node->bounds,
Clip intermediate textures In some cases, we were creating gigantic intermediate textures only to clip out a small section afterwards (e.g. in the listbox example in gtk4-demo). This is wasteful if we apply effects on the texture, such as blur or color-matrix. So, clip the dimensions of the intermediate texture with the current clip. To make this feasible, we move the texture coordinate computation out of the pipeline setup functions into the node_as_texture function where this clipping happens. One extra complication we encounter is that the node might get clipped away completely. Since Vulkan does not allow to create empty images, we bail out in this case and not draw anything. With these changes, the listbox example in gtk4-demo goes from 32M pixels of intermediate texture to 320000.
2017-10-01 23:17:39 +00:00
&op->render.source_rect,
vulkan: Make the effect renderer take matrix + offset This is in preparation for the new color matrix node. I don't think keeping support for a separate opacity shader is worth it.
2016-12-31 12:24:21 +00:00
&color_matrix,
&color_offset);
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
n_bytes += op->render.vertex_count;
}
break;
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
case GSK_VULKAN_OP_BLUR:
{
op->render.vertex_offset = offset + n_bytes;
gsk_vulkan_blur_pipeline_collect_vertex_data (GSK_VULKAN_BLUR_PIPELINE (op->render.pipeline),
data + n_bytes + offset,
&op->render.node->bounds,
Clip intermediate textures In some cases, we were creating gigantic intermediate textures only to clip out a small section afterwards (e.g. in the listbox example in gtk4-demo). This is wasteful if we apply effects on the texture, such as blur or color-matrix. So, clip the dimensions of the intermediate texture with the current clip. To make this feasible, we move the texture coordinate computation out of the pipeline setup functions into the node_as_texture function where this clipping happens. One extra complication we encounter is that the node might get clipped away completely. Since Vulkan does not allow to create empty images, we bail out in this case and not draw anything. With these changes, the listbox example in gtk4-demo goes from 32M pixels of intermediate texture to 320000.
2017-10-01 23:17:39 +00:00
&op->render.source_rect,
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
gsk_blur_node_get_radius (op->render.node));
n_bytes += op->render.vertex_count;
}
break;
vulkan: Add support for color matrix nodes @keyframes weee { 100% { filter: hue-rotate(1turn); } } .background { animation: linear infinite 3s weee; }
2016-12-31 13:14:26 +00:00
case GSK_VULKAN_OP_COLOR_MATRIX:
{
op->render.vertex_offset = offset + n_bytes;
gsk_vulkan_effect_pipeline_collect_vertex_data (GSK_VULKAN_EFFECT_PIPELINE (op->render.pipeline),
data + n_bytes + offset,
&op->render.node->bounds,
Clip intermediate textures In some cases, we were creating gigantic intermediate textures only to clip out a small section afterwards (e.g. in the listbox example in gtk4-demo). This is wasteful if we apply effects on the texture, such as blur or color-matrix. So, clip the dimensions of the intermediate texture with the current clip. To make this feasible, we move the texture coordinate computation out of the pipeline setup functions into the node_as_texture function where this clipping happens. One extra complication we encounter is that the node might get clipped away completely. Since Vulkan does not allow to create empty images, we bail out in this case and not draw anything. With these changes, the listbox example in gtk4-demo goes from 32M pixels of intermediate texture to 320000.
2017-10-01 23:17:39 +00:00
&op->render.source_rect,
rendernode: Rename all gsk_render_node_peek_*() functions Those are getters, they should be gsk_render_node_get_*() functions.
2020-11-16 23:59:36 +00:00
gsk_color_matrix_node_get_color_matrix (op->render.node),
gsk_color_matrix_node_get_color_offset (op->render.node));
vulkan: Add support for color matrix nodes @keyframes weee { 100% { filter: hue-rotate(1turn); } } .background { animation: linear infinite 3s weee; }
2016-12-31 13:14:26 +00:00
n_bytes += op->render.vertex_count;
}
break;
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
vulkan: Add shader for border rendering
2017-01-10 13:59:20 +00:00
case GSK_VULKAN_OP_BORDER:
{
op->render.vertex_offset = offset + n_bytes;
gsk_vulkan_border_pipeline_collect_vertex_data (GSK_VULKAN_BORDER_PIPELINE (op->render.pipeline),
data + n_bytes + offset,
rendernode: Rename all gsk_render_node_peek_*() functions Those are getters, they should be gsk_render_node_get_*() functions.
2020-11-16 23:59:36 +00:00
gsk_border_node_get_outline (op->render.node),
gsk_border_node_get_widths (op->render.node),
gsk_border_node_get_colors (op->render.node));
vulkan: Add shader for border rendering
2017-01-10 13:59:20 +00:00
n_bytes += op->render.vertex_count;
}
break;
vulkan: Add support for unblurred box-shadow
2017-01-18 03:07:09 +00:00
case GSK_VULKAN_OP_INSET_SHADOW:
{
op->render.vertex_offset = offset + n_bytes;
gsk_vulkan_box_shadow_pipeline_collect_vertex_data (GSK_VULKAN_BOX_SHADOW_PIPELINE (op->render.pipeline),
data + n_bytes + offset,
rendernode: Rename all gsk_render_node_peek_*() functions Those are getters, they should be gsk_render_node_get_*() functions.
2020-11-16 23:59:36 +00:00
gsk_inset_shadow_node_get_outline (op->render.node),
gsk_inset_shadow_node_get_color (op->render.node),
vulkan: Add support for unblurred box-shadow
2017-01-18 03:07:09 +00:00
gsk_inset_shadow_node_get_dx (op->render.node),
gsk_inset_shadow_node_get_dy (op->render.node),
gsk_inset_shadow_node_get_spread (op->render.node),
gsk_inset_shadow_node_get_blur_radius (op->render.node));
n_bytes += op->render.vertex_count;
}
break;
case GSK_VULKAN_OP_OUTSET_SHADOW:
{
op->render.vertex_offset = offset + n_bytes;
gsk_vulkan_box_shadow_pipeline_collect_vertex_data (GSK_VULKAN_BOX_SHADOW_PIPELINE (op->render.pipeline),
data + n_bytes + offset,
rendernode: Rename all gsk_render_node_peek_*() functions Those are getters, they should be gsk_render_node_get_*() functions.
2020-11-16 23:59:36 +00:00
gsk_outset_shadow_node_get_outline (op->render.node),
gsk_outset_shadow_node_get_color (op->render.node),
vulkan: Add support for unblurred box-shadow
2017-01-18 03:07:09 +00:00
gsk_outset_shadow_node_get_dx (op->render.node),
gsk_outset_shadow_node_get_dy (op->render.node),
gsk_outset_shadow_node_get_spread (op->render.node),
gsk_outset_shadow_node_get_blur_radius (op->render.node));
n_bytes += op->render.vertex_count;
}
break;
vulkan: Implement crossfade This is the first shader using two textures. It almost works.
2017-09-22 18:20:57 +00:00
case GSK_VULKAN_OP_CROSS_FADE:
{
Cosmetics Go back to a single GskVulkanOpRender that can handle 0, 1 or 2 sources.
2017-09-23 13:47:05 +00:00
op->render.vertex_offset = offset + n_bytes;
gsk_vulkan_cross_fade_pipeline_collect_vertex_data (GSK_VULKAN_CROSS_FADE_PIPELINE (op->render.pipeline),
vulkan: Implement crossfade This is the first shader using two textures. It almost works.
2017-09-22 18:20:57 +00:00
data + n_bytes + offset,
Cosmetics Go back to a single GskVulkanOpRender that can handle 0, 1 or 2 sources.
2017-09-23 13:47:05 +00:00
&op->render.node->bounds,
Clip intermediate textures In some cases, we were creating gigantic intermediate textures only to clip out a small section afterwards (e.g. in the listbox example in gtk4-demo). This is wasteful if we apply effects on the texture, such as blur or color-matrix. So, clip the dimensions of the intermediate texture with the current clip. To make this feasible, we move the texture coordinate computation out of the pipeline setup functions into the node_as_texture function where this clipping happens. One extra complication we encounter is that the node might get clipped away completely. Since Vulkan does not allow to create empty images, we bail out in this case and not draw anything. With these changes, the listbox example in gtk4-demo goes from 32M pixels of intermediate texture to 320000.
2017-10-01 23:17:39 +00:00
&op->render.source_rect,
&op->render.source2_rect,
Cosmetics Go back to a single GskVulkanOpRender that can handle 0, 1 or 2 sources.
2017-09-23 13:47:05 +00:00
gsk_cross_fade_node_get_progress (op->render.node));
n_bytes += op->render.vertex_count;
vulkan: Implement crossfade This is the first shader using two textures. It almost works.
2017-09-22 18:20:57 +00:00
}
break;
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
case GSK_VULKAN_OP_BLEND_MODE:
{
Cosmetics Go back to a single GskVulkanOpRender that can handle 0, 1 or 2 sources.
2017-09-23 13:47:05 +00:00
op->render.vertex_offset = offset + n_bytes;
gsk_vulkan_blend_mode_pipeline_collect_vertex_data (GSK_VULKAN_BLEND_MODE_PIPELINE (op->render.pipeline),
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
data + n_bytes + offset,
Cosmetics Go back to a single GskVulkanOpRender that can handle 0, 1 or 2 sources.
2017-09-23 13:47:05 +00:00
&op->render.node->bounds,
Clip intermediate textures In some cases, we were creating gigantic intermediate textures only to clip out a small section afterwards (e.g. in the listbox example in gtk4-demo). This is wasteful if we apply effects on the texture, such as blur or color-matrix. So, clip the dimensions of the intermediate texture with the current clip. To make this feasible, we move the texture coordinate computation out of the pipeline setup functions into the node_as_texture function where this clipping happens. One extra complication we encounter is that the node might get clipped away completely. Since Vulkan does not allow to create empty images, we bail out in this case and not draw anything. With these changes, the listbox example in gtk4-demo goes from 32M pixels of intermediate texture to 320000.
2017-10-01 23:17:39 +00:00
&op->render.source_rect,
&op->render.source2_rect,
Cosmetics Go back to a single GskVulkanOpRender that can handle 0, 1 or 2 sources.
2017-09-23 13:47:05 +00:00
gsk_blend_node_get_blend_mode (op->render.node));
n_bytes += op->render.vertex_count;
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
}
break;
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
default:
g_assert_not_reached ();
vulkan: Add infrastructure for push constants THe code includes fragment push constants for colors, but that code is so far unused.
2016-12-14 06:21:21 +00:00
case GSK_VULKAN_OP_PUSH_VERTEX_CONSTANTS:
vulkan: Split render ops into seperate structs This makes it a lot clearer which members are relevant for each different operation.
2016-12-14 06:34:18 +00:00
continue;
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: Move vertex data tracking to the pipeline subclass That way, different pipelines can draw different kinds of data.
2016-12-18 00:45:07 +00:00
g_assert (n_bytes + offset <= total);
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: Move vertex data tracking to the pipeline subclass That way, different pipelines can draw different kinds of data.
2016-12-18 00:45:07 +00:00
return n_bytes;
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
static GskVulkanBuffer *
Add an api to get the vertex data for a render pass
2017-09-28 00:55:14 +00:00
gsk_vulkan_render_pass_get_vertex_data (GskVulkanRenderPass *self,
GskVulkanRender *render)
{
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
if (self->vertex_data == NULL)
{
gsize n_bytes;
guchar *data;
n_bytes = gsk_vulkan_render_pass_count_vertex_data (self);
self->vertex_data = gsk_vulkan_buffer_new (self->vulkan, n_bytes);
data = gsk_vulkan_buffer_map (self->vertex_data);
gsk_vulkan_render_pass_collect_vertex_data (self, render, data, 0, n_bytes);
gsk_vulkan_buffer_unmap (self->vertex_data);
}
Add an api to get the vertex data for a render pass
2017-09-28 00:55: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
return self->vertex_data;
}
Add an api to get the vertex data for a render pass
2017-09-28 00:55: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
gsize
gsk_vulkan_render_pass_get_wait_semaphores (GskVulkanRenderPass *self,
VkSemaphore **semaphores)
{
*semaphores = (VkSemaphore *)self->wait_semaphores->data;
return self->wait_semaphores->len;
}
Add an api to get the vertex data for a render pass
2017-09-28 00:55: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
gsize
gsk_vulkan_render_pass_get_signal_semaphores (GskVulkanRenderPass *self,
VkSemaphore **semaphores)
{
*semaphores = (VkSemaphore *)&self->signal_semaphore;
return self->signal_semaphore != VK_NULL_HANDLE ? 1 : 0;
Add an api to get the vertex data for a render pass
2017-09-28 00:55:14 +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
void
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
gsk_vulkan_render_pass_reserve_descriptor_sets (GskVulkanRenderPass *self,
GskVulkanRender *render)
vulkan: Add GskVulkanRenderPass And move the actual rendering code there. A RenderPass is a collection of operations on the same target that get executed one after another. It roughly targets VkRenderPass or rather the subpasses of a VkRenderPass. For now, only the infrastructure is there. No real stuff is happening.
2016-12-08 12:26:36 +00:00
{
vulkan: Split render ops into seperate structs This makes it a lot clearer which members are relevant for each different operation.
2016-12-14 06:34:18 +00:00
GskVulkanOp *op;
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
guint i;
for (i = 0; i < self->render_ops->len; i++)
{
vulkan: Split render ops into seperate structs This makes it a lot clearer which members are relevant for each different operation.
2016-12-14 06:34:18 +00:00
op = &g_array_index (self->render_ops, GskVulkanOp, i);
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
switch (op->type)
{
case GSK_VULKAN_OP_FALLBACK:
gsk: Add GskVulkanClip This is now tracking the clips added by the clip nodes. If any particular node can't deal with a clip, it falls back to Cairo rendering. But if it can, it will render it directly.
2016-12-23 20:36:17 +00:00
case GSK_VULKAN_OP_FALLBACK_CLIP:
case GSK_VULKAN_OP_FALLBACK_ROUNDED_CLIP:
vulkan: Add more node operations Add SURFACE and TEXTURE operations. This way, we actually render more than one node every frame because not everything is a fallback node anymore that gets composited with its children into a cairo surface.
2016-12-09 04:59:19 +00:00
case GSK_VULKAN_OP_TEXTURE:
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
case GSK_VULKAN_OP_OPACITY:
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
case GSK_VULKAN_OP_BLUR:
vulkan: Add support for color matrix nodes @keyframes weee { 100% { filter: hue-rotate(1turn); } } .background { animation: linear infinite 3s weee; }
2016-12-31 13:14:26 +00:00
case GSK_VULKAN_OP_COLOR_MATRIX:
Clip intermediate textures In some cases, we were creating gigantic intermediate textures only to clip out a small section afterwards (e.g. in the listbox example in gtk4-demo). This is wasteful if we apply effects on the texture, such as blur or color-matrix. So, clip the dimensions of the intermediate texture with the current clip. To make this feasible, we move the texture coordinate computation out of the pipeline setup functions into the node_as_texture function where this clipping happens. One extra complication we encounter is that the node might get clipped away completely. Since Vulkan does not allow to create empty images, we bail out in this case and not draw anything. With these changes, the listbox example in gtk4-demo goes from 32M pixels of intermediate texture to 320000.
2017-10-01 23:17:39 +00:00
if (op->render.source)
op->render.descriptor_set_index = gsk_vulkan_render_reserve_descriptor_set (render, op->render.source, FALSE);
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
break;
Support repeat nodes in vulkan We can use the texture pipeline for this, with a repeating sampler.
2017-09-30 02:41:00 +00:00
case GSK_VULKAN_OP_REPEAT:
Clip intermediate textures In some cases, we were creating gigantic intermediate textures only to clip out a small section afterwards (e.g. in the listbox example in gtk4-demo). This is wasteful if we apply effects on the texture, such as blur or color-matrix. So, clip the dimensions of the intermediate texture with the current clip. To make this feasible, we move the texture coordinate computation out of the pipeline setup functions into the node_as_texture function where this clipping happens. One extra complication we encounter is that the node might get clipped away completely. Since Vulkan does not allow to create empty images, we bail out in this case and not draw anything. With these changes, the listbox example in gtk4-demo goes from 32M pixels of intermediate texture to 320000.
2017-10-01 23:17:39 +00:00
if (op->render.source)
op->render.descriptor_set_index = gsk_vulkan_render_reserve_descriptor_set (render, op->render.source, TRUE);
Support repeat nodes in vulkan We can use the texture pipeline for this, with a repeating sampler.
2017-09-30 02:41:00 +00:00
break;
vulkan: Better glyph cache api Move the glyph caching api to something that can support using multiple textures. We now split the text render ops into multiple ops for different textures, and make each op render just a substring of the text node's glyph string.
2017-09-19 22:53:32 +00:00
case GSK_VULKAN_OP_TEXT:
case GSK_VULKAN_OP_COLOR_TEXT:
vulkan: Add a repeating sampler None of the render ops use it, yet.
2017-09-30 03:01:34 +00:00
op->text.descriptor_set_index = gsk_vulkan_render_reserve_descriptor_set (render, op->text.source, FALSE);
vulkan: Better glyph cache api Move the glyph caching api to something that can support using multiple textures. We now split the text render ops into multiple ops for different textures, and make each op render just a substring of the text node's glyph string.
2017-09-19 22:53:32 +00:00
break;
vulkan: Implement crossfade This is the first shader using two textures. It almost works.
2017-09-22 18:20:57 +00:00
case GSK_VULKAN_OP_CROSS_FADE:
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
case GSK_VULKAN_OP_BLEND_MODE:
Clip intermediate textures In some cases, we were creating gigantic intermediate textures only to clip out a small section afterwards (e.g. in the listbox example in gtk4-demo). This is wasteful if we apply effects on the texture, such as blur or color-matrix. So, clip the dimensions of the intermediate texture with the current clip. To make this feasible, we move the texture coordinate computation out of the pipeline setup functions into the node_as_texture function where this clipping happens. One extra complication we encounter is that the node might get clipped away completely. Since Vulkan does not allow to create empty images, we bail out in this case and not draw anything. With these changes, the listbox example in gtk4-demo goes from 32M pixels of intermediate texture to 320000.
2017-10-01 23:17:39 +00:00
if (op->render.source && op->render.source2)
{
op->render.descriptor_set_index = gsk_vulkan_render_reserve_descriptor_set (render, op->render.source, FALSE);
op->render.descriptor_set_index2 = gsk_vulkan_render_reserve_descriptor_set (render, op->render.source2, FALSE);
}
vulkan: Implement crossfade This is the first shader using two textures. It almost works.
2017-09-22 18:20:57 +00:00
break;
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
default:
g_assert_not_reached ();
vulkan: Implement multiple render passes Whenever we need a node as a texture, we now start a new render pass that renders the node into a new intermediate texture, and set up a semaphore to make the current render pass wait for it. As part of this reorganization, much of the setup and drawing code moved from gskvulkanrender.c to gskvulkanrenderpass.c.
2017-09-28 00:56:01 +00:00
vulkan: Add infrastructure for multiple pipelines And use it to draw solid colors with a 2nd pipeline.
2016-12-14 08:40:15 +00:00
case GSK_VULKAN_OP_COLOR:
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
case GSK_VULKAN_OP_LINEAR_GRADIENT:
vulkan: Add infrastructure for push constants THe code includes fragment push constants for colors, but that code is so far unused.
2016-12-14 06:21:21 +00:00
case GSK_VULKAN_OP_PUSH_VERTEX_CONSTANTS:
vulkan: Add shader for border rendering
2017-01-10 13:59:20 +00:00
case GSK_VULKAN_OP_BORDER:
vulkan: Add support for unblurred box-shadow
2017-01-18 03:07:09 +00:00
case GSK_VULKAN_OP_INSET_SHADOW:
case GSK_VULKAN_OP_OUTSET_SHADOW:
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
break;
}
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
static void
gsk_vulkan_render_pass_draw_rect (GskVulkanRenderPass *self,
GskVulkanRender *render,
guint layout_count,
VkPipelineLayout *pipeline_layout,
VkCommandBuffer command_buffer)
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 *current_pipeline = NULL;
vulkan: Move vertex data tracking to the pipeline subclass That way, different pipelines can draw different kinds of data.
2016-12-18 00:45:07 +00:00
gsize current_draw_index = 0;
vulkan: Split render ops into seperate structs This makes it a lot clearer which members are relevant for each different operation.
2016-12-14 06:34:18 +00:00
GskVulkanOp *op;
vulkan: Try combining draw calls This gives a 5-7% speedup in the case where we're just drawing N colors and nothing else. So it;s not tremendously useful, but noticeable.
2016-12-23 21:19:56 +00:00
guint i, step;
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
GskVulkanBuffer *vertex_buffer;
vertex_buffer = gsk_vulkan_render_pass_get_vertex_data (self, render);
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: Try combining draw calls This gives a 5-7% speedup in the case where we're just drawing N colors and nothing else. So it;s not tremendously useful, but noticeable.
2016-12-23 21:19:56 +00:00
for (i = 0; i < self->render_ops->len; i += step)
vulkan: Add GskVulkanRenderPass And move the actual rendering code there. A RenderPass is a collection of operations on the same target that get executed one after another. It roughly targets VkRenderPass or rather the subpasses of a VkRenderPass. For now, only the infrastructure is there. No real stuff is happening.
2016-12-08 12:26:36 +00:00
{
vulkan: Split render ops into seperate structs This makes it a lot clearer which members are relevant for each different operation.
2016-12-14 06:34:18 +00:00
op = &g_array_index (self->render_ops, GskVulkanOp, i);
vulkan: Try combining draw calls This gives a 5-7% speedup in the case where we're just drawing N colors and nothing else. So it;s not tremendously useful, but noticeable.
2016-12-23 21:19:56 +00:00
step = 1;
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: gsk_render_node_set_transform() => GskTransformNode Instead of having a setter for the transform, have a GskTransformNode. Most of the oprations that GTK does do not require a transform, so it doesn't make sense to have it as a primary attribute. Also, changing the transform requires updating the uniforms of the GL renderer, so we're happy if we can avoid that.
2016-12-12 23:11:06 +00:00
switch (op->type)
{
case GSK_VULKAN_OP_FALLBACK:
gsk: Add GskVulkanClip This is now tracking the clips added by the clip nodes. If any particular node can't deal with a clip, it falls back to Cairo rendering. But if it can, it will render it directly.
2016-12-23 20:36:17 +00:00
case GSK_VULKAN_OP_FALLBACK_CLIP:
case GSK_VULKAN_OP_FALLBACK_ROUNDED_CLIP:
gsk: gsk_render_node_set_transform() => GskTransformNode Instead of having a setter for the transform, have a GskTransformNode. Most of the oprations that GTK does do not require a transform, so it doesn't make sense to have it as a primary attribute. Also, changing the transform requires updating the uniforms of the GL renderer, so we're happy if we can avoid that.
2016-12-12 23:11:06 +00:00
case GSK_VULKAN_OP_TEXTURE:
Support repeat nodes in vulkan We can use the texture pipeline for this, with a repeating sampler.
2017-09-30 02:41:00 +00:00
case GSK_VULKAN_OP_REPEAT:
Clip intermediate textures In some cases, we were creating gigantic intermediate textures only to clip out a small section afterwards (e.g. in the listbox example in gtk4-demo). This is wasteful if we apply effects on the texture, such as blur or color-matrix. So, clip the dimensions of the intermediate texture with the current clip. To make this feasible, we move the texture coordinate computation out of the pipeline setup functions into the node_as_texture function where this clipping happens. One extra complication we encounter is that the node might get clipped away completely. Since Vulkan does not allow to create empty images, we bail out in this case and not draw anything. With these changes, the listbox example in gtk4-demo goes from 32M pixels of intermediate texture to 320000.
2017-10-01 23:17:39 +00:00
if (!op->render.source)
continue;
vulkan: Split color and blend pipelines
2016-12-18 01:18:01 +00:00
if (current_pipeline != op->render.pipeline)
{
current_pipeline = op->render.pipeline;
vkCmdBindPipeline (command_buffer,
VK_PIPELINE_BIND_POINT_GRAPHICS,
gsk_vulkan_pipeline_get_pipeline (current_pipeline));
vkCmdBindVertexBuffers (command_buffer,
0,
1,
(VkBuffer[1]) {
gsk_vulkan_buffer_get_buffer (vertex_buffer)
},
(VkDeviceSize[1]) { op->render.vertex_offset });
current_draw_index = 0;
}
gsk: gsk_render_node_set_transform() => GskTransformNode Instead of having a setter for the transform, have a GskTransformNode. Most of the oprations that GTK does do not require a transform, so it doesn't make sense to have it as a primary attribute. Also, changing the transform requires updating the uniforms of the GL renderer, so we're happy if we can avoid that.
2016-12-12 23:11:06 +00:00
vkCmdBindDescriptorSets (command_buffer,
VK_PIPELINE_BIND_POINT_GRAPHICS,
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
gsk_vulkan_pipeline_get_pipeline_layout (current_pipeline),
gsk: gsk_render_node_set_transform() => GskTransformNode Instead of having a setter for the transform, have a GskTransformNode. Most of the oprations that GTK does do not require a transform, so it doesn't make sense to have it as a primary attribute. Also, changing the transform requires updating the uniforms of the GL renderer, so we're happy if we can avoid that.
2016-12-12 23:11:06 +00:00
0,
1,
(VkDescriptorSet[1]) {
vulkan: Split render ops into seperate structs This makes it a lot clearer which members are relevant for each different operation.
2016-12-14 06:34:18 +00:00
gsk_vulkan_render_get_descriptor_set (render, op->render.descriptor_set_index)
gsk: gsk_render_node_set_transform() => GskTransformNode Instead of having a setter for the transform, have a GskTransformNode. Most of the oprations that GTK does do not require a transform, so it doesn't make sense to have it as a primary attribute. Also, changing the transform requires updating the uniforms of the GL renderer, so we're happy if we can avoid that.
2016-12-12 23:11:06 +00:00
},
0,
NULL);
vulkan: Split color and blend pipelines
2016-12-18 01:18:01 +00:00
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
current_draw_index += gsk_vulkan_texture_pipeline_draw (GSK_VULKAN_TEXTURE_PIPELINE (current_pipeline),
command_buffer,
current_draw_index, 1);
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
break;
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
case GSK_VULKAN_OP_TEXT:
vulkan: Better glyph cache api Move the glyph caching api to something that can support using multiple textures. We now split the text render ops into multiple ops for different textures, and make each op render just a substring of the text node's glyph string.
2017-09-19 22:53:32 +00:00
if (current_pipeline != op->text.pipeline)
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
{
vulkan: Better glyph cache api Move the glyph caching api to something that can support using multiple textures. We now split the text render ops into multiple ops for different textures, and make each op render just a substring of the text node's glyph string.
2017-09-19 22:53:32 +00:00
current_pipeline = op->text.pipeline;
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
vkCmdBindPipeline (command_buffer,
VK_PIPELINE_BIND_POINT_GRAPHICS,
gsk_vulkan_pipeline_get_pipeline (current_pipeline));
vkCmdBindVertexBuffers (command_buffer,
0,
1,
(VkBuffer[1]) {
gsk_vulkan_buffer_get_buffer (vertex_buffer)
},
vulkan: Better glyph cache api Move the glyph caching api to something that can support using multiple textures. We now split the text render ops into multiple ops for different textures, and make each op render just a substring of the text node's glyph string.
2017-09-19 22:53:32 +00:00
(VkDeviceSize[1]) { op->text.vertex_offset });
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
current_draw_index = 0;
}
vkCmdBindDescriptorSets (command_buffer,
VK_PIPELINE_BIND_POINT_GRAPHICS,
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
gsk_vulkan_pipeline_get_pipeline_layout (current_pipeline),
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
0,
1,
(VkDescriptorSet[1]) {
vulkan: Better glyph cache api Move the glyph caching api to something that can support using multiple textures. We now split the text render ops into multiple ops for different textures, and make each op render just a substring of the text node's glyph string.
2017-09-19 22:53:32 +00:00
gsk_vulkan_render_get_descriptor_set (render, op->text.descriptor_set_index)
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
},
0,
NULL);
current_draw_index += gsk_vulkan_text_pipeline_draw (GSK_VULKAN_TEXT_PIPELINE (current_pipeline),
vulkan: Better glyph cache api Move the glyph caching api to something that can support using multiple textures. We now split the text render ops into multiple ops for different textures, and make each op render just a substring of the text node's glyph string.
2017-09-19 22:53:32 +00:00
command_buffer,
current_draw_index, op->text.num_glyphs);
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
break;
case GSK_VULKAN_OP_COLOR_TEXT:
vulkan: Better glyph cache api Move the glyph caching api to something that can support using multiple textures. We now split the text render ops into multiple ops for different textures, and make each op render just a substring of the text node's glyph string.
2017-09-19 22:53:32 +00:00
if (current_pipeline != op->text.pipeline)
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
{
vulkan: Better glyph cache api Move the glyph caching api to something that can support using multiple textures. We now split the text render ops into multiple ops for different textures, and make each op render just a substring of the text node's glyph string.
2017-09-19 22:53:32 +00:00
current_pipeline = op->text.pipeline;
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
vkCmdBindPipeline (command_buffer,
VK_PIPELINE_BIND_POINT_GRAPHICS,
gsk_vulkan_pipeline_get_pipeline (current_pipeline));
vkCmdBindVertexBuffers (command_buffer,
0,
1,
(VkBuffer[1]) {
gsk_vulkan_buffer_get_buffer (vertex_buffer)
},
vulkan: Better glyph cache api Move the glyph caching api to something that can support using multiple textures. We now split the text render ops into multiple ops for different textures, and make each op render just a substring of the text node's glyph string.
2017-09-19 22:53:32 +00:00
(VkDeviceSize[1]) { op->text.vertex_offset });
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
current_draw_index = 0;
}
vkCmdBindDescriptorSets (command_buffer,
VK_PIPELINE_BIND_POINT_GRAPHICS,
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
gsk_vulkan_pipeline_get_pipeline_layout (current_pipeline),
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
0,
1,
(VkDescriptorSet[1]) {
vulkan: Better glyph cache api Move the glyph caching api to something that can support using multiple textures. We now split the text render ops into multiple ops for different textures, and make each op render just a substring of the text node's glyph string.
2017-09-19 22:53:32 +00:00
gsk_vulkan_render_get_descriptor_set (render, op->text.descriptor_set_index)
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
},
0,
NULL);
current_draw_index += gsk_vulkan_color_text_pipeline_draw (GSK_VULKAN_COLOR_TEXT_PIPELINE (current_pipeline),
command_buffer,
vulkan: Better glyph cache api Move the glyph caching api to something that can support using multiple textures. We now split the text render ops into multiple ops for different textures, and make each op render just a substring of the text node's glyph string.
2017-09-19 22:53:32 +00:00
current_draw_index, op->text.num_glyphs);
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
break;
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
case GSK_VULKAN_OP_OPACITY:
vulkan: Add support for color matrix nodes @keyframes weee { 100% { filter: hue-rotate(1turn); } } .background { animation: linear infinite 3s weee; }
2016-12-31 13:14:26 +00:00
case GSK_VULKAN_OP_COLOR_MATRIX:
Clip intermediate textures In some cases, we were creating gigantic intermediate textures only to clip out a small section afterwards (e.g. in the listbox example in gtk4-demo). This is wasteful if we apply effects on the texture, such as blur or color-matrix. So, clip the dimensions of the intermediate texture with the current clip. To make this feasible, we move the texture coordinate computation out of the pipeline setup functions into the node_as_texture function where this clipping happens. One extra complication we encounter is that the node might get clipped away completely. Since Vulkan does not allow to create empty images, we bail out in this case and not draw anything. With these changes, the listbox example in gtk4-demo goes from 32M pixels of intermediate texture to 320000.
2017-10-01 23:17:39 +00:00
if (!op->render.source)
continue;
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
if (current_pipeline != op->render.pipeline)
{
current_pipeline = op->render.pipeline;
vkCmdBindPipeline (command_buffer,
VK_PIPELINE_BIND_POINT_GRAPHICS,
gsk_vulkan_pipeline_get_pipeline (current_pipeline));
vkCmdBindVertexBuffers (command_buffer,
0,
1,
(VkBuffer[1]) {
gsk_vulkan_buffer_get_buffer (vertex_buffer)
},
(VkDeviceSize[1]) { op->render.vertex_offset });
current_draw_index = 0;
}
vkCmdBindDescriptorSets (command_buffer,
VK_PIPELINE_BIND_POINT_GRAPHICS,
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
gsk_vulkan_pipeline_get_pipeline_layout (current_pipeline),
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
0,
1,
(VkDescriptorSet[1]) {
gsk_vulkan_render_get_descriptor_set (render, op->render.descriptor_set_index)
},
0,
NULL);
current_draw_index += gsk_vulkan_effect_pipeline_draw (GSK_VULKAN_EFFECT_PIPELINE (current_pipeline),
command_buffer,
current_draw_index, 1);
vulkan: Split color and blend pipelines
2016-12-18 01:18:01 +00:00
break;
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
case GSK_VULKAN_OP_BLUR:
Clip intermediate textures In some cases, we were creating gigantic intermediate textures only to clip out a small section afterwards (e.g. in the listbox example in gtk4-demo). This is wasteful if we apply effects on the texture, such as blur or color-matrix. So, clip the dimensions of the intermediate texture with the current clip. To make this feasible, we move the texture coordinate computation out of the pipeline setup functions into the node_as_texture function where this clipping happens. One extra complication we encounter is that the node might get clipped away completely. Since Vulkan does not allow to create empty images, we bail out in this case and not draw anything. With these changes, the listbox example in gtk4-demo goes from 32M pixels of intermediate texture to 320000.
2017-10-01 23:17:39 +00:00
if (!op->render.source)
continue;
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
if (current_pipeline != op->render.pipeline)
{
current_pipeline = op->render.pipeline;
vkCmdBindPipeline (command_buffer,
VK_PIPELINE_BIND_POINT_GRAPHICS,
gsk_vulkan_pipeline_get_pipeline (current_pipeline));
vkCmdBindVertexBuffers (command_buffer,
0,
1,
(VkBuffer[1]) {
gsk_vulkan_buffer_get_buffer (vertex_buffer)
},
(VkDeviceSize[1]) { op->render.vertex_offset });
current_draw_index = 0;
}
vkCmdBindDescriptorSets (command_buffer,
VK_PIPELINE_BIND_POINT_GRAPHICS,
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
gsk_vulkan_pipeline_get_pipeline_layout (current_pipeline),
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
0,
1,
(VkDescriptorSet[1]) {
gsk_vulkan_render_get_descriptor_set (render, op->render.descriptor_set_index)
},
0,
NULL);
current_draw_index += gsk_vulkan_blur_pipeline_draw (GSK_VULKAN_BLUR_PIPELINE (current_pipeline),
command_buffer,
current_draw_index, 1);
break;
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
case GSK_VULKAN_OP_COLOR:
if (current_pipeline != op->render.pipeline)
{
current_pipeline = op->render.pipeline;
vkCmdBindPipeline (command_buffer,
VK_PIPELINE_BIND_POINT_GRAPHICS,
gsk_vulkan_pipeline_get_pipeline (current_pipeline));
vulkan: Move vertex data tracking to the pipeline subclass That way, different pipelines can draw different kinds of data.
2016-12-18 00:45:07 +00:00
vkCmdBindVertexBuffers (command_buffer,
0,
1,
(VkBuffer[1]) {
gsk_vulkan_buffer_get_buffer (vertex_buffer)
},
(VkDeviceSize[1]) { op->render.vertex_offset });
current_draw_index = 0;
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
}
gsk: gsk_render_node_set_transform() => GskTransformNode Instead of having a setter for the transform, have a GskTransformNode. Most of the oprations that GTK does do not require a transform, so it doesn't make sense to have it as a primary attribute. Also, changing the transform requires updating the uniforms of the GL renderer, so we're happy if we can avoid that.
2016-12-12 23:11:06 +00:00
vulkan: Try combining draw calls This gives a 5-7% speedup in the case where we're just drawing N colors and nothing else. So it;s not tremendously useful, but noticeable.
2016-12-23 21:19:56 +00:00
for (step = 1; step + i < self->render_ops->len; step++)
{
vulkan: Add shader for color drawing with rectangle clip
2016-12-25 05:01:54 +00:00
GskVulkanOp *cmp = &g_array_index (self->render_ops, GskVulkanOp, i + step);
if (cmp->type != GSK_VULKAN_OP_COLOR ||
cmp->render.pipeline != current_pipeline)
vulkan: Try combining draw calls This gives a 5-7% speedup in the case where we're just drawing N colors and nothing else. So it;s not tremendously useful, but noticeable.
2016-12-23 21:19:56 +00:00
break;
}
vulkan: Split color and blend pipelines
2016-12-18 01:18:01 +00:00
current_draw_index += gsk_vulkan_color_pipeline_draw (GSK_VULKAN_COLOR_PIPELINE (current_pipeline),
vulkan: Move vertex data tracking to the pipeline subclass That way, different pipelines can draw different kinds of data.
2016-12-18 00:45:07 +00:00
command_buffer,
vulkan: Try combining draw calls This gives a 5-7% speedup in the case where we're just drawing N colors and nothing else. So it;s not tremendously useful, but noticeable.
2016-12-23 21:19:56 +00:00
current_draw_index, step);
gsk: gsk_render_node_set_transform() => GskTransformNode Instead of having a setter for the transform, have a GskTransformNode. Most of the oprations that GTK does do not require a transform, so it doesn't make sense to have it as a primary attribute. Also, changing the transform requires updating the uniforms of the GL renderer, so we're happy if we can avoid that.
2016-12-12 23:11:06 +00:00
break;
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
case GSK_VULKAN_OP_LINEAR_GRADIENT:
if (current_pipeline != op->render.pipeline)
{
current_pipeline = op->render.pipeline;
vkCmdBindPipeline (command_buffer,
VK_PIPELINE_BIND_POINT_GRAPHICS,
gsk_vulkan_pipeline_get_pipeline (current_pipeline));
vkCmdBindVertexBuffers (command_buffer,
0,
1,
(VkBuffer[1]) {
gsk_vulkan_buffer_get_buffer (vertex_buffer)
},
(VkDeviceSize[1]) { op->render.vertex_offset });
current_draw_index = 0;
}
current_draw_index += gsk_vulkan_linear_gradient_pipeline_draw (GSK_VULKAN_LINEAR_GRADIENT_PIPELINE (current_pipeline),
command_buffer,
current_draw_index, 1);
break;
vulkan: Add shader for border rendering
2017-01-10 13:59:20 +00:00
case GSK_VULKAN_OP_BORDER:
if (current_pipeline != op->render.pipeline)
{
current_pipeline = op->render.pipeline;
vkCmdBindPipeline (command_buffer,
VK_PIPELINE_BIND_POINT_GRAPHICS,
gsk_vulkan_pipeline_get_pipeline (current_pipeline));
vkCmdBindVertexBuffers (command_buffer,
0,
1,
(VkBuffer[1]) {
gsk_vulkan_buffer_get_buffer (vertex_buffer)
},
(VkDeviceSize[1]) { op->render.vertex_offset });
current_draw_index = 0;
}
current_draw_index += gsk_vulkan_border_pipeline_draw (GSK_VULKAN_BORDER_PIPELINE (current_pipeline),
command_buffer,
current_draw_index, 1);
break;
vulkan: Add support for unblurred box-shadow
2017-01-18 03:07:09 +00:00
case GSK_VULKAN_OP_INSET_SHADOW:
case GSK_VULKAN_OP_OUTSET_SHADOW:
if (current_pipeline != op->render.pipeline)
{
current_pipeline = op->render.pipeline;
vkCmdBindPipeline (command_buffer,
VK_PIPELINE_BIND_POINT_GRAPHICS,
gsk_vulkan_pipeline_get_pipeline (current_pipeline));
vkCmdBindVertexBuffers (command_buffer,
0,
1,
(VkBuffer[1]) {
gsk_vulkan_buffer_get_buffer (vertex_buffer)
},
(VkDeviceSize[1]) { op->render.vertex_offset });
current_draw_index = 0;
}
current_draw_index += gsk_vulkan_box_shadow_pipeline_draw (GSK_VULKAN_BOX_SHADOW_PIPELINE (current_pipeline),
command_buffer,
current_draw_index, 1);
break;
vulkan: Add infrastructure for push constants THe code includes fragment push constants for colors, but that code is so far unused.
2016-12-14 06:21:21 +00:00
case GSK_VULKAN_OP_PUSH_VERTEX_CONSTANTS:
build: Reintroduce warning flags from autotools Some of the flags got lost in the meson transition or were demoted from error flags to warning flags. This commit reintroduces them. It also includes fixes for the code that had warnings with those flags. The big one being -Wshadow.
2019-01-22 03:30:47 +00:00
for (int j = 0; j < layout_count; j++)
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
gsk_vulkan_push_constants_push (&op->constants.constants,
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
command_buffer,
build: Reintroduce warning flags from autotools Some of the flags got lost in the meson transition or were demoted from error flags to warning flags. This commit reintroduces them. It also includes fixes for the code that had warnings with those flags. The big one being -Wshadow.
2019-01-22 03:30:47 +00:00
pipeline_layout[j]);
vulkan: Add infrastructure for push constants THe code includes fragment push constants for colors, but that code is so far unused.
2016-12-14 06:21:21 +00:00
break;
gsk: gsk_render_node_set_transform() => GskTransformNode Instead of having a setter for the transform, have a GskTransformNode. Most of the oprations that GTK does do not require a transform, so it doesn't make sense to have it as a primary attribute. Also, changing the transform requires updating the uniforms of the GL renderer, so we're happy if we can avoid that.
2016-12-12 23:11:06 +00:00
vulkan: Implement crossfade This is the first shader using two textures. It almost works.
2017-09-22 18:20:57 +00:00
case GSK_VULKAN_OP_CROSS_FADE:
Clip intermediate textures In some cases, we were creating gigantic intermediate textures only to clip out a small section afterwards (e.g. in the listbox example in gtk4-demo). This is wasteful if we apply effects on the texture, such as blur or color-matrix. So, clip the dimensions of the intermediate texture with the current clip. To make this feasible, we move the texture coordinate computation out of the pipeline setup functions into the node_as_texture function where this clipping happens. One extra complication we encounter is that the node might get clipped away completely. Since Vulkan does not allow to create empty images, we bail out in this case and not draw anything. With these changes, the listbox example in gtk4-demo goes from 32M pixels of intermediate texture to 320000.
2017-10-01 23:17:39 +00:00
if (!op->render.source || !op->render.source2)
continue;
Cosmetics Go back to a single GskVulkanOpRender that can handle 0, 1 or 2 sources.
2017-09-23 13:47:05 +00:00
if (current_pipeline != op->render.pipeline)
vulkan: Implement crossfade This is the first shader using two textures. It almost works.
2017-09-22 18:20:57 +00:00
{
Cosmetics Go back to a single GskVulkanOpRender that can handle 0, 1 or 2 sources.
2017-09-23 13:47:05 +00:00
current_pipeline = op->render.pipeline;
vulkan: Implement crossfade This is the first shader using two textures. It almost works.
2017-09-22 18:20:57 +00:00
vkCmdBindPipeline (command_buffer,
VK_PIPELINE_BIND_POINT_GRAPHICS,
gsk_vulkan_pipeline_get_pipeline (current_pipeline));
vkCmdBindVertexBuffers (command_buffer,
0,
1,
(VkBuffer[1]) {
gsk_vulkan_buffer_get_buffer (vertex_buffer)
},
Cosmetics Go back to a single GskVulkanOpRender that can handle 0, 1 or 2 sources.
2017-09-23 13:47:05 +00:00
(VkDeviceSize[1]) { op->render.vertex_offset });
vulkan: Implement crossfade This is the first shader using two textures. It almost works.
2017-09-22 18:20:57 +00:00
current_draw_index = 0;
}
vkCmdBindDescriptorSets (command_buffer,
VK_PIPELINE_BIND_POINT_GRAPHICS,
gsk_vulkan_pipeline_get_pipeline_layout (current_pipeline),
0,
2,
(VkDescriptorSet[2]) {
Cosmetics Go back to a single GskVulkanOpRender that can handle 0, 1 or 2 sources.
2017-09-23 13:47:05 +00:00
gsk_vulkan_render_get_descriptor_set (render, op->render.descriptor_set_index),
gsk_vulkan_render_get_descriptor_set (render, op->render.descriptor_set_index2)
vulkan: Implement crossfade This is the first shader using two textures. It almost works.
2017-09-22 18:20:57 +00:00
},
0,
NULL);
current_draw_index += gsk_vulkan_cross_fade_pipeline_draw (GSK_VULKAN_CROSS_FADE_PIPELINE (current_pipeline),
command_buffer,
current_draw_index, 1);
break;
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
case GSK_VULKAN_OP_BLEND_MODE:
Clip intermediate textures In some cases, we were creating gigantic intermediate textures only to clip out a small section afterwards (e.g. in the listbox example in gtk4-demo). This is wasteful if we apply effects on the texture, such as blur or color-matrix. So, clip the dimensions of the intermediate texture with the current clip. To make this feasible, we move the texture coordinate computation out of the pipeline setup functions into the node_as_texture function where this clipping happens. One extra complication we encounter is that the node might get clipped away completely. Since Vulkan does not allow to create empty images, we bail out in this case and not draw anything. With these changes, the listbox example in gtk4-demo goes from 32M pixels of intermediate texture to 320000.
2017-10-01 23:17:39 +00:00
if (!op->render.source || !op->render.source2)
continue;
Cosmetics Go back to a single GskVulkanOpRender that can handle 0, 1 or 2 sources.
2017-09-23 13:47:05 +00:00
if (current_pipeline != op->render.pipeline)
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
{
Cosmetics Go back to a single GskVulkanOpRender that can handle 0, 1 or 2 sources.
2017-09-23 13:47:05 +00:00
current_pipeline = op->render.pipeline;
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
vkCmdBindPipeline (command_buffer,
VK_PIPELINE_BIND_POINT_GRAPHICS,
gsk_vulkan_pipeline_get_pipeline (current_pipeline));
vkCmdBindVertexBuffers (command_buffer,
0,
1,
(VkBuffer[1]) {
gsk_vulkan_buffer_get_buffer (vertex_buffer)
},
Cosmetics Go back to a single GskVulkanOpRender that can handle 0, 1 or 2 sources.
2017-09-23 13:47:05 +00:00
(VkDeviceSize[1]) { op->render.vertex_offset });
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
current_draw_index = 0;
}
vkCmdBindDescriptorSets (command_buffer,
VK_PIPELINE_BIND_POINT_GRAPHICS,
gsk_vulkan_pipeline_get_pipeline_layout (current_pipeline),
0,
2,
(VkDescriptorSet[2]) {
Cosmetics Go back to a single GskVulkanOpRender that can handle 0, 1 or 2 sources.
2017-09-23 13:47:05 +00:00
gsk_vulkan_render_get_descriptor_set (render, op->render.descriptor_set_index),
gsk_vulkan_render_get_descriptor_set (render, op->render.descriptor_set_index2)
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
},
0,
NULL);
current_draw_index += gsk_vulkan_blend_mode_pipeline_draw (GSK_VULKAN_BLEND_MODE_PIPELINE (current_pipeline),
command_buffer,
current_draw_index, 1);
break;
gsk: gsk_render_node_set_transform() => GskTransformNode Instead of having a setter for the transform, have a GskTransformNode. Most of the oprations that GTK does do not require a transform, so it doesn't make sense to have it as a primary attribute. Also, changing the transform requires updating the uniforms of the GL renderer, so we're happy if we can avoid that.
2016-12-12 23:11:06 +00:00
default:
g_assert_not_reached ();
break;
}
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_pass_draw (GskVulkanRenderPass *self,
GskVulkanRender *render,
guint layout_count,
VkPipelineLayout *pipeline_layout,
VkCommandBuffer command_buffer)
{
guint i;
vkCmdSetViewport (command_buffer,
0,
1,
&(VkViewport) {
.x = 0,
.y = 0,
.width = self->viewport.size.width,
.height = self->viewport.size.height,
.minDepth = 0,
.maxDepth = 1
});
for (i = 0; i < cairo_region_num_rectangles (self->clip); i++)
{
cairo_rectangle_int_t rect;
cairo_region_get_rectangle (self->clip, i, &rect);
vkCmdSetScissor (command_buffer,
0,
1,
&(VkRect2D) {
{ rect.x * self->scale_factor, rect.y * self->scale_factor },
{ rect.width * self->scale_factor, rect.height * self->scale_factor }
});
vkCmdBeginRenderPass (command_buffer,
&(VkRenderPassBeginInfo) {
.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,
.renderPass = self->render_pass,
.framebuffer = gsk_vulkan_render_get_framebuffer (render, self->target),
.renderArea = {
{ rect.x * self->scale_factor, rect.y * self->scale_factor },
{ rect.width * self->scale_factor, rect.height * self->scale_factor }
},
.clearValueCount = 1,
.pClearValues = (VkClearValue [1]) {
{ .color = { .float32 = { 0.f, 0.f, 0.f, 0.f } } }
}
},
VK_SUBPASS_CONTENTS_INLINE);
gsk_vulkan_render_pass_draw_rect (self, render, layout_count, pipeline_layout, command_buffer);
vkCmdEndRenderPass (command_buffer);
}
}
Reference in New Issue Copy Permalink