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

999 lines
42 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: 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"
#include "gskroundedrectprivate.h"
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
#include "gskvulkanblendpipelineprivate.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"
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"
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"
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
typedef union _GskVulkanOp GskVulkanOp;
typedef struct _GskVulkanOpRender GskVulkanOpRender;
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,
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_SURFACE,
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,
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,
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: Remove color from push constants It's now handled by the color pipeline.
2016-12-18 06:07:02 +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;
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 */
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 */
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
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;
GskVulkanOpPushConstants 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
struct _GskVulkanRenderPass
{
GdkVulkanContext *vulkan;
GArray *render_ops;
};
GskVulkanRenderPass *
gsk_vulkan_render_pass_new (GdkVulkanContext *context)
{
GskVulkanRenderPass *self;
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: 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);
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_NOTE (FALLBACK, g_print (__VA_ARGS__)); \
goto fallback; \
}G_STMT_END
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: 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 = {
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
.type = GSK_VULKAN_OP_FALLBACK,
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
.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;
vulkan: Add shader for border rendering
2017-01-10 13:59:20 +00:00
case GSK_REPEAT_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:
case GSK_BLEND_NODE:
case GSK_CROSS_FADE_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:
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 ("Unsupported node '%s'\n", node->node_class->type_name);
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
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)
FALLBACK ("Blur support not implemented for inset shadows\n");
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
FALLBACK ("Inset shadow nodes can't deal with clip type %u\n", constants->clip.type);
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)
FALLBACK ("Blur support not implemented for outset shadows\n");
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
FALLBACK ("Outset shadow nodes can't deal with clip type %u\n", constants->clip.type);
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:
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 (gsk_cairo_node_get_surface (node) == NULL)
return;
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))
pipeline_type = GSK_VULKAN_PIPELINE_BLEND;
else if (constants->clip.type == GSK_VULKAN_CLIP_RECT)
pipeline_type = GSK_VULKAN_PIPELINE_BLEND_CLIP;
else if (constants->clip.type == GSK_VULKAN_CLIP_ROUNDED_CIRCULAR)
pipeline_type = GSK_VULKAN_PIPELINE_BLEND_CLIP_ROUNDED;
else
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
FALLBACK ("Cairo nodes can't deal with clip type %u\n", 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
op.type = GSK_VULKAN_OP_SURFACE;
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);
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);
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_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))
pipeline_type = GSK_VULKAN_PIPELINE_BLEND;
else if (constants->clip.type == GSK_VULKAN_CLIP_RECT)
pipeline_type = GSK_VULKAN_PIPELINE_BLEND_CLIP;
else if (constants->clip.type == GSK_VULKAN_CLIP_ROUNDED_CIRCULAR)
pipeline_type = GSK_VULKAN_PIPELINE_BLEND_CLIP_ROUNDED;
else
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
FALLBACK ("Texture nodes can't deal with clip type %u\n", 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
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
FALLBACK ("Color nodes can't deal with clip type %u\n", 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)
FALLBACK ("Linear gradient with %zu color stops, hardcoded limit is %u\n",
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
FALLBACK ("Linear gradient nodes can't deal with clip type %u\n", constants->clip.type);
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
FALLBACK ("Opacity nodes can't deal with clip type %u\n", constants->clip.type);
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;
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
FALLBACK ("Color matrix nodes can't deal with clip type %u\n", constants->clip.type);
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
FALLBACK ("Border nodes can't deal with clip type %u\n", constants->clip.type);
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: 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:
{
graphene_matrix_t transform;
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
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 (!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_transform_node_get_transform (node, &transform);
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
child = gsk_transform_node_get_child (node);
if (!gsk_vulkan_push_constants_transform (&op.constants.constants, constants, &transform, &child->bounds))
FALLBACK ("Transform nodes can't deal with clip type %u\n", 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);
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:
{
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_rect (&op.constants.constants, constants, gsk_clip_node_peek_clip (node)))
FALLBACK ("Failed to find intersection between clip of type %u and rectangle\n", 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,
gsk_rounded_clip_node_peek_clip (node)))
FALLBACK ("Failed to find intersection between clip of type %u and rounded rectangle\n", 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: 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, GSK_VULKAN_PIPELINE_BLEND);
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,
const graphene_matrix_t *mvp,
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
const graphene_rect_t *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
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, };
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: 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: 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_push_constants_init (&op.constants.constants, mvp, 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 *
gsk_vulkan_render_pass_get_node_as_texture (GskVulkanRenderPass *self,
GskVulkanRender *render,
GskVulkanUploader *uploader,
GskRenderNode *node,
const graphene_rect_t *bounds)
{
GskVulkanImage *result;
cairo_surface_t *surface;
cairo_t *cr;
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
if (graphene_rect_equal (bounds, &node->bounds))
{
switch (gsk_render_node_get_node_type (node))
{
case GSK_TEXTURE_NODE:
return gsk_vulkan_renderer_ref_texture_image (GSK_VULKAN_RENDERER (gsk_vulkan_render_get_renderer (render)),
gsk_texture_node_get_texture (node),
uploader);
case GSK_CAIRO_NODE:
surface = cairo_surface_reference (gsk_cairo_node_get_surface (node));
goto got_surface;
default:
break;
}
}
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
GSK_NOTE (FALLBACK, g_print ("Node as texture not implemented. Using %gx%g fallback surface\n",
ceil (bounds->size.width),
ceil (bounds->size.height)));
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);
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
got_surface:
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
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);
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: 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: 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
ceil (node->bounds.size.width),
ceil (node->bounds.size.height));
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
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));
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;
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;
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_SURFACE:
{
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
cairo_surface_t *surface = gsk_cairo_node_get_surface (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
op->render.source = gsk_vulkan_image_new_from_data (uploader,
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
cairo_image_surface_get_data (surface),
cairo_image_surface_get_width (surface),
cairo_image_surface_get_height (surface),
cairo_image_surface_get_stride (surface));
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;
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)),
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);
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);
op->render.source = gsk_vulkan_render_pass_get_node_as_texture (self,
render,
uploader,
child,
&child->bounds);
}
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);
op->render.source = gsk_vulkan_render_pass_get_node_as_texture (self,
render,
uploader,
child,
&child->bounds);
}
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 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: 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;
}
}
}
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_SURFACE:
case GSK_VULKAN_OP_TEXTURE:
op->render.vertex_count = gsk_vulkan_blend_pipeline_count_vertex_data (GSK_VULKAN_BLEND_PIPELINE (op->render.pipeline));
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
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;
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: 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 ();
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
}
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,
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_SURFACE:
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;
gsk_vulkan_blend_pipeline_collect_vertex_data (GSK_VULKAN_BLEND_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);
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;
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,
vulkan: Pass color rects in instance data This way, we don't need push constants or per-vertex data, we can render colored rectangles completely via instance data.
2016-12-18 05:54:48 +00:00
gsk_color_node_peek_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,
gsk_linear_gradient_node_peek_start (op->render.node),
gsk_linear_gradient_node_peek_end (op->render.node),
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),
gsk_linear_gradient_node_peek_color_stops (op->render.node));
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;
graphene_matrix_init_from_float (&color_matrix,
(float[16]) {
1.0, 0.0, 0.0, 0.0,
0.0, 1.0, 0.0, 0.0,
0.0, 0.0, 1.0, 0.0,
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;
gsk_vulkan_effect_pipeline_collect_vertex_data (GSK_VULKAN_EFFECT_PIPELINE (op->render.pipeline),
data + n_bytes + offset,
&op->render.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
&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;
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,
gsk_color_matrix_node_peek_color_matrix (op->render.node),
gsk_color_matrix_node_peek_color_offset (op->render.node));
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,
gsk_border_node_peek_outline (op->render.node),
gsk_border_node_peek_widths (op->render.node),
gsk_border_node_peek_colors (op->render.node));
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,
gsk_inset_shadow_node_peek_outline (op->render.node),
gsk_inset_shadow_node_peek_color (op->render.node),
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,
gsk_outset_shadow_node_peek_outline (op->render.node),
gsk_outset_shadow_node_peek_color (op->render.node),
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: 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
}
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_SURFACE:
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:
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: 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.descriptor_set_index = gsk_vulkan_render_reserve_descriptor_set (render, op->render.source);
vulkan: Redo descriptor set handling First, we collect all the info about descriptor sets into a hash table, then we use its size to determine the amount of sets and allocate those before we finally go ahead and use the hash table's contents to initialize the descriptor sets. And then we're ready to render.
2016-12-09 01:55:47 +00:00
break;
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 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
}
}
void
vulkan: Push the correct matrix when drawing Instead of pushing the root matrix, push the world matrix for the current node. That way, the bounds we emit as vertices are actually properly transformed.
2016-12-09 04:53:04 +00:00
gsk_vulkan_render_pass_draw (GskVulkanRenderPass *self,
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
GskVulkanBuffer *vertex_buffer,
vulkan: Split PipelineLayout into its own object This way, we can share the layout between different pipelines.
2016-12-14 07:00:58 +00:00
GskVulkanPipelineLayout *layout,
vulkan: Push the correct matrix when drawing Instead of pushing the root matrix, push the world matrix for the current node. That way, the bounds we emit as vertices are actually properly transformed.
2016-12-09 04:53:04 +00:00
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: 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_SURFACE:
case GSK_VULKAN_OP_TEXTURE:
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,
vulkan: Split PipelineLayout into its own object This way, we can share the layout between different pipelines.
2016-12-14 07:00:58 +00:00
gsk_vulkan_pipeline_layout_get_pipeline_layout (layout),
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
current_draw_index += gsk_vulkan_blend_pipeline_draw (GSK_VULKAN_BLEND_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;
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
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,
gsk_vulkan_pipeline_layout_get_pipeline_layout (layout),
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;
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:
vulkan: Add push constants to fragment shader That way we don't need to move the clip rounded rect manually through the vertex shader into the fragment shader but can just look at the push constants. Simplifies shaders a lot.
2017-01-17 04:20:07 +00:00
gsk_vulkan_push_constants_push (&op->constants.constants,
command_buffer,
gsk_vulkan_pipeline_layout_get_pipeline_layout (layout));
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
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
}
}
Reference in New Issue Copy Permalink