From b1e441d18a6ccda5ffdb7d9a959511b834d508ac Mon Sep 17 00:00:00 2001 From: Benjamin Otte Date: Thu, 18 Jul 2024 22:42:15 +0200 Subject: [PATCH 01/28] gpu: Introduce GskGpuShaderImage It's a struct collecting all relevant info for a texture passed to a shader. The ultimate goal is to get rid of the descriptors and let ops manage them on thir own. --- gsk/gpu/gskgpucolorizeop.c | 22 ++++++++++------------ gsk/gpu/gskgpucolorizeopprivate.h | 4 +--- gsk/gpu/gskgpunodeprocessor.c | 30 +++++++++++++++++++++--------- gsk/gpu/gskgpushaderopprivate.h | 11 +++++++++++ gsk/gpu/gskgputypesprivate.h | 1 + 5 files changed, 44 insertions(+), 24 deletions(-) diff --git a/gsk/gpu/gskgpucolorizeop.c b/gsk/gpu/gskgpucolorizeop.c index eb5ebf9715..045e84495a 100644 --- a/gsk/gpu/gskgpucolorizeop.c +++ b/gsk/gpu/gskgpucolorizeop.c @@ -49,15 +49,13 @@ static const GskGpuShaderOpClass GSK_GPU_COLORIZE_OP_CLASS = { }; void -gsk_gpu_colorize_op (GskGpuFrame *frame, - GskGpuShaderClip clip, - GskGpuColorStates color_states, - GskGpuDescriptors *descriptors, - guint32 descriptor, - const graphene_rect_t *rect, - const graphene_point_t *offset, - const graphene_rect_t *tex_rect, - const float color[4]) +gsk_gpu_colorize_op (GskGpuFrame *frame, + GskGpuShaderClip clip, + GskGpuColorStates color_states, + GskGpuDescriptors *descriptors, + const graphene_point_t *offset, + const GskGpuShaderImage *image, + const float color[4]) { GskGpuColorizeInstance *instance; @@ -69,8 +67,8 @@ gsk_gpu_colorize_op (GskGpuFrame *frame, descriptors, &instance); - gsk_gpu_rect_to_float (rect, offset, instance->rect); - gsk_gpu_rect_to_float (tex_rect, offset, instance->tex_rect); - instance->tex_id = descriptor; + gsk_gpu_rect_to_float (image->coverage ? image->coverage : image->bounds, offset, instance->rect); + gsk_gpu_rect_to_float (image->bounds, offset, instance->tex_rect); + instance->tex_id = image->descriptor; gsk_gpu_color_to_float (color, instance->color); } diff --git a/gsk/gpu/gskgpucolorizeopprivate.h b/gsk/gpu/gskgpucolorizeopprivate.h index 3c75ff4b25..3fe39f4aa4 100644 --- a/gsk/gpu/gskgpucolorizeopprivate.h +++ b/gsk/gpu/gskgpucolorizeopprivate.h @@ -10,10 +10,8 @@ void gsk_gpu_colorize_op (GskGpuF GskGpuShaderClip clip, GskGpuColorStates color_states, GskGpuDescriptors *desc, - guint32 descriptor, - const graphene_rect_t *rect, const graphene_point_t *offset, - const graphene_rect_t *tex_rect, + const GskGpuShaderImage *image, const float color[4]); diff --git a/gsk/gpu/gskgpunodeprocessor.c b/gsk/gpu/gskgpunodeprocessor.c index 5ffe7df433..82ec2773e6 100644 --- a/gsk/gpu/gskgpunodeprocessor.c +++ b/gsk/gpu/gskgpunodeprocessor.c @@ -2502,10 +2502,14 @@ gsk_gpu_node_processor_add_shadow_node (GskGpuNodeProcessor *self, gsk_gpu_clip_get_shader_clip (&self->clip, &shadow_offset, &child->bounds), gsk_gpu_node_processor_color_states_for_rgba (self), desc, - descriptor, - &child->bounds, &shadow_offset, - &tex_rect, + &(GskGpuShaderImage) { + image, + GSK_GPU_SAMPLER_TRANSPARENT, + descriptor, + &child->bounds, + &tex_rect, + }, GSK_RGBA_TO_VEC4 (&shadow->color)); } else @@ -2736,10 +2740,14 @@ gsk_gpu_node_processor_add_mask_node (GskGpuNodeProcessor *self, gsk_gpu_clip_get_shader_clip (&self->clip, &self->offset, &node->bounds), gsk_gpu_node_processor_color_states_for_rgba (self), self->desc, - descriptor, - &node->bounds, &self->offset, - &mask_rect, + &(GskGpuShaderImage) { + mask_image, + GSK_GPU_SAMPLER_DEFAULT, + descriptor, + &node->bounds, + &mask_rect, + }, GSK_RGBA_TO_VEC4_ALPHA (rgba, self->opacity)); } else @@ -2892,10 +2900,14 @@ gsk_gpu_node_processor_add_glyph_node (GskGpuNodeProcessor *self, gsk_gpu_clip_get_shader_clip (&self->clip, &glyph_offset, &glyph_bounds), gsk_gpu_node_processor_color_states_for_rgba (self), self->desc, - descriptor, - &glyph_bounds, &glyph_origin, - &glyph_tex_rect, + &(GskGpuShaderImage) { + image, + GSK_GPU_SAMPLER_DEFAULT, + descriptor, + &glyph_bounds, + &glyph_tex_rect + }, GSK_RGBA_TO_VEC4 (&color)); offset.x += glyphs[i].geometry.width * inv_pango_scale; diff --git a/gsk/gpu/gskgpushaderopprivate.h b/gsk/gpu/gskgpushaderopprivate.h index 4c80d85b74..4bc7871793 100644 --- a/gsk/gpu/gskgpushaderopprivate.h +++ b/gsk/gpu/gskgpushaderopprivate.h @@ -5,8 +5,19 @@ #include "gskgputypesprivate.h" #include "gskgpucolorstatesprivate.h" +#include + G_BEGIN_DECLS +struct _GskGpuShaderImage +{ + GskGpuImage *image; /* image to draw */ + GskGpuSampler sampler; /* sampler to use for image */ + guint32 descriptor; /* FIXME: preallocated descriptor for image + sampler */ + const graphene_rect_t *coverage; /* the clip area for the image or NULL for unclipped */ + const graphene_rect_t *bounds; /* bounds for the image */ +}; + struct _GskGpuShaderOp { GskGpuOp parent_op; diff --git a/gsk/gpu/gskgputypesprivate.h b/gsk/gpu/gskgputypesprivate.h index 0279d159f6..a8fcb3e7f3 100644 --- a/gsk/gpu/gskgputypesprivate.h +++ b/gsk/gpu/gskgputypesprivate.h @@ -15,6 +15,7 @@ typedef struct _GskGpuFrame GskGpuFrame; typedef struct _GskGpuImage GskGpuImage; typedef struct _GskGpuOp GskGpuOp; typedef struct _GskGpuOpClass GskGpuOpClass; +typedef struct _GskGpuShaderImage GskGpuShaderImage; typedef struct _GskGpuShaderOp GskGpuShaderOp; typedef struct _GskGpuShaderOpClass GskGpuShaderOpClass; typedef struct _GskVulkanDescriptors GskVulkanDescriptors; From 23081d2bc476b088b717ebf4133fad625c820d81 Mon Sep 17 00:00:00 2001 From: Benjamin Otte Date: Thu, 18 Jul 2024 23:02:00 +0200 Subject: [PATCH 02/28] gpu: Use GskGpuShaderImage for texture ops --- gsk/gpu/gskgpunodeprocessor.c | 80 +++++++++++++++++++++----------- gsk/gpu/gskgputextureop.c | 18 ++++--- gsk/gpu/gskgputextureopprivate.h | 4 +- 3 files changed, 63 insertions(+), 39 deletions(-) diff --git a/gsk/gpu/gskgpunodeprocessor.c b/gsk/gpu/gskgpunodeprocessor.c index 82ec2773e6..2a4d93c30c 100644 --- a/gsk/gpu/gskgpunodeprocessor.c +++ b/gsk/gpu/gskgpunodeprocessor.c @@ -559,10 +559,14 @@ gsk_gpu_node_processor_image_op (GskGpuNodeProcessor *self, gsk_gpu_texture_op (self->frame, gsk_gpu_clip_get_shader_clip (&self->clip, &self->offset, rect), self->desc, - descriptor, - rect, &self->offset, - tex_rect); + &(GskGpuShaderImage) { + image, + sampler, + descriptor, + rect, + tex_rect + }); } } @@ -2055,10 +2059,14 @@ gsk_gpu_node_processor_add_texture_scale_node (GskGpuNodeProcessor *self, gsk_gpu_texture_op (self->frame, gsk_gpu_clip_get_shader_clip (&self->clip, &self->offset, &node->bounds), self->desc, - descriptor, - &node->bounds, &self->offset, - &clip_bounds); + &(GskGpuShaderImage) { + offscreen, + GSK_GPU_SAMPLER_DEFAULT, + descriptor, + &node->bounds, + &clip_bounds + }); g_object_unref (offscreen); return; } @@ -2083,10 +2091,14 @@ gsk_gpu_node_processor_add_texture_scale_node (GskGpuNodeProcessor *self, gsk_gpu_texture_op (self->frame, gsk_gpu_clip_get_shader_clip (&self->clip, &self->offset, &node->bounds), self->desc, - descriptor, - &node->bounds, &self->offset, - &node->bounds); + &(GskGpuShaderImage) { + image, + gsk_gpu_sampler_for_scaling_filter (scaling_filter), + descriptor, + &node->bounds, + &node->bounds, + }); g_object_unref (image); } @@ -2318,10 +2330,14 @@ gsk_gpu_node_processor_add_gradient_node (GskGpuNodeProcessor *self, gsk_gpu_texture_op (self->frame, gsk_gpu_clip_get_shader_clip (&self->clip, &self->offset, &bounds), self->desc, - descriptor, - &node->bounds, &self->offset, - &bounds); + &(GskGpuShaderImage) { + image, + GSK_GPU_SAMPLER_DEFAULT, + descriptor, + &node->bounds, + &bounds + }); g_object_unref (image); } @@ -2534,10 +2550,14 @@ gsk_gpu_node_processor_add_shadow_node (GskGpuNodeProcessor *self, gsk_gpu_texture_op (self->frame, gsk_gpu_clip_get_shader_clip (&self->clip, &self->offset, &child->bounds), self->desc, - descriptor, - &child->bounds, &self->offset, - &tex_rect); + &(GskGpuShaderImage) { + image, + GSK_GPU_SAMPLER_DEFAULT, + descriptor, + &child->bounds, + &tex_rect, + }); g_object_unref (image); } @@ -2891,10 +2911,14 @@ gsk_gpu_node_processor_add_glyph_node (GskGpuNodeProcessor *self, gsk_gpu_texture_op (self->frame, gsk_gpu_clip_get_shader_clip (&self->clip, &glyph_offset, &glyph_bounds), self->desc, - descriptor, - &glyph_bounds, &glyph_origin, - &glyph_tex_rect); + &(GskGpuShaderImage) { + image, + GSK_GPU_SAMPLER_DEFAULT, + descriptor, + &glyph_bounds, + &glyph_tex_rect + }); else gsk_gpu_colorize_op (self->frame, gsk_gpu_clip_get_shader_clip (&self->clip, &glyph_offset, &glyph_bounds), @@ -3001,15 +3025,19 @@ gsk_gpu_node_processor_repeat_tile (GskGpuNodeProcessor *self, gsk_gpu_texture_op (self->frame, gsk_gpu_clip_get_shader_clip (&self->clip, &self->offset, rect), self->desc, - descriptor, - rect, &self->offset, - &GRAPHENE_RECT_INIT ( - clipped_child_bounds.origin.x + x * child_bounds->size.width, - clipped_child_bounds.origin.y + y * child_bounds->size.height, - clipped_child_bounds.size.width, - clipped_child_bounds.size.height - )); + &(GskGpuShaderImage) { + image, + GSK_GPU_SAMPLER_REPEAT, + descriptor, + rect, + &GRAPHENE_RECT_INIT ( + clipped_child_bounds.origin.x + x * child_bounds->size.width, + clipped_child_bounds.origin.y + y * child_bounds->size.height, + clipped_child_bounds.size.width, + clipped_child_bounds.size.height + ) + }); g_object_unref (image); } diff --git a/gsk/gpu/gskgputextureop.c b/gsk/gpu/gskgputextureop.c index 07faf875cf..f54dc8cb1c 100644 --- a/gsk/gpu/gskgputextureop.c +++ b/gsk/gpu/gskgputextureop.c @@ -48,13 +48,11 @@ static const GskGpuShaderOpClass GSK_GPU_TEXTURE_OP_CLASS = { }; void -gsk_gpu_texture_op (GskGpuFrame *frame, - GskGpuShaderClip clip, - GskGpuDescriptors *desc, - guint32 descriptor, - const graphene_rect_t *rect, - const graphene_point_t *offset, - const graphene_rect_t *tex_rect) +gsk_gpu_texture_op (GskGpuFrame *frame, + GskGpuShaderClip clip, + GskGpuDescriptors *desc, + const graphene_point_t *offset, + const GskGpuShaderImage *image) { GskGpuTextureInstance *instance; @@ -66,7 +64,7 @@ gsk_gpu_texture_op (GskGpuFrame *frame, desc, &instance); - gsk_gpu_rect_to_float (rect, offset, instance->rect); - gsk_gpu_rect_to_float (tex_rect, offset, instance->tex_rect); - instance->tex_id = descriptor; + gsk_gpu_rect_to_float (image->coverage ? image->coverage : image->bounds, offset, instance->rect); + gsk_gpu_rect_to_float (image->bounds, offset, instance->tex_rect); + instance->tex_id = image->descriptor; } diff --git a/gsk/gpu/gskgputextureopprivate.h b/gsk/gpu/gskgputextureopprivate.h index 51b3a79e6a..bb58628f2b 100644 --- a/gsk/gpu/gskgputextureopprivate.h +++ b/gsk/gpu/gskgputextureopprivate.h @@ -9,10 +9,8 @@ G_BEGIN_DECLS void gsk_gpu_texture_op (GskGpuFrame *frame, GskGpuShaderClip clip, GskGpuDescriptors *desc, - guint32 descriptor, - const graphene_rect_t *rect, const graphene_point_t *offset, - const graphene_rect_t *tex_rect); + const GskGpuShaderImage *image); G_END_DECLS From 21988ea700d4873b71dd561d0b3c73e1d78bb690 Mon Sep 17 00:00:00 2001 From: Benjamin Otte Date: Fri, 19 Jul 2024 00:46:33 +0200 Subject: [PATCH 03/28] gpu: Use GskGpuShaderImage for blendmode ops --- gsk/gpu/gskgpublendmodeop.c | 28 +++++++++++++--------------- gsk/gpu/gskgpublendmodeopprivate.h | 6 ++---- gsk/gpu/gskgpunodeprocessor.c | 18 ++++++++++++++---- 3 files changed, 29 insertions(+), 23 deletions(-) diff --git a/gsk/gpu/gskgpublendmodeop.c b/gsk/gpu/gskgpublendmodeop.c index fde694bde2..e2cb81af97 100644 --- a/gsk/gpu/gskgpublendmodeop.c +++ b/gsk/gpu/gskgpublendmodeop.c @@ -52,17 +52,15 @@ static const GskGpuShaderOpClass GSK_GPU_BLEND_MODE_OP_CLASS = { }; void -gsk_gpu_blend_mode_op (GskGpuFrame *frame, - GskGpuShaderClip clip, - GskGpuDescriptors *desc, - const graphene_rect_t *rect, - const graphene_point_t *offset, - float opacity, - GskBlendMode blend_mode, - guint32 bottom_descriptor, - const graphene_rect_t *bottom_rect, - guint32 top_descriptor, - const graphene_rect_t *top_rect) +gsk_gpu_blend_mode_op (GskGpuFrame *frame, + GskGpuShaderClip clip, + GskGpuDescriptors *desc, + const graphene_rect_t *rect, + const graphene_point_t *offset, + float opacity, + GskBlendMode blend_mode, + const GskGpuShaderImage *bottom, + const GskGpuShaderImage *top) { GskGpuBlendmodeInstance *instance; @@ -76,8 +74,8 @@ gsk_gpu_blend_mode_op (GskGpuFrame *frame, gsk_gpu_rect_to_float (rect, offset, instance->rect); instance->opacity = opacity; - gsk_gpu_rect_to_float (bottom_rect, offset, instance->bottom_rect); - instance->bottom_id = bottom_descriptor; - gsk_gpu_rect_to_float (top_rect, offset, instance->top_rect); - instance->top_id = top_descriptor; + gsk_gpu_rect_to_float (bottom->bounds, offset, instance->bottom_rect); + instance->bottom_id = bottom->descriptor; + gsk_gpu_rect_to_float (top->bounds, offset, instance->top_rect); + instance->top_id = top->descriptor; } diff --git a/gsk/gpu/gskgpublendmodeopprivate.h b/gsk/gpu/gskgpublendmodeopprivate.h index e8d7b63479..1087211871 100644 --- a/gsk/gpu/gskgpublendmodeopprivate.h +++ b/gsk/gpu/gskgpublendmodeopprivate.h @@ -13,10 +13,8 @@ void gsk_gpu_blend_mode_op (GskGpuF const graphene_point_t *offset, float opacity, GskBlendMode blend_mode, - guint32 start_descriptor, - const graphene_rect_t *start_rect, - guint32 end_descriptor, - const graphene_rect_t *end_rect); + const GskGpuShaderImage *bottom, + const GskGpuShaderImage *top); G_END_DECLS diff --git a/gsk/gpu/gskgpunodeprocessor.c b/gsk/gpu/gskgpunodeprocessor.c index 2a4d93c30c..3af27b5ee8 100644 --- a/gsk/gpu/gskgpunodeprocessor.c +++ b/gsk/gpu/gskgpunodeprocessor.c @@ -2625,10 +2625,20 @@ gsk_gpu_node_processor_add_blend_node (GskGpuNodeProcessor *self, &self->offset, self->opacity, gsk_blend_node_get_blend_mode (node), - descriptors[0], - &bottom_rect, - descriptors[1], - &top_rect); + &(GskGpuShaderImage) { + bottom_image, + GSK_GPU_SAMPLER_DEFAULT, + descriptors[0], + NULL, + &bottom_rect + }, + &(GskGpuShaderImage) { + top_image, + GSK_GPU_SAMPLER_DEFAULT, + descriptors[1], + NULL, + &top_rect + }); g_object_unref (top_image); g_object_unref (bottom_image); From 0795d86df76db832800dee369827e546646ace54 Mon Sep 17 00:00:00 2001 From: Benjamin Otte Date: Fri, 19 Jul 2024 02:36:00 +0200 Subject: [PATCH 04/28] gpu: Use GskGpuShaderImage for colormatrix ops --- gsk/gpu/gskgpucolormatrixop.c | 10 ++++------ gsk/gpu/gskgpucolormatrixopprivate.h | 4 +--- gsk/gpu/gskgpunodeprocessor.c | 10 +++++++--- 3 files changed, 12 insertions(+), 12 deletions(-) diff --git a/gsk/gpu/gskgpucolormatrixop.c b/gsk/gpu/gskgpucolormatrixop.c index fd39191c69..597a7b9e62 100644 --- a/gsk/gpu/gskgpucolormatrixop.c +++ b/gsk/gpu/gskgpucolormatrixop.c @@ -52,10 +52,8 @@ gsk_gpu_color_matrix_op (GskGpuFrame *frame, GskGpuShaderClip clip, GskGpuColorStates color_states, GskGpuDescriptors *desc, - guint32 descriptor, - const graphene_rect_t *rect, const graphene_point_t *offset, - const graphene_rect_t *tex_rect, + const GskGpuShaderImage *image, const graphene_matrix_t *color_matrix, const graphene_vec4_t *color_offset) { @@ -69,9 +67,9 @@ gsk_gpu_color_matrix_op (GskGpuFrame *frame, desc, &instance); - gsk_gpu_rect_to_float (rect, offset, instance->rect); - gsk_gpu_rect_to_float (tex_rect, offset, instance->tex_rect); - instance->tex_id = descriptor; + gsk_gpu_rect_to_float (image->coverage, offset, instance->rect); + gsk_gpu_rect_to_float (image->bounds, offset, instance->tex_rect); + instance->tex_id = image->descriptor; graphene_matrix_to_float (color_matrix, instance->color_matrix); graphene_vec4_to_float (color_offset, instance->color_offset); } diff --git a/gsk/gpu/gskgpucolormatrixopprivate.h b/gsk/gpu/gskgpucolormatrixopprivate.h index c8a53d8cc2..b32e654bb7 100644 --- a/gsk/gpu/gskgpucolormatrixopprivate.h +++ b/gsk/gpu/gskgpucolormatrixopprivate.h @@ -10,10 +10,8 @@ void gsk_gpu_color_matrix_op (GskGpuF GskGpuShaderClip clip, GskGpuColorStates color_states, GskGpuDescriptors *desc, - guint32 descriptor, - const graphene_rect_t *rect, const graphene_point_t *offset, - const graphene_rect_t *tex_rect, + const GskGpuShaderImage *image, const graphene_matrix_t *color_matrix, const graphene_vec4_t *color_offset); diff --git a/gsk/gpu/gskgpunodeprocessor.c b/gsk/gpu/gskgpunodeprocessor.c index 3af27b5ee8..22b63bde2b 100644 --- a/gsk/gpu/gskgpunodeprocessor.c +++ b/gsk/gpu/gskgpunodeprocessor.c @@ -2988,10 +2988,14 @@ gsk_gpu_node_processor_add_color_matrix_node (GskGpuNodeProcessor *self, gsk_gpu_clip_get_shader_clip (&self->clip, &self->offset, &node->bounds), gsk_gpu_node_processor_color_states_explicit (self, self->ccs, FALSE), self->desc, - descriptor, - &node->bounds, &self->offset, - &tex_rect, + &(GskGpuShaderImage) { + image, + GSK_GPU_SAMPLER_DEFAULT, + descriptor, + &node->bounds, + &tex_rect, + }, color_matrix, gsk_color_matrix_node_get_color_offset (node)); From 9644fc2e8f4858e4ddc24098a390ebce8ab32ea8 Mon Sep 17 00:00:00 2001 From: Benjamin Otte Date: Fri, 19 Jul 2024 03:06:20 +0200 Subject: [PATCH 05/28] gpu: Use GskGpuShaderImage for mask ops --- gsk/gpu/gskgpumaskop.c | 28 +++++++------- gsk/gpu/gskgpumaskopprivate.h | 6 +-- gsk/gpu/gskgpunodeprocessor.c | 72 +++++++++++++++++++++++++++-------- 3 files changed, 71 insertions(+), 35 deletions(-) diff --git a/gsk/gpu/gskgpumaskop.c b/gsk/gpu/gskgpumaskop.c index e77dfbc591..6e36a5d24c 100644 --- a/gsk/gpu/gskgpumaskop.c +++ b/gsk/gpu/gskgpumaskop.c @@ -51,17 +51,15 @@ static const GskGpuShaderOpClass GSK_GPU_MASK_OP_CLASS = { }; void -gsk_gpu_mask_op (GskGpuFrame *frame, - GskGpuShaderClip clip, - GskGpuDescriptors *desc, - const graphene_rect_t *rect, - const graphene_point_t *offset, - float opacity, - GskMaskMode mask_mode, - guint32 source_descriptor, - const graphene_rect_t *source_rect, - guint32 mask_descriptor, - const graphene_rect_t *mask_rect) +gsk_gpu_mask_op (GskGpuFrame *frame, + GskGpuShaderClip clip, + GskGpuDescriptors *desc, + const graphene_rect_t *rect, + const graphene_point_t *offset, + float opacity, + GskMaskMode mask_mode, + const GskGpuShaderImage *source, + const GskGpuShaderImage *mask) { GskGpuMaskInstance *instance; @@ -74,9 +72,9 @@ gsk_gpu_mask_op (GskGpuFrame *frame, &instance); gsk_gpu_rect_to_float (rect, offset, instance->rect); - gsk_gpu_rect_to_float (source_rect, offset, instance->source_rect); - instance->source_id = source_descriptor; - gsk_gpu_rect_to_float (mask_rect, offset, instance->mask_rect); - instance->mask_id = mask_descriptor; + gsk_gpu_rect_to_float (source->bounds, offset, instance->source_rect); + instance->source_id = source->descriptor; + gsk_gpu_rect_to_float (mask->bounds, offset, instance->mask_rect); + instance->mask_id = mask->descriptor; instance->opacity = opacity; } diff --git a/gsk/gpu/gskgpumaskopprivate.h b/gsk/gpu/gskgpumaskopprivate.h index ed321a4b1e..20c74b2b90 100644 --- a/gsk/gpu/gskgpumaskopprivate.h +++ b/gsk/gpu/gskgpumaskopprivate.h @@ -13,10 +13,8 @@ void gsk_gpu_mask_op (GskGpuF const graphene_point_t *offset, float opacity, GskMaskMode mask_mode, - guint32 source_descriptor, - const graphene_rect_t *source_rect, - guint32 mask_descriptor, - const graphene_rect_t *mask_rect); + const GskGpuShaderImage *source, + const GskGpuShaderImage *mask); G_END_DECLS diff --git a/gsk/gpu/gskgpunodeprocessor.c b/gsk/gpu/gskgpunodeprocessor.c index 22b63bde2b..82d586f985 100644 --- a/gsk/gpu/gskgpunodeprocessor.c +++ b/gsk/gpu/gskgpunodeprocessor.c @@ -1082,10 +1082,20 @@ gsk_gpu_node_processor_add_rounded_clip_node_with_mask (GskGpuNodeProcessor *sel &self->offset, self->opacity, GSK_MASK_MODE_ALPHA, - descriptors[0], - &child_rect, - descriptors[1], - &clip_bounds); + &(GskGpuShaderImage) { + child_image, + GSK_GPU_SAMPLER_DEFAULT, + descriptors[0], + NULL, + &child_rect, + }, + &(GskGpuShaderImage) { + mask_image, + GSK_GPU_SAMPLER_DEFAULT, + descriptors[1], + NULL, + &clip_bounds, + }); g_object_unref (child_image); g_object_unref (mask_image); @@ -2809,10 +2819,20 @@ gsk_gpu_node_processor_add_mask_node (GskGpuNodeProcessor *self, &self->offset, self->opacity, mask_mode, - descriptors[0], - &source_rect, - descriptors[1], - &mask_rect); + &(GskGpuShaderImage) { + source_image, + GSK_GPU_SAMPLER_DEFAULT, + descriptors[0], + NULL, + &source_rect, + }, + &(GskGpuShaderImage) { + mask_image, + GSK_GPU_SAMPLER_DEFAULT, + descriptors[1], + NULL, + &mask_rect, + }); g_object_unref (source_image); } @@ -3275,10 +3295,20 @@ gsk_gpu_node_processor_add_fill_node (GskGpuNodeProcessor *self, &self->offset, self->opacity, GSK_MASK_MODE_ALPHA, - descriptors[0], - &source_rect, - descriptors[1], - &clip_bounds); + &(GskGpuShaderImage) { + source_image, + GSK_GPU_SAMPLER_DEFAULT, + descriptors[0], + NULL, + &source_rect, + }, + &(GskGpuShaderImage) { + mask_image, + GSK_GPU_SAMPLER_DEFAULT, + descriptors[1], + NULL, + &clip_bounds, + }); g_object_unref (source_image); } @@ -3373,10 +3403,20 @@ gsk_gpu_node_processor_add_stroke_node (GskGpuNodeProcessor *self, &self->offset, self->opacity, GSK_MASK_MODE_ALPHA, - descriptors[0], - &source_rect, - descriptors[1], - &clip_bounds); + &(GskGpuShaderImage) { + source_image, + GSK_GPU_SAMPLER_DEFAULT, + descriptors[0], + NULL, + &source_rect, + }, + &(GskGpuShaderImage) { + mask_image, + GSK_GPU_SAMPLER_DEFAULT, + descriptors[1], + NULL, + &clip_bounds, + }); g_object_unref (source_image); } From 71e412e8f89ec8614587b3d93c25440606d7e194 Mon Sep 17 00:00:00 2001 From: Benjamin Otte Date: Fri, 19 Jul 2024 03:26:53 +0200 Subject: [PATCH 06/28] gpu: Use GskGpuShaderImage for convert ops --- gsk/gpu/gskgpuconvertop.c | 24 +++++++++++------------- gsk/gpu/gskgpuconvertopprivate.h | 4 +--- gsk/gpu/gskgpunodeprocessor.c | 20 ++++++++++++++------ 3 files changed, 26 insertions(+), 22 deletions(-) diff --git a/gsk/gpu/gskgpuconvertop.c b/gsk/gpu/gskgpuconvertop.c index 896336bea6..900edd6a17 100644 --- a/gsk/gpu/gskgpuconvertop.c +++ b/gsk/gpu/gskgpuconvertop.c @@ -54,16 +54,14 @@ static const GskGpuShaderOpClass GSK_GPU_CONVERT_OP_CLASS = { }; void -gsk_gpu_convert_op (GskGpuFrame *frame, - GskGpuShaderClip clip, - GskGpuColorStates color_states, - float opacity, - GskGpuDescriptors *desc, - guint32 descriptor, - gboolean straight_alpha, - const graphene_rect_t *rect, - const graphene_point_t *offset, - const graphene_rect_t *tex_rect) +gsk_gpu_convert_op (GskGpuFrame *frame, + GskGpuShaderClip clip, + GskGpuColorStates color_states, + float opacity, + GskGpuDescriptors *desc, + gboolean straight_alpha, + const graphene_point_t *offset, + const GskGpuShaderImage *image) { GskGpuConvertInstance *instance; @@ -76,9 +74,9 @@ gsk_gpu_convert_op (GskGpuFrame *frame, desc, &instance); - gsk_gpu_rect_to_float (rect, offset, instance->rect); - gsk_gpu_rect_to_float (tex_rect, offset, instance->tex_rect); - instance->tex_id = descriptor; + gsk_gpu_rect_to_float (image->coverage, offset, instance->rect); + gsk_gpu_rect_to_float (image->bounds, offset, instance->tex_rect); + instance->tex_id = image->descriptor; instance->opacity = opacity; } diff --git a/gsk/gpu/gskgpuconvertopprivate.h b/gsk/gpu/gskgpuconvertopprivate.h index cdde8deb98..b4b79d05f3 100644 --- a/gsk/gpu/gskgpuconvertopprivate.h +++ b/gsk/gpu/gskgpuconvertopprivate.h @@ -11,11 +11,9 @@ void gsk_gpu_convert_op (GskGpuF GskGpuColorStates color_states, float opacity, GskGpuDescriptors *desc, - guint32 descriptor, gboolean straight_alpha, - const graphene_rect_t *rect, const graphene_point_t *offset, - const graphene_rect_t *tex_rect); + const GskGpuShaderImage *image); G_END_DECLS diff --git a/gsk/gpu/gskgpunodeprocessor.c b/gsk/gpu/gskgpunodeprocessor.c index 82d586f985..ba2461abbc 100644 --- a/gsk/gpu/gskgpunodeprocessor.c +++ b/gsk/gpu/gskgpunodeprocessor.c @@ -548,11 +548,15 @@ gsk_gpu_node_processor_image_op (GskGpuNodeProcessor *self, TRUE), self->opacity, self->desc, - descriptor, straight_alpha, - rect, &self->offset, - tex_rect); + &(GskGpuShaderImage) { + image, + sampler, + descriptor, + rect, + tex_rect + }); } else { @@ -4070,11 +4074,15 @@ gsk_gpu_node_processor_process (GskGpuFrame *frame, gsk_gpu_node_processor_color_states_explicit (&self, ccs, TRUE), self.opacity, self.desc, - descriptor, FALSE, - &node->bounds, &self.offset, - &tex_rect); + &(GskGpuShaderImage) { + image, + GSK_GPU_SAMPLER_DEFAULT, + descriptor, + &node->bounds, + &tex_rect + }); gsk_gpu_render_pass_end_op (frame, target, From 52db54e8031ceb801a5ec55d77fe64aa18a5ea04 Mon Sep 17 00:00:00 2001 From: Benjamin Otte Date: Fri, 19 Jul 2024 12:11:40 +0200 Subject: [PATCH 07/28] gpu: Use GskGpuShaderImage for crossfade ops --- gsk/gpu/gskgpucrossfadeop.c | 30 ++++++++++++++---------------- gsk/gpu/gskgpucrossfadeopprivate.h | 6 ++---- gsk/gpu/gskgpunodeprocessor.c | 18 ++++++++++++++---- 3 files changed, 30 insertions(+), 24 deletions(-) diff --git a/gsk/gpu/gskgpucrossfadeop.c b/gsk/gpu/gskgpucrossfadeop.c index 6c82a63b28..4c9e87f626 100644 --- a/gsk/gpu/gskgpucrossfadeop.c +++ b/gsk/gpu/gskgpucrossfadeop.c @@ -50,18 +50,16 @@ static const GskGpuShaderOpClass GSK_GPU_CROSS_FADE_OP_CLASS = { }; void -gsk_gpu_cross_fade_op (GskGpuFrame *frame, - GskGpuShaderClip clip, - GskGpuColorStates color_states, - GskGpuDescriptors *desc, - const graphene_rect_t *rect, - const graphene_point_t *offset, - float opacity, - float progress, - guint32 start_descriptor, - const graphene_rect_t *start_rect, - guint32 end_descriptor, - const graphene_rect_t *end_rect) +gsk_gpu_cross_fade_op (GskGpuFrame *frame, + GskGpuShaderClip clip, + GskGpuColorStates color_states, + GskGpuDescriptors *desc, + const graphene_rect_t *rect, + const graphene_point_t *offset, + float opacity, + float progress, + const GskGpuShaderImage *start, + const GskGpuShaderImage *end) { GskGpuCrossfadeInstance *instance; @@ -76,8 +74,8 @@ gsk_gpu_cross_fade_op (GskGpuFrame *frame, gsk_gpu_rect_to_float (rect, offset, instance->rect); instance->opacity_progress[0] = opacity; instance->opacity_progress[1] = progress; - gsk_gpu_rect_to_float (start_rect, offset, instance->start_rect); - instance->start_id = start_descriptor; - gsk_gpu_rect_to_float (end_rect, offset, instance->end_rect); - instance->end_id = end_descriptor; + gsk_gpu_rect_to_float (start->bounds, offset, instance->start_rect); + instance->start_id = start->descriptor; + gsk_gpu_rect_to_float (end->bounds, offset, instance->end_rect); + instance->end_id = end->descriptor; } diff --git a/gsk/gpu/gskgpucrossfadeopprivate.h b/gsk/gpu/gskgpucrossfadeopprivate.h index 0e7a89611d..ceb7d1fcc1 100644 --- a/gsk/gpu/gskgpucrossfadeopprivate.h +++ b/gsk/gpu/gskgpucrossfadeopprivate.h @@ -14,10 +14,8 @@ void gsk_gpu_cross_fade_op (GskGpuF const graphene_point_t *offset, float opacity, float progress, - guint32 start_descriptor, - const graphene_rect_t *start_rect, - guint32 end_descriptor, - const graphene_rect_t *end_rect); + const GskGpuShaderImage *start, + const GskGpuShaderImage *end); G_END_DECLS diff --git a/gsk/gpu/gskgpunodeprocessor.c b/gsk/gpu/gskgpunodeprocessor.c index ba2461abbc..77ea9178a8 100644 --- a/gsk/gpu/gskgpunodeprocessor.c +++ b/gsk/gpu/gskgpunodeprocessor.c @@ -2739,10 +2739,20 @@ gsk_gpu_node_processor_add_cross_fade_node (GskGpuNodeProcessor *self, &self->offset, self->opacity, progress, - descriptors[0], - &start_rect, - descriptors[1], - &end_rect); + &(GskGpuShaderImage) { + start_image, + GSK_GPU_SAMPLER_DEFAULT, + descriptors[0], + NULL, + &start_rect + }, + &(GskGpuShaderImage) { + end_image, + GSK_GPU_SAMPLER_DEFAULT, + descriptors[1], + NULL, + &end_rect + }); g_object_unref (end_image); g_object_unref (start_image); From 68baa9346038e171555f427fa9a52bcae51547fc Mon Sep 17 00:00:00 2001 From: Benjamin Otte Date: Fri, 19 Jul 2024 12:21:28 +0200 Subject: [PATCH 08/28] gpu: Use GskGpuShaderImage for blur ops --- gsk/gpu/gskgpublurop.c | 68 +++++++++++++++-------------------- gsk/gpu/gskgpubluropprivate.h | 8 ++--- gsk/gpu/gskgpunodeprocessor.c | 33 ++++++++++++----- 3 files changed, 55 insertions(+), 54 deletions(-) diff --git a/gsk/gpu/gskgpublurop.c b/gsk/gpu/gskgpublurop.c index 24efc0ceeb..0420d8aed2 100644 --- a/gsk/gpu/gskgpublurop.c +++ b/gsk/gpu/gskgpublurop.c @@ -53,17 +53,15 @@ static const GskGpuShaderOpClass GSK_GPU_BLUR_OP_CLASS = { }; static void -gsk_gpu_blur_op_full (GskGpuFrame *frame, - GskGpuShaderClip clip, - GskGpuColorStates color_states, - guint32 variation, - GskGpuDescriptors *desc, - guint32 descriptor, - const graphene_rect_t *rect, - const graphene_point_t *offset, - const graphene_rect_t *tex_rect, - const graphene_vec2_t *blur_direction, - float blur_color[4]) +gsk_gpu_blur_op_full (GskGpuFrame *frame, + GskGpuShaderClip clip, + GskGpuColorStates color_states, + guint32 variation, + GskGpuDescriptors *desc, + const graphene_point_t *offset, + const GskGpuShaderImage *image, + const graphene_vec2_t *blur_direction, + float blur_color[4]) { GskGpuBlurInstance *instance; @@ -75,58 +73,50 @@ gsk_gpu_blur_op_full (GskGpuFrame *frame, desc, &instance); - gsk_gpu_rect_to_float (rect, offset, instance->rect); - gsk_gpu_rect_to_float (tex_rect, offset, instance->tex_rect); + gsk_gpu_rect_to_float (image->coverage, offset, instance->rect); + gsk_gpu_rect_to_float (image->bounds, offset, instance->tex_rect); graphene_vec2_to_float (blur_direction, instance->blur_direction); gsk_gpu_color_to_float (blur_color, instance->blur_color); - instance->tex_id = descriptor; + instance->tex_id = image->descriptor; } void -gsk_gpu_blur_op (GskGpuFrame *frame, - GskGpuShaderClip clip, - GskGpuColorStates color_states, - GskGpuDescriptors *desc, - guint32 descriptor, - const graphene_rect_t *rect, - const graphene_point_t *offset, - const graphene_rect_t *tex_rect, - const graphene_vec2_t *blur_direction) +gsk_gpu_blur_op (GskGpuFrame *frame, + GskGpuShaderClip clip, + GskGpuColorStates color_states, + GskGpuDescriptors *desc, + const graphene_point_t *offset, + const GskGpuShaderImage *image, + const graphene_vec2_t *blur_direction) { gsk_gpu_blur_op_full (frame, clip, color_states, 0, desc, - descriptor, - rect, offset, - tex_rect, + image, blur_direction, (float[4]) { 1, 1, 1, 1 }); } void -gsk_gpu_blur_shadow_op (GskGpuFrame *frame, - GskGpuShaderClip clip, - GskGpuColorStates color_states, - GskGpuDescriptors *desc, - guint32 descriptor, - const graphene_rect_t *rect, - const graphene_point_t *offset, - const graphene_rect_t *tex_rect, - const graphene_vec2_t *blur_direction, - float shadow_color[4]) +gsk_gpu_blur_shadow_op (GskGpuFrame *frame, + GskGpuShaderClip clip, + GskGpuColorStates color_states, + GskGpuDescriptors *desc, + const graphene_point_t *offset, + const GskGpuShaderImage *image, + const graphene_vec2_t *blur_direction, + float shadow_color[4]) { gsk_gpu_blur_op_full (frame, clip, color_states, VARIATION_COLORIZE, desc, - descriptor, - rect, offset, - tex_rect, + image, blur_direction, shadow_color); } diff --git a/gsk/gpu/gskgpubluropprivate.h b/gsk/gpu/gskgpubluropprivate.h index de00ecf0ce..85f2fab41c 100644 --- a/gsk/gpu/gskgpubluropprivate.h +++ b/gsk/gpu/gskgpubluropprivate.h @@ -10,20 +10,16 @@ void gsk_gpu_blur_op (GskGpuF GskGpuShaderClip clip, GskGpuColorStates color_states, GskGpuDescriptors *desc, - guint32 descriptor, - const graphene_rect_t *rect, const graphene_point_t *offset, - const graphene_rect_t *tex_rect, + const GskGpuShaderImage *image, const graphene_vec2_t *blur_direction); void gsk_gpu_blur_shadow_op (GskGpuFrame *frame, GskGpuShaderClip clip, GskGpuColorStates color_states, GskGpuDescriptors *desc, - guint32 descriptor, - const graphene_rect_t *rect, const graphene_point_t *offset, - const graphene_rect_t *tex_rect, + const GskGpuShaderImage *image, const graphene_vec2_t *blur_direction, float shadow_color[4]); diff --git a/gsk/gpu/gskgpunodeprocessor.c b/gsk/gpu/gskgpunodeprocessor.c index 77ea9178a8..a8f0ea61a5 100644 --- a/gsk/gpu/gskgpunodeprocessor.c +++ b/gsk/gpu/gskgpunodeprocessor.c @@ -766,6 +766,7 @@ gsk_gpu_node_processor_blur_op (GskGpuNodeProcessor *self, float blur_radius, const GdkRGBA *shadow_color, GskGpuDescriptors *source_desc, + GskGpuImage *source_image, guint32 source_descriptor, GdkMemoryDepth source_depth, const graphene_rect_t *source_rect) @@ -804,10 +805,14 @@ gsk_gpu_node_processor_blur_op (GskGpuNodeProcessor *self, gsk_gpu_clip_get_shader_clip (&other.clip, &other.offset, &intermediate_rect), gsk_gpu_node_processor_color_states_self (&other), source_desc, - source_descriptor, - &intermediate_rect, &other.offset, - source_rect, + &(GskGpuShaderImage) { + source_image, + GSK_GPU_SAMPLER_TRANSPARENT, + source_descriptor, + &intermediate_rect, + source_rect + }, &direction); gsk_gpu_node_processor_finish_draw (&other, intermediate); @@ -822,10 +827,14 @@ gsk_gpu_node_processor_blur_op (GskGpuNodeProcessor *self, gsk_gpu_clip_get_shader_clip (&self->clip, &real_offset, rect), gsk_gpu_node_processor_color_states_for_rgba (self), self->desc, - intermediate_descriptor, - rect, &real_offset, - &intermediate_rect, + &(GskGpuShaderImage) { + intermediate, + GSK_GPU_SAMPLER_TRANSPARENT, + intermediate_descriptor, + rect, + &intermediate_rect, + }, &direction, GSK_RGBA_TO_VEC4 (shadow_color)); } @@ -835,10 +844,14 @@ gsk_gpu_node_processor_blur_op (GskGpuNodeProcessor *self, gsk_gpu_clip_get_shader_clip (&self->clip, &real_offset, rect), gsk_gpu_node_processor_color_states_self (self), self->desc, - intermediate_descriptor, - rect, &real_offset, - &intermediate_rect, + &(GskGpuShaderImage) { + intermediate, + GSK_GPU_SAMPLER_TRANSPARENT, + intermediate_descriptor, + rect, + &intermediate_rect, + }, &direction); } @@ -2483,6 +2496,7 @@ gsk_gpu_node_processor_add_blur_node (GskGpuNodeProcessor *self, blur_radius, NULL, self->desc, + image, descriptor, gdk_memory_format_get_depth (gsk_gpu_image_get_format (image), gsk_gpu_image_get_flags (image) & GSK_GPU_IMAGE_SRGB), @@ -2553,6 +2567,7 @@ gsk_gpu_node_processor_add_shadow_node (GskGpuNodeProcessor *self, shadow->radius, &shadow->color, desc, + image, descriptor, gdk_memory_format_get_depth (gsk_gpu_image_get_format (image), gsk_gpu_image_get_flags (image) & GSK_GPU_IMAGE_SRGB), From b481fd854f83b8f7b961071cdad6bbd54d2e7142 Mon Sep 17 00:00:00 2001 From: Benjamin Otte Date: Fri, 19 Jul 2024 17:19:56 +0200 Subject: [PATCH 09/28] gpu: Encode number of textures use in every shader Just define GSK_N_TEXTURES in every glsl file, extract that #define in the python parser and emit a static const uint variable "{shader_name}_n_textures" in the generated header. --- gsk/gpu/shaders/generate-header.py | 12 ++++++++++++ gsk/gpu/shaders/gskgpublendmode.glsl | 2 ++ gsk/gpu/shaders/gskgpublur.glsl | 2 ++ gsk/gpu/shaders/gskgpuborder.glsl | 2 ++ gsk/gpu/shaders/gskgpuboxshadow.glsl | 2 ++ gsk/gpu/shaders/gskgpucolor.glsl | 2 ++ gsk/gpu/shaders/gskgpucolorize.glsl | 2 ++ gsk/gpu/shaders/gskgpucolormatrix.glsl | 2 ++ gsk/gpu/shaders/gskgpuconicgradient.glsl | 2 ++ gsk/gpu/shaders/gskgpuconvert.glsl | 2 ++ gsk/gpu/shaders/gskgpucrossfade.glsl | 2 ++ gsk/gpu/shaders/gskgpulineargradient.glsl | 2 ++ gsk/gpu/shaders/gskgpumask.glsl | 2 ++ gsk/gpu/shaders/gskgpuradialgradient.glsl | 2 ++ gsk/gpu/shaders/gskgpuroundedcolor.glsl | 2 ++ gsk/gpu/shaders/gskgputexture.glsl | 2 ++ 16 files changed, 42 insertions(+) diff --git a/gsk/gpu/shaders/generate-header.py b/gsk/gpu/shaders/generate-header.py index 1f161c5b1e..e715bf9721 100644 --- a/gsk/gpu/shaders/generate-header.py +++ b/gsk/gpu/shaders/generate-header.py @@ -7,6 +7,7 @@ import os name = os.path.splitext(os.path.splitext(os.path.basename(sys.argv[1]))[0])[0][6:] var_name = "gsk_gpu_" + name.replace('-', '_') struct_name = "GskGpu" + name.title().replace('-', '') + "Instance" +n_textures = -1 filename = sys.argv[1] with open(filename) as f: @@ -14,6 +15,10 @@ with open(filename) as f: matches = [] for pos, line in enumerate (lines): + match = re.search(r"^#define GSK_N_TEXTURES ([0-9]+)$", line) + if match: + n_textures = int(match.group(1)) + match = re.search(r"^IN\(([0-9]+)\) ([a-z0-9]+) ([a-zA-Z0-9_]+);$", line) if not match: if re.search(r"layout.*\sin\s.*", line): @@ -26,9 +31,16 @@ with open(filename) as f: 'location': int(match.group(1)), 'type': match.group(2)}) +if n_textures < 0: + raise Exception(f'''{filename}: GSK_N_TEXTURES not defined''') +if n_textures > 2: + raise Exception(f'''{filename}: GSK_N_TEXTURES must be <= 2''') + print(f'''/* This file is auto-generated; any change will not be preserved */ #pragma once +#define {var_name}_n_textures {n_textures} + typedef struct _{struct_name} {struct_name}; struct _{struct_name} {{''') diff --git a/gsk/gpu/shaders/gskgpublendmode.glsl b/gsk/gpu/shaders/gskgpublendmode.glsl index 8dee311e1c..46f6ae706f 100644 --- a/gsk/gpu/shaders/gskgpublendmode.glsl +++ b/gsk/gpu/shaders/gskgpublendmode.glsl @@ -1,3 +1,5 @@ +#define GSK_N_TEXTURES 2 + #include "common.glsl" #include "blendmode.glsl" diff --git a/gsk/gpu/shaders/gskgpublur.glsl b/gsk/gpu/shaders/gskgpublur.glsl index c77bd12ed3..71a5bee40e 100644 --- a/gsk/gpu/shaders/gskgpublur.glsl +++ b/gsk/gpu/shaders/gskgpublur.glsl @@ -1,3 +1,5 @@ +#define GSK_N_TEXTURES 1 + #include "common.glsl" /* blur radius (aka in_blur_direction) 0 is NOT supported and MUST be caught before */ diff --git a/gsk/gpu/shaders/gskgpuborder.glsl b/gsk/gpu/shaders/gskgpuborder.glsl index 4418f73159..8b98b2bcee 100644 --- a/gsk/gpu/shaders/gskgpuborder.glsl +++ b/gsk/gpu/shaders/gskgpuborder.glsl @@ -1,3 +1,5 @@ +#define GSK_N_TEXTURES 0 + #include "common.glsl" PASS(0) vec2 _pos; diff --git a/gsk/gpu/shaders/gskgpuboxshadow.glsl b/gsk/gpu/shaders/gskgpuboxshadow.glsl index 374637b741..8e26e43a35 100644 --- a/gsk/gpu/shaders/gskgpuboxshadow.glsl +++ b/gsk/gpu/shaders/gskgpuboxshadow.glsl @@ -1,3 +1,5 @@ +#define GSK_N_TEXTURES 0 + #include "common.glsl" /* blur radius (aka in_blur_direction) 0 is NOT supported and MUST be caught before */ diff --git a/gsk/gpu/shaders/gskgpucolor.glsl b/gsk/gpu/shaders/gskgpucolor.glsl index aa2d4a0be3..3d12c5a914 100644 --- a/gsk/gpu/shaders/gskgpucolor.glsl +++ b/gsk/gpu/shaders/gskgpucolor.glsl @@ -1,3 +1,5 @@ +#define GSK_N_TEXTURES 0 + #include "common.glsl" PASS(0) vec2 _pos; diff --git a/gsk/gpu/shaders/gskgpucolorize.glsl b/gsk/gpu/shaders/gskgpucolorize.glsl index a45582d7ef..6051d9645d 100644 --- a/gsk/gpu/shaders/gskgpucolorize.glsl +++ b/gsk/gpu/shaders/gskgpucolorize.glsl @@ -1,3 +1,5 @@ +#define GSK_N_TEXTURES 1 + #include "common.glsl" PASS(0) vec2 _pos; diff --git a/gsk/gpu/shaders/gskgpucolormatrix.glsl b/gsk/gpu/shaders/gskgpucolormatrix.glsl index 9955c924e5..ba3d0d8cc0 100644 --- a/gsk/gpu/shaders/gskgpucolormatrix.glsl +++ b/gsk/gpu/shaders/gskgpucolormatrix.glsl @@ -1,3 +1,5 @@ +#define GSK_N_TEXTURES 1 + #include "common.glsl" PASS_FLAT(0) mat4 _color_matrix; diff --git a/gsk/gpu/shaders/gskgpuconicgradient.glsl b/gsk/gpu/shaders/gskgpuconicgradient.glsl index 16eaa3e0f7..40e0d07194 100644 --- a/gsk/gpu/shaders/gskgpuconicgradient.glsl +++ b/gsk/gpu/shaders/gskgpuconicgradient.glsl @@ -1,3 +1,5 @@ +#define GSK_N_TEXTURES 0 + #include "common.glsl" #define VARIATION_SUPERSAMPLING ((GSK_VARIATION & (1u << 0)) == (1u << 0)) diff --git a/gsk/gpu/shaders/gskgpuconvert.glsl b/gsk/gpu/shaders/gskgpuconvert.glsl index ba39cee318..2d85820a9d 100644 --- a/gsk/gpu/shaders/gskgpuconvert.glsl +++ b/gsk/gpu/shaders/gskgpuconvert.glsl @@ -1,3 +1,5 @@ +#define GSK_N_TEXTURES 1 + #include "common.glsl" #define VARIATION_OPACITY (1u << 0) diff --git a/gsk/gpu/shaders/gskgpucrossfade.glsl b/gsk/gpu/shaders/gskgpucrossfade.glsl index c7665d9c5a..7d6051aec6 100644 --- a/gsk/gpu/shaders/gskgpucrossfade.glsl +++ b/gsk/gpu/shaders/gskgpucrossfade.glsl @@ -1,3 +1,5 @@ +#define GSK_N_TEXTURES 2 + #include "common.glsl" PASS(0) vec2 _pos; diff --git a/gsk/gpu/shaders/gskgpulineargradient.glsl b/gsk/gpu/shaders/gskgpulineargradient.glsl index 92b38170c7..75de861ad4 100644 --- a/gsk/gpu/shaders/gskgpulineargradient.glsl +++ b/gsk/gpu/shaders/gskgpulineargradient.glsl @@ -1,3 +1,5 @@ +#define GSK_N_TEXTURES 0 + #include "common.glsl" #define VARIATION_SUPERSAMPLING ((GSK_VARIATION & (1u << 0)) == (1u << 0)) diff --git a/gsk/gpu/shaders/gskgpumask.glsl b/gsk/gpu/shaders/gskgpumask.glsl index 55dd717ed1..27ac1bd431 100644 --- a/gsk/gpu/shaders/gskgpumask.glsl +++ b/gsk/gpu/shaders/gskgpumask.glsl @@ -1,3 +1,5 @@ +#define GSK_N_TEXTURES 2 + #include "common.glsl" #define VARIATION_MASK_MODE GSK_VARIATION diff --git a/gsk/gpu/shaders/gskgpuradialgradient.glsl b/gsk/gpu/shaders/gskgpuradialgradient.glsl index 2d108445ad..a276533575 100644 --- a/gsk/gpu/shaders/gskgpuradialgradient.glsl +++ b/gsk/gpu/shaders/gskgpuradialgradient.glsl @@ -1,3 +1,5 @@ +#define GSK_N_TEXTURES 0 + #include "common.glsl" #define VARIATION_SUPERSAMPLING ((GSK_VARIATION & (1u << 0)) == (1u << 0)) diff --git a/gsk/gpu/shaders/gskgpuroundedcolor.glsl b/gsk/gpu/shaders/gskgpuroundedcolor.glsl index 8ebd1a6beb..1ad040d955 100644 --- a/gsk/gpu/shaders/gskgpuroundedcolor.glsl +++ b/gsk/gpu/shaders/gskgpuroundedcolor.glsl @@ -1,3 +1,5 @@ +#define GSK_N_TEXTURES 0 + #include "common.glsl" PASS(0) vec2 _pos; diff --git a/gsk/gpu/shaders/gskgputexture.glsl b/gsk/gpu/shaders/gskgputexture.glsl index 33d51f9c6a..4fc29a0045 100644 --- a/gsk/gpu/shaders/gskgputexture.glsl +++ b/gsk/gpu/shaders/gskgputexture.glsl @@ -1,3 +1,5 @@ +#define GSK_N_TEXTURES 1 + #include "common.glsl" PASS(0) vec2 _pos; From ea6253c1df01c5552d74899754fc7ea068fc7dfc Mon Sep 17 00:00:00 2001 From: Benjamin Otte Date: Fri, 19 Jul 2024 17:25:03 +0200 Subject: [PATCH 10/28] gpu: Add a member in ShaderOpClass for number of textures This just puts the number from the header into a strcut where it can be accessed. --- gsk/gpu/gskgpublendmodeop.c | 1 + gsk/gpu/gskgpublurop.c | 1 + gsk/gpu/gskgpuborderop.c | 1 + gsk/gpu/gskgpuboxshadowop.c | 1 + gsk/gpu/gskgpucolorizeop.c | 1 + gsk/gpu/gskgpucolormatrixop.c | 1 + gsk/gpu/gskgpucolorop.c | 1 + gsk/gpu/gskgpuconicgradientop.c | 1 + gsk/gpu/gskgpuconvertop.c | 1 + gsk/gpu/gskgpucrossfadeop.c | 1 + gsk/gpu/gskgpulineargradientop.c | 1 + gsk/gpu/gskgpumaskop.c | 1 + gsk/gpu/gskgpuradialgradientop.c | 1 + gsk/gpu/gskgpuroundedcolorop.c | 1 + gsk/gpu/gskgpushaderopprivate.h | 1 + gsk/gpu/gskgputextureop.c | 1 + 16 files changed, 16 insertions(+) diff --git a/gsk/gpu/gskgpublendmodeop.c b/gsk/gpu/gskgpublendmodeop.c index e2cb81af97..e766e18f54 100644 --- a/gsk/gpu/gskgpublendmodeop.c +++ b/gsk/gpu/gskgpublendmodeop.c @@ -42,6 +42,7 @@ static const GskGpuShaderOpClass GSK_GPU_BLEND_MODE_OP_CLASS = { gsk_gpu_shader_op_gl_command }, "gskgpublendmode", + gsk_gpu_blendmode_n_textures, sizeof (GskGpuBlendmodeInstance), #ifdef GDK_RENDERING_VULKAN &gsk_gpu_blendmode_info, diff --git a/gsk/gpu/gskgpublurop.c b/gsk/gpu/gskgpublurop.c index 0420d8aed2..425bebb631 100644 --- a/gsk/gpu/gskgpublurop.c +++ b/gsk/gpu/gskgpublurop.c @@ -43,6 +43,7 @@ static const GskGpuShaderOpClass GSK_GPU_BLUR_OP_CLASS = { gsk_gpu_shader_op_gl_command }, "gskgpublur", + gsk_gpu_blur_n_textures, sizeof (GskGpuBlurInstance), #ifdef GDK_RENDERING_VULKAN &gsk_gpu_blur_info, diff --git a/gsk/gpu/gskgpuborderop.c b/gsk/gpu/gskgpuborderop.c index e89deb8254..d1f80fe778 100644 --- a/gsk/gpu/gskgpuborderop.c +++ b/gsk/gpu/gskgpuborderop.c @@ -84,6 +84,7 @@ static const GskGpuShaderOpClass GSK_GPU_BORDER_OP_CLASS = { gsk_gpu_border_op_gl_command }, "gskgpuborder", + gsk_gpu_border_n_textures, sizeof (GskGpuBorderInstance), #ifdef GDK_RENDERING_VULKAN &gsk_gpu_border_info, diff --git a/gsk/gpu/gskgpuboxshadowop.c b/gsk/gpu/gskgpuboxshadowop.c index 6e84509a70..45933e92ba 100644 --- a/gsk/gpu/gskgpuboxshadowop.c +++ b/gsk/gpu/gskgpuboxshadowop.c @@ -63,6 +63,7 @@ static const GskGpuShaderOpClass GSK_GPU_BOX_SHADOW_OP_CLASS = { gsk_gpu_box_shadow_op_gl_command }, "gskgpuboxshadow", + gsk_gpu_boxshadow_n_textures, sizeof (GskGpuBoxshadowInstance), #ifdef GDK_RENDERING_VULKAN &gsk_gpu_boxshadow_info, diff --git a/gsk/gpu/gskgpucolorizeop.c b/gsk/gpu/gskgpucolorizeop.c index 045e84495a..0bf1d8c6a7 100644 --- a/gsk/gpu/gskgpucolorizeop.c +++ b/gsk/gpu/gskgpucolorizeop.c @@ -39,6 +39,7 @@ static const GskGpuShaderOpClass GSK_GPU_COLORIZE_OP_CLASS = { gsk_gpu_shader_op_gl_command }, "gskgpucolorize", + gsk_gpu_colorize_n_textures, sizeof (GskGpuColorizeInstance), #ifdef GDK_RENDERING_VULKAN &gsk_gpu_colorize_info, diff --git a/gsk/gpu/gskgpucolormatrixop.c b/gsk/gpu/gskgpucolormatrixop.c index 597a7b9e62..354e48bc35 100644 --- a/gsk/gpu/gskgpucolormatrixop.c +++ b/gsk/gpu/gskgpucolormatrixop.c @@ -38,6 +38,7 @@ static const GskGpuShaderOpClass GSK_GPU_COLOR_MATRIX_OP_CLASS = { gsk_gpu_shader_op_gl_command }, "gskgpucolormatrix", + gsk_gpu_colormatrix_n_textures, sizeof (GskGpuColormatrixInstance), #ifdef GDK_RENDERING_VULKAN &gsk_gpu_colormatrix_info, diff --git a/gsk/gpu/gskgpucolorop.c b/gsk/gpu/gskgpucolorop.c index 06582ad019..78ab08bade 100644 --- a/gsk/gpu/gskgpucolorop.c +++ b/gsk/gpu/gskgpucolorop.c @@ -40,6 +40,7 @@ static const GskGpuShaderOpClass GSK_GPU_COLOR_OP_CLASS = { gsk_gpu_shader_op_gl_command }, "gskgpucolor", + gsk_gpu_color_n_textures, sizeof (GskGpuColorInstance), #ifdef GDK_RENDERING_VULKAN &gsk_gpu_color_info, diff --git a/gsk/gpu/gskgpuconicgradientop.c b/gsk/gpu/gskgpuconicgradientop.c index f664c76096..372758780d 100644 --- a/gsk/gpu/gskgpuconicgradientop.c +++ b/gsk/gpu/gskgpuconicgradientop.c @@ -39,6 +39,7 @@ static const GskGpuShaderOpClass GSK_GPU_CONIC_GRADIENT_OP_CLASS = { gsk_gpu_shader_op_gl_command }, "gskgpuconicgradient", + gsk_gpu_conicgradient_n_textures, sizeof (GskGpuConicgradientInstance), #ifdef GDK_RENDERING_VULKAN &gsk_gpu_conicgradient_info, diff --git a/gsk/gpu/gskgpuconvertop.c b/gsk/gpu/gskgpuconvertop.c index 900edd6a17..a420d03a14 100644 --- a/gsk/gpu/gskgpuconvertop.c +++ b/gsk/gpu/gskgpuconvertop.c @@ -44,6 +44,7 @@ static const GskGpuShaderOpClass GSK_GPU_CONVERT_OP_CLASS = { gsk_gpu_shader_op_gl_command }, "gskgpuconvert", + gsk_gpu_convert_n_textures, sizeof (GskGpuConvertInstance), #ifdef GDK_RENDERING_VULKAN &gsk_gpu_convert_info, diff --git a/gsk/gpu/gskgpucrossfadeop.c b/gsk/gpu/gskgpucrossfadeop.c index 4c9e87f626..70ee9eb3f5 100644 --- a/gsk/gpu/gskgpucrossfadeop.c +++ b/gsk/gpu/gskgpucrossfadeop.c @@ -40,6 +40,7 @@ static const GskGpuShaderOpClass GSK_GPU_CROSS_FADE_OP_CLASS = { gsk_gpu_shader_op_gl_command }, "gskgpucrossfade", + gsk_gpu_crossfade_n_textures, sizeof (GskGpuCrossfadeInstance), #ifdef GDK_RENDERING_VULKAN &gsk_gpu_crossfade_info, diff --git a/gsk/gpu/gskgpulineargradientop.c b/gsk/gpu/gskgpulineargradientop.c index a7b09ebff3..8e2d41c459 100644 --- a/gsk/gpu/gskgpulineargradientop.c +++ b/gsk/gpu/gskgpulineargradientop.c @@ -42,6 +42,7 @@ static const GskGpuShaderOpClass GSK_GPU_LINEAR_GRADIENT_OP_CLASS = { gsk_gpu_shader_op_gl_command }, "gskgpulineargradient", + gsk_gpu_lineargradient_n_textures, sizeof (GskGpuLineargradientInstance), #ifdef GDK_RENDERING_VULKAN &gsk_gpu_lineargradient_info, diff --git a/gsk/gpu/gskgpumaskop.c b/gsk/gpu/gskgpumaskop.c index 6e36a5d24c..a6db7dbd1d 100644 --- a/gsk/gpu/gskgpumaskop.c +++ b/gsk/gpu/gskgpumaskop.c @@ -41,6 +41,7 @@ static const GskGpuShaderOpClass GSK_GPU_MASK_OP_CLASS = { gsk_gpu_shader_op_gl_command }, "gskgpumask", + gsk_gpu_mask_n_textures, sizeof (GskGpuMaskInstance), #ifdef GDK_RENDERING_VULKAN &gsk_gpu_mask_info, diff --git a/gsk/gpu/gskgpuradialgradientop.c b/gsk/gpu/gskgpuradialgradientop.c index b9d2b3d498..621e06787d 100644 --- a/gsk/gpu/gskgpuradialgradientop.c +++ b/gsk/gpu/gskgpuradialgradientop.c @@ -42,6 +42,7 @@ static const GskGpuShaderOpClass GSK_GPU_RADIAL_GRADIENT_OP_CLASS = { gsk_gpu_shader_op_gl_command }, "gskgpuradialgradient", + gsk_gpu_radialgradient_n_textures, sizeof (GskGpuRadialgradientInstance), #ifdef GDK_RENDERING_VULKAN &gsk_gpu_radialgradient_info, diff --git a/gsk/gpu/gskgpuroundedcolorop.c b/gsk/gpu/gskgpuroundedcolorop.c index f9e94d8b58..6b05ac5e75 100644 --- a/gsk/gpu/gskgpuroundedcolorop.c +++ b/gsk/gpu/gskgpuroundedcolorop.c @@ -39,6 +39,7 @@ static const GskGpuShaderOpClass GSK_GPU_ROUNDED_COLOR_OP_CLASS = { gsk_gpu_shader_op_gl_command }, "gskgpuroundedcolor", + gsk_gpu_roundedcolor_n_textures, sizeof (GskGpuRoundedcolorInstance), #ifdef GDK_RENDERING_VULKAN &gsk_gpu_roundedcolor_info, diff --git a/gsk/gpu/gskgpushaderopprivate.h b/gsk/gpu/gskgpushaderopprivate.h index 4bc7871793..1131c1eae8 100644 --- a/gsk/gpu/gskgpushaderopprivate.h +++ b/gsk/gpu/gskgpushaderopprivate.h @@ -35,6 +35,7 @@ struct _GskGpuShaderOpClass GskGpuOpClass parent_class; const char * shader_name; + gsize n_textures; gsize vertex_size; #ifdef GDK_RENDERING_VULKAN const VkPipelineVertexInputStateCreateInfo *vertex_input_state; diff --git a/gsk/gpu/gskgputextureop.c b/gsk/gpu/gskgputextureop.c index f54dc8cb1c..828c75d013 100644 --- a/gsk/gpu/gskgputextureop.c +++ b/gsk/gpu/gskgputextureop.c @@ -38,6 +38,7 @@ static const GskGpuShaderOpClass GSK_GPU_TEXTURE_OP_CLASS = { gsk_gpu_shader_op_gl_command }, "gskgputexture", + gsk_gpu_texture_n_textures, sizeof (GskGpuTextureInstance), #ifdef GDK_RENDERING_VULKAN &gsk_gpu_texture_info, From dc9f0869b14067e27591dfcf043f37ff6b1ad911 Mon Sep 17 00:00:00 2001 From: Benjamin Otte Date: Fri, 19 Jul 2024 18:02:06 +0200 Subject: [PATCH 11/28] gpu: Pass used images to shader ops This by itself is just more work refcounting all those images, but there's actually a goal here, that will become visible in future commits. But this is split out for correctness and benchmarking purposes (the overhead from refcounting seems to be negligible on my computer). --- gsk/gpu/gskgpublendmodeop.c | 2 ++ gsk/gpu/gskgpublurop.c | 2 ++ gsk/gpu/gskgpuborderop.c | 2 ++ gsk/gpu/gskgpuboxshadowop.c | 2 ++ gsk/gpu/gskgpucolorizeop.c | 2 ++ gsk/gpu/gskgpucolormatrixop.c | 2 ++ gsk/gpu/gskgpucolorop.c | 2 ++ gsk/gpu/gskgpuconicgradientop.c | 2 ++ gsk/gpu/gskgpuconvertop.c | 2 ++ gsk/gpu/gskgpucrossfadeop.c | 2 ++ gsk/gpu/gskgpulineargradientop.c | 2 ++ gsk/gpu/gskgpumaskop.c | 2 ++ gsk/gpu/gskgpuradialgradientop.c | 2 ++ gsk/gpu/gskgpuroundedcolorop.c | 2 ++ gsk/gpu/gskgpushaderop.c | 20 ++++++++++++++++---- gsk/gpu/gskgpushaderopprivate.h | 4 ++++ gsk/gpu/gskgputextureop.c | 2 ++ 17 files changed, 50 insertions(+), 4 deletions(-) diff --git a/gsk/gpu/gskgpublendmodeop.c b/gsk/gpu/gskgpublendmodeop.c index e766e18f54..5fa68b5ec7 100644 --- a/gsk/gpu/gskgpublendmodeop.c +++ b/gsk/gpu/gskgpublendmodeop.c @@ -71,6 +71,8 @@ gsk_gpu_blend_mode_op (GskGpuFrame *frame, blend_mode, clip, desc, + (GskGpuImage *[2]) { bottom->image, top->image }, + (GskGpuSampler[2]) { bottom->sampler, top->sampler }, &instance); gsk_gpu_rect_to_float (rect, offset, instance->rect); diff --git a/gsk/gpu/gskgpublurop.c b/gsk/gpu/gskgpublurop.c index 425bebb631..390884fa17 100644 --- a/gsk/gpu/gskgpublurop.c +++ b/gsk/gpu/gskgpublurop.c @@ -72,6 +72,8 @@ gsk_gpu_blur_op_full (GskGpuFrame *frame, variation, clip, desc, + (GskGpuImage *[1]) { image->image }, + (GskGpuSampler[1]) { image->sampler }, &instance); gsk_gpu_rect_to_float (image->coverage, offset, instance->rect); diff --git a/gsk/gpu/gskgpuborderop.c b/gsk/gpu/gskgpuborderop.c index d1f80fe778..c8313724ec 100644 --- a/gsk/gpu/gskgpuborderop.c +++ b/gsk/gpu/gskgpuborderop.c @@ -113,6 +113,8 @@ gsk_gpu_border_op (GskGpuFrame *frame, 0, clip, NULL, + NULL, + NULL, &instance); gsk_rounded_rect_to_float (outline, offset, instance->outline); diff --git a/gsk/gpu/gskgpuboxshadowop.c b/gsk/gpu/gskgpuboxshadowop.c index 45933e92ba..92c8aa8a56 100644 --- a/gsk/gpu/gskgpuboxshadowop.c +++ b/gsk/gpu/gskgpuboxshadowop.c @@ -97,6 +97,8 @@ gsk_gpu_box_shadow_op (GskGpuFrame *frame, inset ? VARIATION_INSET : 0, clip, NULL, + NULL, + NULL, &instance); gsk_gpu_rect_to_float (bounds, offset, instance->bounds); diff --git a/gsk/gpu/gskgpucolorizeop.c b/gsk/gpu/gskgpucolorizeop.c index 0bf1d8c6a7..8e62bcc05b 100644 --- a/gsk/gpu/gskgpucolorizeop.c +++ b/gsk/gpu/gskgpucolorizeop.c @@ -66,6 +66,8 @@ gsk_gpu_colorize_op (GskGpuFrame *frame, 0, clip, descriptors, + (GskGpuImage *[1]) { image->image }, + (GskGpuSampler[1]) { image->sampler }, &instance); gsk_gpu_rect_to_float (image->coverage ? image->coverage : image->bounds, offset, instance->rect); diff --git a/gsk/gpu/gskgpucolormatrixop.c b/gsk/gpu/gskgpucolormatrixop.c index 354e48bc35..26a0fa553f 100644 --- a/gsk/gpu/gskgpucolormatrixop.c +++ b/gsk/gpu/gskgpucolormatrixop.c @@ -66,6 +66,8 @@ gsk_gpu_color_matrix_op (GskGpuFrame *frame, 0, clip, desc, + (GskGpuImage *[1]) { image->image }, + (GskGpuSampler[1]) { image->sampler }, &instance); gsk_gpu_rect_to_float (image->coverage, offset, instance->rect); diff --git a/gsk/gpu/gskgpucolorop.c b/gsk/gpu/gskgpucolorop.c index 78ab08bade..21930c76da 100644 --- a/gsk/gpu/gskgpucolorop.c +++ b/gsk/gpu/gskgpucolorop.c @@ -66,6 +66,8 @@ gsk_gpu_color_op (GskGpuFrame *frame, 0, clip, NULL, + NULL, + NULL, &instance); gsk_gpu_rect_to_float (rect, offset, instance->rect); diff --git a/gsk/gpu/gskgpuconicgradientop.c b/gsk/gpu/gskgpuconicgradientop.c index 372758780d..5c56cb49a5 100644 --- a/gsk/gpu/gskgpuconicgradientop.c +++ b/gsk/gpu/gskgpuconicgradientop.c @@ -73,6 +73,8 @@ gsk_gpu_conic_gradient_op (GskGpuFrame *frame, (gsk_gpu_frame_should_optimize (frame, GSK_GPU_OPTIMIZE_GRADIENTS) ? VARIATION_SUPERSAMPLING : 0), clip, NULL, + NULL, + NULL, &instance); gsk_gpu_rect_to_float (rect, offset, instance->rect); diff --git a/gsk/gpu/gskgpuconvertop.c b/gsk/gpu/gskgpuconvertop.c index a420d03a14..77aa1235ea 100644 --- a/gsk/gpu/gskgpuconvertop.c +++ b/gsk/gpu/gskgpuconvertop.c @@ -73,6 +73,8 @@ gsk_gpu_convert_op (GskGpuFrame *frame, (straight_alpha ? VARIATION_STRAIGHT_ALPHA : 0), clip, desc, + (GskGpuImage *[1]) { image->image }, + (GskGpuSampler[1]) { image->sampler }, &instance); gsk_gpu_rect_to_float (image->coverage, offset, instance->rect); diff --git a/gsk/gpu/gskgpucrossfadeop.c b/gsk/gpu/gskgpucrossfadeop.c index 70ee9eb3f5..f86a0c20af 100644 --- a/gsk/gpu/gskgpucrossfadeop.c +++ b/gsk/gpu/gskgpucrossfadeop.c @@ -70,6 +70,8 @@ gsk_gpu_cross_fade_op (GskGpuFrame *frame, 0, clip, desc, + (GskGpuImage *[2]) { start->image, end->image }, + (GskGpuSampler[2]) { start->sampler, end->sampler }, &instance); gsk_gpu_rect_to_float (rect, offset, instance->rect); diff --git a/gsk/gpu/gskgpulineargradientop.c b/gsk/gpu/gskgpulineargradientop.c index 8e2d41c459..8f0c0f064e 100644 --- a/gsk/gpu/gskgpulineargradientop.c +++ b/gsk/gpu/gskgpulineargradientop.c @@ -78,6 +78,8 @@ gsk_gpu_linear_gradient_op (GskGpuFrame *frame, (gsk_gpu_frame_should_optimize (frame, GSK_GPU_OPTIMIZE_GRADIENTS) ? VARIATION_SUPERSAMPLING : 0), clip, NULL, + NULL, + NULL, &instance); gsk_gpu_rect_to_float (rect, offset, instance->rect); diff --git a/gsk/gpu/gskgpumaskop.c b/gsk/gpu/gskgpumaskop.c index a6db7dbd1d..b58efe0a12 100644 --- a/gsk/gpu/gskgpumaskop.c +++ b/gsk/gpu/gskgpumaskop.c @@ -70,6 +70,8 @@ gsk_gpu_mask_op (GskGpuFrame *frame, mask_mode, clip, desc, + (GskGpuImage *[2]) { source->image, mask->image }, + (GskGpuSampler[2]) { source->sampler, mask->sampler }, &instance); gsk_gpu_rect_to_float (rect, offset, instance->rect); diff --git a/gsk/gpu/gskgpuradialgradientop.c b/gsk/gpu/gskgpuradialgradientop.c index 621e06787d..c36892d4cc 100644 --- a/gsk/gpu/gskgpuradialgradientop.c +++ b/gsk/gpu/gskgpuradialgradientop.c @@ -80,6 +80,8 @@ gsk_gpu_radial_gradient_op (GskGpuFrame *frame, (gsk_gpu_frame_should_optimize (frame, GSK_GPU_OPTIMIZE_GRADIENTS) ? VARIATION_SUPERSAMPLING : 0), clip, NULL, + NULL, + NULL, &instance); gsk_gpu_rect_to_float (rect, offset, instance->rect); diff --git a/gsk/gpu/gskgpuroundedcolorop.c b/gsk/gpu/gskgpuroundedcolorop.c index 6b05ac5e75..d1b930b853 100644 --- a/gsk/gpu/gskgpuroundedcolorop.c +++ b/gsk/gpu/gskgpuroundedcolorop.c @@ -65,6 +65,8 @@ gsk_gpu_rounded_color_op (GskGpuFrame *frame, 0, clip, NULL, + NULL, + NULL, &instance); gsk_rounded_rect_to_float (outline, offset, instance->outline); diff --git a/gsk/gpu/gskgpushaderop.c b/gsk/gpu/gskgpushaderop.c index cf3694bf94..599f7a20da 100644 --- a/gsk/gpu/gskgpushaderop.c +++ b/gsk/gpu/gskgpushaderop.c @@ -27,6 +27,8 @@ gsk_gpu_shader_op_finish (GskGpuOp *op) GskGpuShaderOp *self = (GskGpuShaderOp *) op; g_clear_object (&self->desc); + g_clear_object (&self->images[0]); + g_clear_object (&self->images[1]); } void @@ -192,7 +194,9 @@ gsk_gpu_shader_op_gl_command_n (GskGpuOp *op, next_shader->color_states != self->color_states || next_shader->variation != self->variation || next_shader->clip != self->clip || - next_shader->vertex_offset != self->vertex_offset + n_ops * shader_op_class->vertex_size) + next_shader->vertex_offset != self->vertex_offset + n_ops * shader_op_class->vertex_size || + (shader_op_class->n_textures > 0 && (next_shader->images[0] != self->images[0] || next_shader->samplers[0] != self->samplers[0])) || + (shader_op_class->n_textures > 1 && (next_shader->images[1] != self->images[1] || next_shader->samplers[1] != self->samplers[1]))) break; n_ops += next_shader->n_ops; @@ -238,11 +242,13 @@ gsk_gpu_shader_op_alloc (GskGpuFrame *frame, guint32 variation, GskGpuShaderClip clip, GskGpuDescriptors *desc, + GskGpuImage **images, + GskGpuSampler *samplers, gpointer out_vertex_data) { GskGpuOp *last; GskGpuShaderOp *last_shader; - gsize vertex_offset; + gsize i, vertex_offset; vertex_offset = gsk_gpu_frame_reserve_vertex_data (frame, op_class->vertex_size); @@ -251,11 +257,12 @@ gsk_gpu_shader_op_alloc (GskGpuFrame *frame, last_shader = (GskGpuShaderOp *) last; if (last && last->op_class == (const GskGpuOpClass *) op_class && - last_shader->desc == desc && last_shader->color_states == color_states && last_shader->variation == variation && last_shader->clip == clip && - last_shader->vertex_offset + last_shader->n_ops * op_class->vertex_size == vertex_offset) + last_shader->vertex_offset + last_shader->n_ops * op_class->vertex_size == vertex_offset && + (op_class->n_textures < 1 || (last_shader->images[0] == images[0] && last_shader->samplers[0] == samplers[0])) && + (op_class->n_textures < 2 || (last_shader->images[1] == images[1] && last_shader->samplers[1] == samplers[1]))) { last_shader->n_ops++; } @@ -273,6 +280,11 @@ gsk_gpu_shader_op_alloc (GskGpuFrame *frame, else self->desc = NULL; self->n_ops = 1; + for (i = 0; i < op_class->n_textures; i++) + { + self->images[i] = g_object_ref (images[i]); + self->samplers[i] = samplers[i]; + } } *((gpointer *) out_vertex_data) = gsk_gpu_frame_get_vertex_data (frame, vertex_offset); diff --git a/gsk/gpu/gskgpushaderopprivate.h b/gsk/gpu/gskgpushaderopprivate.h index 1131c1eae8..4a88124062 100644 --- a/gsk/gpu/gskgpushaderopprivate.h +++ b/gsk/gpu/gskgpushaderopprivate.h @@ -23,6 +23,8 @@ struct _GskGpuShaderOp GskGpuOp parent_op; GskGpuDescriptors *desc; + GskGpuImage *images[2]; + GskGpuSampler samplers[2]; GskGpuColorStates color_states; guint32 variation; GskGpuShaderClip clip; @@ -53,6 +55,8 @@ void gsk_gpu_shader_op_alloc (GskGpuF guint32 variation, GskGpuShaderClip clip, GskGpuDescriptors *desc, + GskGpuImage **images, + GskGpuSampler *samplers, gpointer out_vertex_data); void gsk_gpu_shader_op_finish (GskGpuOp *op); diff --git a/gsk/gpu/gskgputextureop.c b/gsk/gpu/gskgputextureop.c index 828c75d013..5dd4e605c1 100644 --- a/gsk/gpu/gskgputextureop.c +++ b/gsk/gpu/gskgputextureop.c @@ -63,6 +63,8 @@ gsk_gpu_texture_op (GskGpuFrame *frame, 0, clip, desc, + (GskGpuImage *[1]) { image->image }, + (GskGpuSampler[1]) { image->sampler }, &instance); gsk_gpu_rect_to_float (image->coverage ? image->coverage : image->bounds, offset, instance->rect); From 1331a10e8847b40a4244f6d4fcca0ca1ed4fe097 Mon Sep 17 00:00:00 2001 From: Benjamin Otte Date: Fri, 19 Jul 2024 20:45:56 +0200 Subject: [PATCH 12/28] gpu: Remove buffer handling We don't use buffers atm, and if we want to bring them back later, we can just look at reverting this commit. And it's in the way while refactoring. --- gsk/gpu/gskgldescriptors.c | 27 ---- gsk/gpu/gskgpudescriptors.c | 83 +---------- gsk/gpu/gskgpudescriptorsprivate.h | 12 +- gsk/gpu/gskvulkandescriptors.c | 1 - gsk/gpu/gskvulkanframe.c | 13 +- gsk/gpu/gskvulkanrealdescriptors.c | 78 +--------- gsk/gpu/gskvulkanrealdescriptorsprivate.h | 3 +- gsk/gpu/gskvulkansubdescriptors.c | 13 -- gsk/gpu/shaders/common-gl.glsl | 53 ------- gsk/gpu/shaders/common-vulkan.glsl | 172 ---------------------- 10 files changed, 11 insertions(+), 444 deletions(-) diff --git a/gsk/gpu/gskgldescriptors.c b/gsk/gpu/gskgldescriptors.c index c061a61e61..2a6b5b16d3 100644 --- a/gsk/gpu/gskgldescriptors.c +++ b/gsk/gpu/gskgldescriptors.c @@ -2,7 +2,6 @@ #include "gskgldescriptorsprivate.h" -#include "gskglbufferprivate.h" #include "gskglimageprivate.h" struct _GskGLDescriptors @@ -55,23 +54,6 @@ gsk_gl_descriptors_add_image (GskGpuDescriptors *desc, } } -static gboolean -gsk_gl_descriptors_add_buffer (GskGpuDescriptors *desc, - GskGpuBuffer *buffer, - guint32 *out_descriptor) -{ - gsize used_buffers; - - used_buffers = gsk_gpu_descriptors_get_n_buffers (desc); - - if (used_buffers >= 11) - return FALSE; - - *out_descriptor = used_buffers; - - return TRUE; -} - static void gsk_gl_descriptors_class_init (GskGLDescriptorsClass *klass) { @@ -81,7 +63,6 @@ gsk_gl_descriptors_class_init (GskGLDescriptorsClass *klass) object_class->finalize = gsk_gl_descriptors_finalize; descriptors_class->add_image = gsk_gl_descriptors_add_image; - descriptors_class->add_buffer = gsk_gl_descriptors_add_buffer; } static void @@ -133,12 +114,4 @@ gsk_gl_descriptors_use (GskGLDescriptors *self) glBindSampler (i - ext, gsk_gl_device_get_sampler_id (self->device, gsk_gpu_descriptors_get_sampler (desc, i))); } } - - for (i = 0; i < gsk_gpu_descriptors_get_n_buffers (desc); i++) - { - GskGLBuffer *buffer = GSK_GL_BUFFER (gsk_gpu_descriptors_get_buffer (desc, i)); - - /* index 0 are the globals, we start at 1 */ - gsk_gl_buffer_bind_base (buffer, i + 1); - } } diff --git a/gsk/gpu/gskgpudescriptors.c b/gsk/gpu/gskgpudescriptors.c index d0e9d907de..7749c9607c 100644 --- a/gsk/gpu/gskgpudescriptors.c +++ b/gsk/gpu/gskgpudescriptors.c @@ -12,12 +12,6 @@ struct _GskGpuImageEntry guint32 descriptor; }; -struct _GskGpuBufferEntry -{ - GskGpuBuffer *buffer; - guint32 descriptor; -}; - static void gsk_gpu_image_entry_clear (gpointer data) { @@ -26,14 +20,6 @@ gsk_gpu_image_entry_clear (gpointer data) g_object_unref (entry->image); } -static void -gsk_gpu_buffer_entry_clear (gpointer data) -{ - GskGpuBufferEntry *entry = data; - - g_object_unref (entry->buffer); -} - #define GDK_ARRAY_NAME gsk_gpu_image_entries #define GDK_ARRAY_TYPE_NAME GskGpuImageEntries #define GDK_ARRAY_ELEMENT_TYPE GskGpuImageEntry @@ -43,21 +29,11 @@ gsk_gpu_buffer_entry_clear (gpointer data) #define GDK_ARRAY_NO_MEMSET 1 #include "gdk/gdkarrayimpl.c" -#define GDK_ARRAY_NAME gsk_gpu_buffer_entries -#define GDK_ARRAY_TYPE_NAME GskGpuBufferEntries -#define GDK_ARRAY_ELEMENT_TYPE GskGpuBufferEntry -#define GDK_ARRAY_FREE_FUNC gsk_gpu_buffer_entry_clear -#define GDK_ARRAY_BY_VALUE 1 -#define GDK_ARRAY_PREALLOC 4 -#define GDK_ARRAY_NO_MEMSET 1 -#include "gdk/gdkarrayimpl.c" - typedef struct _GskGpuDescriptorsPrivate GskGpuDescriptorsPrivate; struct _GskGpuDescriptorsPrivate { GskGpuImageEntries images; - GskGpuBufferEntries buffers; }; G_DEFINE_TYPE_WITH_PRIVATE (GskGpuDescriptors, gsk_gpu_descriptors, G_TYPE_OBJECT) @@ -69,7 +45,6 @@ gsk_gpu_descriptors_finalize (GObject *object) GskGpuDescriptorsPrivate *priv = gsk_gpu_descriptors_get_instance_private (self); gsk_gpu_image_entries_clear (&priv->images); - gsk_gpu_buffer_entries_clear (&priv->buffers); G_OBJECT_CLASS (gsk_gpu_descriptors_parent_class)->finalize (object); } @@ -88,7 +63,6 @@ gsk_gpu_descriptors_init (GskGpuDescriptors *self) GskGpuDescriptorsPrivate *priv = gsk_gpu_descriptors_get_instance_private (self); gsk_gpu_image_entries_init (&priv->images); - gsk_gpu_buffer_entries_init (&priv->buffers); } gsize @@ -99,25 +73,14 @@ gsk_gpu_descriptors_get_n_images (GskGpuDescriptors *self) return gsk_gpu_image_entries_get_size (&priv->images); } -gsize -gsk_gpu_descriptors_get_n_buffers (GskGpuDescriptors *self) -{ - GskGpuDescriptorsPrivate *priv = gsk_gpu_descriptors_get_instance_private (self); - - return gsk_gpu_buffer_entries_get_size (&priv->buffers); -} void gsk_gpu_descriptors_set_size (GskGpuDescriptors *self, - gsize n_images, - gsize n_buffers) + gsize n_images) { GskGpuDescriptorsPrivate *priv = gsk_gpu_descriptors_get_instance_private (self); g_assert (n_images <= gsk_gpu_image_entries_get_size (&priv->images)); gsk_gpu_image_entries_set_size (&priv->images, n_images); - - g_assert (n_buffers <= gsk_gpu_buffer_entries_get_size (&priv->buffers)); - gsk_gpu_buffer_entries_set_size (&priv->buffers, n_buffers); } GskGpuImage * @@ -158,16 +121,6 @@ gsk_gpu_descriptors_find_image (GskGpuDescriptors *self, g_return_val_if_reached ((gsize) -1); } -GskGpuBuffer * -gsk_gpu_descriptors_get_buffer (GskGpuDescriptors *self, - gsize id) -{ - GskGpuDescriptorsPrivate *priv = gsk_gpu_descriptors_get_instance_private (self); - const GskGpuBufferEntry *entry = gsk_gpu_buffer_entries_get (&priv->buffers, id); - - return entry->buffer; -} - gboolean gsk_gpu_descriptors_add_image (GskGpuDescriptors *self, GskGpuImage *image, @@ -204,37 +157,3 @@ gsk_gpu_descriptors_add_image (GskGpuDescriptors *self, return TRUE; } -gboolean -gsk_gpu_descriptors_add_buffer (GskGpuDescriptors *self, - GskGpuBuffer *buffer, - guint32 *out_descriptor) -{ - GskGpuDescriptorsPrivate *priv = gsk_gpu_descriptors_get_instance_private (self); - gsize i; - guint32 descriptor; - - for (i = 0; i < gsk_gpu_buffer_entries_get_size (&priv->buffers); i++) - { - const GskGpuBufferEntry *entry = gsk_gpu_buffer_entries_get (&priv->buffers, i); - - if (entry->buffer == buffer) - { - *out_descriptor = entry->descriptor; - return TRUE; - } - } - - if (!GSK_GPU_DESCRIPTORS_GET_CLASS (self)->add_buffer (self, buffer, &descriptor)) - return FALSE; - - gsk_gpu_buffer_entries_append (&priv->buffers, - &(GskGpuBufferEntry) { - .buffer = g_object_ref (buffer), - .descriptor = descriptor - }); - - *out_descriptor = descriptor; - - return TRUE; -} - diff --git a/gsk/gpu/gskgpudescriptorsprivate.h b/gsk/gpu/gskgpudescriptorsprivate.h index 908f1d393d..c64db7d661 100644 --- a/gsk/gpu/gskgpudescriptorsprivate.h +++ b/gsk/gpu/gskgpudescriptorsprivate.h @@ -26,34 +26,24 @@ struct _GskGpuDescriptorsClass GskGpuImage *image, GskGpuSampler sampler, guint32 *out_id); - gboolean (* add_buffer) (GskGpuDescriptors *self, - GskGpuBuffer *buffer, - guint32 *out_id); }; GType gsk_gpu_descriptors_get_type (void) G_GNUC_CONST; gsize gsk_gpu_descriptors_get_n_images (GskGpuDescriptors *self); -gsize gsk_gpu_descriptors_get_n_buffers (GskGpuDescriptors *self); void gsk_gpu_descriptors_set_size (GskGpuDescriptors *self, - gsize n_images, - gsize n_buffers); + gsize n_images); GskGpuImage * gsk_gpu_descriptors_get_image (GskGpuDescriptors *self, gsize id); GskGpuSampler gsk_gpu_descriptors_get_sampler (GskGpuDescriptors *self, gsize id); gsize gsk_gpu_descriptors_find_image (GskGpuDescriptors *self, guint32 descriptor); -GskGpuBuffer * gsk_gpu_descriptors_get_buffer (GskGpuDescriptors *self, - gsize id); gboolean gsk_gpu_descriptors_add_image (GskGpuDescriptors *self, GskGpuImage *image, GskGpuSampler sampler, guint32 *out_descriptor); -gboolean gsk_gpu_descriptors_add_buffer (GskGpuDescriptors *self, - GskGpuBuffer *buffer, - guint32 *out_descriptor); G_DEFINE_AUTOPTR_CLEANUP_FUNC(GskGpuDescriptors, g_object_unref) diff --git a/gsk/gpu/gskvulkandescriptors.c b/gsk/gpu/gskvulkandescriptors.c index d76df09105..4aca1ce356 100644 --- a/gsk/gpu/gskvulkandescriptors.c +++ b/gsk/gpu/gskvulkandescriptors.c @@ -2,7 +2,6 @@ #include "gskvulkandescriptorsprivate.h" -#include "gskvulkanbufferprivate.h" #include "gskvulkanframeprivate.h" #include "gskvulkanimageprivate.h" diff --git a/gsk/gpu/gskvulkanframe.c b/gsk/gpu/gskvulkanframe.c index 266d784505..ce75043350 100644 --- a/gsk/gpu/gskvulkanframe.c +++ b/gsk/gpu/gskvulkanframe.c @@ -242,26 +242,23 @@ gsk_vulkan_frame_prepare_descriptors (GskVulkanFrame *self) { GskVulkanDevice *device; VkDevice vk_device; - gsize i, n_images, n_buffers, n_sets; + gsize i, n_images, n_sets; device = GSK_VULKAN_DEVICE (gsk_gpu_frame_get_device (GSK_GPU_FRAME (self))); vk_device = gsk_vulkan_device_get_vk_device (device); n_images = 0; - n_buffers = 0; n_sets = 2 * gsk_descriptors_get_size (&self->descriptors); for (i = 0; i < gsk_descriptors_get_size (&self->descriptors); i++) { - gsize n_desc_images, n_desc_buffers; + gsize n_desc_images; GskVulkanRealDescriptors *desc = gsk_descriptors_get (&self->descriptors, i); - gsk_vulkan_real_descriptors_prepare (desc, &n_desc_images, &n_desc_buffers); + gsk_vulkan_real_descriptors_prepare (desc, &n_desc_images); n_images += n_desc_images; - n_buffers += n_desc_buffers; } if (n_sets > self->pool_n_sets || - n_images > self->pool_n_images || - n_buffers > self->pool_n_buffers) + n_images > self->pool_n_images) { if (self->vk_descriptor_pool != VK_NULL_HANDLE) { @@ -274,8 +271,6 @@ gsk_vulkan_frame_prepare_descriptors (GskVulkanFrame *self) self->pool_n_sets = 4 << g_bit_nth_msf (n_sets - 1, -1); if (n_images > self->pool_n_images) self->pool_n_images = 2 << g_bit_nth_msf (n_images - 1, -1); - if (n_buffers > self->pool_n_buffers) - self->pool_n_buffers = 4 << g_bit_nth_msf (n_buffers - 1, -1); } if (self->vk_descriptor_pool == VK_NULL_HANDLE) diff --git a/gsk/gpu/gskvulkanrealdescriptors.c b/gsk/gpu/gskvulkanrealdescriptors.c index 12e5c1baa9..fa6657e884 100644 --- a/gsk/gpu/gskvulkanrealdescriptors.c +++ b/gsk/gpu/gskvulkanrealdescriptors.c @@ -3,7 +3,6 @@ #include "gskvulkanrealdescriptorsprivate.h" #include "gskgpucacheprivate.h" -#include "gskvulkanbufferprivate.h" #include "gskvulkanframeprivate.h" #include "gskvulkanimageprivate.h" @@ -15,14 +14,6 @@ #define GDK_ARRAY_NO_MEMSET 1 #include "gdk/gdkarrayimpl.c" -#define GDK_ARRAY_NAME gsk_descriptor_buffer_infos -#define GDK_ARRAY_TYPE_NAME GskDescriptorBufferInfos -#define GDK_ARRAY_ELEMENT_TYPE VkDescriptorBufferInfo -#define GDK_ARRAY_BY_VALUE 1 -#define GDK_ARRAY_PREALLOC 32 -#define GDK_ARRAY_NO_MEMSET 1 -#include "gdk/gdkarrayimpl.c" - #define GDK_ARRAY_NAME gsk_samplers #define GDK_ARRAY_TYPE_NAME GskSamplers #define GDK_ARRAY_ELEMENT_TYPE VkSampler @@ -41,7 +32,6 @@ struct _GskVulkanRealDescriptors GskSamplers immutable_samplers; GskDescriptorImageInfos descriptor_immutable_images; GskDescriptorImageInfos descriptor_images; - GskDescriptorBufferInfos descriptor_buffers; VkDescriptorSet descriptor_sets[GSK_VULKAN_N_DESCRIPTOR_SETS]; }; @@ -131,29 +121,6 @@ gsk_vulkan_real_descriptors_add_image (GskGpuDescriptors *desc, return TRUE; } -static gboolean -gsk_vulkan_real_descriptors_add_buffer (GskGpuDescriptors *desc, - GskGpuBuffer *buffer, - guint32 *out_descriptor) -{ - GskVulkanRealDescriptors *self = GSK_VULKAN_REAL_DESCRIPTORS (desc); - GskVulkanDevice *device = GSK_VULKAN_DEVICE (gsk_gpu_frame_get_device (GSK_GPU_FRAME (self->frame))); - - if (gsk_descriptor_buffer_infos_get_size (&self->descriptor_buffers) >= - gsk_vulkan_device_get_max_buffers (device)) - return FALSE; - - *out_descriptor = gsk_descriptor_buffer_infos_get_size (&self->descriptor_buffers); - gsk_descriptor_buffer_infos_append (&self->descriptor_buffers, - &(VkDescriptorBufferInfo) { - .buffer = gsk_vulkan_buffer_get_vk_buffer (GSK_VULKAN_BUFFER (buffer)), - .offset = 0, - .range = VK_WHOLE_SIZE - }); - - return TRUE; -} - static void gsk_vulkan_real_descriptors_finalize (GObject *object) { @@ -162,7 +129,6 @@ gsk_vulkan_real_descriptors_finalize (GObject *object) gsk_samplers_clear (&self->immutable_samplers); gsk_descriptor_image_infos_clear (&self->descriptor_immutable_images); gsk_descriptor_image_infos_clear (&self->descriptor_images); - gsk_descriptor_buffer_infos_clear (&self->descriptor_buffers); gsk_vulkan_device_release_pipeline_layout (GSK_VULKAN_DEVICE (gsk_gpu_frame_get_device (GSK_GPU_FRAME (self->frame))), self->pipeline_layout); @@ -180,7 +146,6 @@ gsk_vulkan_real_descriptors_class_init (GskVulkanRealDescriptorsClass *klass) object_class->finalize = gsk_vulkan_real_descriptors_finalize; descriptors_class->add_image = gsk_vulkan_real_descriptors_add_image; - descriptors_class->add_buffer = gsk_vulkan_real_descriptors_add_buffer; vulkan_descriptors_class->get_pipeline_layout = gsk_vulkan_real_descriptors_get_pipeline_layout; vulkan_descriptors_class->bind = gsk_vulkan_real_descriptors_bind; @@ -192,7 +157,6 @@ gsk_vulkan_real_descriptors_init (GskVulkanRealDescriptors *self) gsk_samplers_init (&self->immutable_samplers); gsk_descriptor_image_infos_init (&self->descriptor_immutable_images); gsk_descriptor_image_infos_init (&self->descriptor_images); - gsk_descriptor_buffer_infos_init (&self->descriptor_buffers); } GskVulkanRealDescriptors * @@ -215,8 +179,7 @@ gsk_vulkan_real_descriptors_is_full (GskVulkanRealDescriptors *self) return gsk_descriptor_image_infos_get_size (&self->descriptor_immutable_images) >= gsk_vulkan_device_get_max_immutable_samplers (device) || gsk_descriptor_image_infos_get_size (&self->descriptor_images) + MAX (1, gsk_descriptor_image_infos_get_size (&self->descriptor_immutable_images) * 3) >= - gsk_vulkan_device_get_max_samplers (device) || - gsk_descriptor_buffer_infos_get_size (&self->descriptor_buffers) >= gsk_vulkan_device_get_max_buffers (device); + gsk_vulkan_device_get_max_samplers (device); } static void @@ -261,42 +224,21 @@ gsk_vulkan_real_descriptors_fill_sets (GskVulkanRealDescriptors *self) { gsk_descriptor_image_infos_append (&self->descriptor_images, gsk_descriptor_image_infos_get (&self->descriptor_images, 0)); } - if (gsk_descriptor_buffer_infos_get_size (&self->descriptor_buffers) == 0) - { - /* If there's no storage buffer yet, just make one */ - GskGpuBuffer *buffer; - gsize ignored_offset; - guint32 ignored; - - buffer = gsk_gpu_frame_write_storage_buffer (GSK_GPU_FRAME (self->frame), NULL, 0, &ignored_offset); - if (!gsk_gpu_descriptors_add_buffer (GSK_GPU_DESCRIPTORS (self), - buffer, - &ignored)) - { - g_assert_not_reached (); - } - } - while (n_buffers > gsk_descriptor_buffer_infos_get_size (&self->descriptor_buffers)) - { - gsk_descriptor_buffer_infos_append (&self->descriptor_buffers, gsk_descriptor_buffer_infos_get (&self->descriptor_buffers, 0)); - } } void gsk_vulkan_real_descriptors_prepare (GskVulkanRealDescriptors *self, - gsize *n_images, - gsize *n_buffers) + gsize *n_images) { self->pipeline_layout = gsk_vulkan_device_acquire_pipeline_layout (GSK_VULKAN_DEVICE (gsk_gpu_frame_get_device (GSK_GPU_FRAME (self->frame))), gsk_samplers_get_data (&self->immutable_samplers), gsk_samplers_get_size (&self->immutable_samplers), gsk_descriptor_image_infos_get_size (&self->descriptor_images), - gsk_descriptor_buffer_infos_get_size (&self->descriptor_buffers)); + 0); gsk_vulkan_real_descriptors_fill_sets (self); *n_images = MAX (1, gsk_descriptor_image_infos_get_size (&self->descriptor_immutable_images)) + gsk_descriptor_image_infos_get_size (&self->descriptor_images); - *n_buffers = gsk_descriptor_buffer_infos_get_size (&self->descriptor_buffers); } void @@ -327,7 +269,7 @@ gsk_vulkan_real_descriptors_update_sets (GskVulkanRealDescriptors *self, .descriptorSetCount = GSK_VULKAN_N_DESCRIPTOR_SETS, .pDescriptorCounts = (uint32_t[GSK_VULKAN_N_DESCRIPTOR_SETS]) { gsk_descriptor_image_infos_get_size (&self->descriptor_images), - gsk_descriptor_buffer_infos_get_size (&self->descriptor_buffers) + 0, } } }, @@ -358,18 +300,6 @@ gsk_vulkan_real_descriptors_update_sets (GskVulkanRealDescriptors *self, .pImageInfo = gsk_descriptor_image_infos_get_data (&self->descriptor_images) }; } - if (gsk_descriptor_buffer_infos_get_size (&self->descriptor_buffers) > 0) - { - write_descriptor_sets[n_descriptor_sets++] = (VkWriteDescriptorSet) { - .sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, - .dstSet = self->descriptor_sets[GSK_VULKAN_BUFFER_SET_LAYOUT], - .dstBinding = 0, - .dstArrayElement = 0, - .descriptorCount = gsk_descriptor_buffer_infos_get_size (&self->descriptor_buffers), - .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, - .pBufferInfo = gsk_descriptor_buffer_infos_get_data (&self->descriptor_buffers) - }; - } vkUpdateDescriptorSets (vk_device, n_descriptor_sets, diff --git a/gsk/gpu/gskvulkanrealdescriptorsprivate.h b/gsk/gpu/gskvulkanrealdescriptorsprivate.h index 25cb82746b..7f0d6c16d1 100644 --- a/gsk/gpu/gskvulkanrealdescriptorsprivate.h +++ b/gsk/gpu/gskvulkanrealdescriptorsprivate.h @@ -14,8 +14,7 @@ GskVulkanRealDescriptors * gsk_vulkan_real_descriptors_new gboolean gsk_vulkan_real_descriptors_is_full (GskVulkanRealDescriptors *self); void gsk_vulkan_real_descriptors_prepare (GskVulkanRealDescriptors *self, - gsize *n_images, - gsize *n_buffers); + gsize *n_images); void gsk_vulkan_real_descriptors_update_sets (GskVulkanRealDescriptors *self, VkDescriptorPool vk_descriptor_pool); diff --git a/gsk/gpu/gskvulkansubdescriptors.c b/gsk/gpu/gskvulkansubdescriptors.c index f779e6be06..b9e8420591 100644 --- a/gsk/gpu/gskvulkansubdescriptors.c +++ b/gsk/gpu/gskvulkansubdescriptors.c @@ -49,18 +49,6 @@ gsk_vulkan_sub_descriptors_add_image (GskGpuDescriptors *desc, out_descriptor); } -static gboolean -gsk_vulkan_sub_descriptors_add_buffer (GskGpuDescriptors *desc, - GskGpuBuffer *buffer, - guint32 *out_descriptor) -{ - GskVulkanSubDescriptors *self = GSK_VULKAN_SUB_DESCRIPTORS (desc); - - return gsk_gpu_descriptors_add_buffer (GSK_GPU_DESCRIPTORS (self->parent), - buffer, - out_descriptor); -} - static void gsk_vulkan_sub_descriptors_finalize (GObject *object) { @@ -81,7 +69,6 @@ gsk_vulkan_sub_descriptors_class_init (GskVulkanSubDescriptorsClass *klass) object_class->finalize = gsk_vulkan_sub_descriptors_finalize; descriptors_class->add_image = gsk_vulkan_sub_descriptors_add_image; - descriptors_class->add_buffer = gsk_vulkan_sub_descriptors_add_buffer; vulkan_descriptors_class->get_pipeline_layout = gsk_vulkan_sub_descriptors_get_pipeline_layout; vulkan_descriptors_class->bind = gsk_vulkan_sub_descriptors_bind; diff --git a/gsk/gpu/shaders/common-gl.glsl b/gsk/gpu/shaders/common-gl.glsl index d15eba6464..cf4f1ac609 100644 --- a/gsk/gpu/shaders/common-gl.glsl +++ b/gsk/gpu/shaders/common-gl.glsl @@ -17,16 +17,6 @@ uniform PushConstants #define GSK_GLOBAL_CLIP_RECT push.clip[0] #define GSK_GLOBAL_SCALE push.scale -#if __VERSION__ < 420 || (defined(GSK_GLES) && __VERSION__ < 310) -layout(std140) -#else -layout(std140, binding = 1) -#endif -uniform Floats -{ - vec4 really_just_floats[1024]; -} floats[11]; - #if N_EXTERNAL_TEXTURES > 0 uniform samplerExternalOES external_textures[N_EXTERNAL_TEXTURES]; #endif @@ -48,49 +38,6 @@ uniform sampler2D textures[N_TEXTURES]; #define PASS(_loc) in #define PASS_FLAT(_loc) flat in -float -gsk_get_float (int id) -{ - int float_id = id & 0x3FFFFF; - int array_id = (id >> 22) & 0xFF; - switch (array_id) - { - case 0: - return floats[0].really_just_floats[float_id >> 2][float_id & 3]; - case 1: - return floats[1].really_just_floats[float_id >> 2][float_id & 3]; - case 2: - return floats[2].really_just_floats[float_id >> 2][float_id & 3]; - case 3: - return floats[3].really_just_floats[float_id >> 2][float_id & 3]; - case 4: - return floats[4].really_just_floats[float_id >> 2][float_id & 3]; - case 5: - return floats[5].really_just_floats[float_id >> 2][float_id & 3]; - case 6: - return floats[6].really_just_floats[float_id >> 2][float_id & 3]; - case 7: - return floats[7].really_just_floats[float_id >> 2][float_id & 3]; - case 8: - return floats[8].really_just_floats[float_id >> 2][float_id & 3]; - case 9: - return floats[9].really_just_floats[float_id >> 2][float_id & 3]; - case 10: - return floats[10].really_just_floats[float_id >> 2][float_id & 3]; - default: - return 0.0; - } -} - -float -gsk_get_float (uint id) -{ - return gsk_get_float (int (id)); -} - -#define gsk_get_int(id) (floatBitsToInt(gsk_get_float(id))) -#define gsk_get_uint(id) (floatBitsToUint(gsk_get_float(id))) - #if __VERSION__ < 400 || defined(GSK_GLES) vec4 diff --git a/gsk/gpu/shaders/common-vulkan.glsl b/gsk/gpu/shaders/common-vulkan.glsl index fe2d309109..2a2f49f91d 100644 --- a/gsk/gpu/shaders/common-vulkan.glsl +++ b/gsk/gpu/shaders/common-vulkan.glsl @@ -37,9 +37,6 @@ layout(constant_id=5) const uint GSK_VARIATION = 0; layout(set = 0, binding = 0) uniform sampler2D immutable_textures[GSK_N_IMMUTABLE_SAMPLERS]; layout(set = 0, binding = 1) uniform sampler2D textures[GSK_N_SAMPLERS]; -layout(set = 1, binding = 0) readonly buffer FloatBuffers { - float floats[]; -} buffers[GSK_N_BUFFERS]; layout(location = 0) out vec4 out_color; @@ -1025,175 +1022,6 @@ gsk_texel_fetch (uint id, return vec4 (1.0, 0.0, 0.8, 1.0); } -#ifdef HAVE_VULKAN_1_2 -#define gsk_get_buffer(id) buffers[nonuniformEXT (id)] -#define gsk_get_float(id) gsk_get_buffer(id >> 22).floats[id & 0x3FFFFF] -#else -float -gsk_get_float (uint id) -{ - uint buffer_id = id >> 22; - uint float_id = id & 0x3FFFFF; - if (buffer_id < 16) - { - if (buffer_id < 8) - { - if (buffer_id < 4) - { - if (buffer_id < 2) - { - if (buffer_id < 1) - return buffers[0].floats[float_id]; - else if (GSK_N_BUFFERS > 1) - return buffers[1].floats[float_id]; - } - else if (GSK_N_BUFFERS > 2) - { - if (buffer_id < 3) - return buffers[2].floats[float_id]; - else if (GSK_N_BUFFERS > 3) - return buffers[3].floats[float_id]; - } - } - else if (GSK_N_BUFFERS > 4) - { - if (buffer_id < 6) - { - if (buffer_id < 5) - return buffers[4].floats[float_id]; - else if (GSK_N_BUFFERS > 5) - return buffers[5].floats[float_id]; - } - else if (GSK_N_BUFFERS > 6) - { - if (buffer_id < 7) - return buffers[6].floats[float_id]; - else if (GSK_N_BUFFERS > 7) - return buffers[7].floats[float_id]; - } - } - } - else if (GSK_N_BUFFERS > 8) - { - if (buffer_id < 12) - { - if (buffer_id < 10) - { - if (buffer_id < 9) - return buffers[8].floats[float_id]; - else if (GSK_N_BUFFERS > 9) - return buffers[9].floats[float_id]; - } - else if (GSK_N_BUFFERS > 10) - { - if (buffer_id < 11) - return buffers[10].floats[float_id]; - else if (GSK_N_BUFFERS > 11) - return buffers[11].floats[float_id]; - } - } - else if (GSK_N_BUFFERS > 12) - { - if (buffer_id < 14) - { - if (buffer_id < 13) - return buffers[12].floats[float_id]; - else if (GSK_N_BUFFERS > 13) - return buffers[13].floats[float_id]; - } - else if (GSK_N_BUFFERS > 14) - { - if (buffer_id < 15) - return buffers[14].floats[float_id]; - else if (GSK_N_BUFFERS > 15) - return buffers[15].floats[float_id]; - } - } - } - } - else if (GSK_N_BUFFERS > 16) - { - if (buffer_id < 24) - { - if (buffer_id < 20) - { - if (buffer_id < 18) - { - if (buffer_id < 17) - return buffers[16].floats[float_id]; - else if (GSK_N_BUFFERS > 17) - return buffers[17].floats[float_id]; - } - else if (GSK_N_BUFFERS > 18) - { - if (buffer_id < 19) - return buffers[18].floats[float_id]; - else if (GSK_N_BUFFERS > 19) - return buffers[19].floats[float_id]; - } - } - else if (GSK_N_BUFFERS > 20) - { - if (buffer_id < 22) - { - if (buffer_id < 21) - return buffers[20].floats[float_id]; - else if (GSK_N_BUFFERS > 21) - return buffers[21].floats[float_id]; - } - else if (GSK_N_BUFFERS > 22) - { - if (buffer_id < 23) - return buffers[22].floats[float_id]; - else if (GSK_N_BUFFERS > 23) - return buffers[23].floats[float_id]; - } - } - } - else if (GSK_N_BUFFERS > 24) - { - if (buffer_id < 28) - { - if (buffer_id < 26) - { - if (buffer_id < 25) - return buffers[24].floats[float_id]; - else if (GSK_N_BUFFERS > 25) - return buffers[25].floats[float_id]; - } - else if (GSK_N_BUFFERS > 26) - { - if (buffer_id < 27) - return buffers[26].floats[float_id]; - else if (GSK_N_BUFFERS > 27) - return buffers[27].floats[float_id]; - } - } - else if (GSK_N_BUFFERS > 28) - { - if (buffer_id < 30) - { - if (buffer_id < 29) - return buffers[28].floats[float_id]; - else if (GSK_N_BUFFERS > 29) - return buffers[29].floats[float_id]; - } - else if (GSK_N_BUFFERS > 30) - { - if (buffer_id < 31) - return buffers[30].floats[float_id]; - else if (GSK_N_BUFFERS > 31) - return buffers[31].floats[float_id]; - } - } - } - } - return 0.0; -} -#endif -#define gsk_get_int(id) (floatBitsToInt(gsk_get_float(id))) -#define gsk_get_uint(id) (floatBitsToUint(gsk_get_float(id))) - void gsk_set_output_color (vec4 color) { From 677b6c1a812d61b55218433616cf452cb468d7e5 Mon Sep 17 00:00:00 2001 From: Benjamin Otte Date: Fri, 19 Jul 2024 23:30:42 +0200 Subject: [PATCH 13/28] gpu: Force new descriptors every time This guarantees that the images get ID 0 and 1 (on GL), which is going to be quite important for the next steps. Just for funsies, here's fps numbers on my desktop for this change: NGL 1500 => 1400 Vulkan 2650 => 2250 --- gsk/gpu/gskgpunodeprocessor.c | 21 ++++++--------------- 1 file changed, 6 insertions(+), 15 deletions(-) diff --git a/gsk/gpu/gskgpunodeprocessor.c b/gsk/gpu/gskgpunodeprocessor.c index a8f0ea61a5..4960f66ae4 100644 --- a/gsk/gpu/gskgpunodeprocessor.c +++ b/gsk/gpu/gskgpunodeprocessor.c @@ -278,14 +278,7 @@ gsk_gpu_node_processor_add_image (GskGpuNodeProcessor *self, { guint32 descriptor; - if (self->desc != NULL) - { - if (gsk_gpu_descriptors_add_image (self->desc, image, sampler, &descriptor)) - return descriptor; - - g_object_unref (self->desc); - } - + g_clear_object (&self->desc); self->desc = gsk_gpu_frame_create_descriptors (self->frame); if (!gsk_gpu_descriptors_add_image (self->desc, image, sampler, &descriptor)) @@ -305,15 +298,13 @@ gsk_gpu_node_processor_add_two_images (GskGpuNodeProcessor *self, GskGpuSampler sampler2, guint32 *out_descriptors) { - GskGpuDescriptors *desc; - - do + g_clear_object (&self->desc); + self->desc = gsk_gpu_frame_create_descriptors (self->frame); + if (!gsk_gpu_descriptors_add_image (self->desc, image1, sampler1, &out_descriptors[0]) || + !gsk_gpu_descriptors_add_image (self->desc, image2, sampler2, &out_descriptors[1])) { - out_descriptors[0] = gsk_gpu_node_processor_add_image (self, image1, sampler1); - desc = self->desc; - out_descriptors[1] = gsk_gpu_node_processor_add_image (self, image2, sampler2); + g_assert_not_reached (); } - while (desc != self->desc); } static void From 163278af0ded3576d889b248a451d8ea79553599 Mon Sep 17 00:00:00 2001 From: Benjamin Otte Date: Sat, 20 Jul 2024 01:20:17 +0200 Subject: [PATCH 14/28] gpu: Add infrastructure to write texture vertex data This allows GskGpuFrame implementations to store data per vertex attribute. This is just the plumbing, no actual implementation is done in this commit. --- gsk/gpu/gskglframe.c | 10 +++++++++ gsk/gpu/gskgpuframe.c | 42 ++++++++++++++++++++++++++++++++++++ gsk/gpu/gskgpuframeprivate.h | 14 ++++++++++++ gsk/gpu/gskgpushaderop.c | 18 ++++++++++++---- gsk/gpu/gskvulkanframe.c | 10 +++++++++ 5 files changed, 90 insertions(+), 4 deletions(-) diff --git a/gsk/gpu/gskglframe.c b/gsk/gpu/gskglframe.c index c69cbee08f..99d340899f 100644 --- a/gsk/gpu/gskglframe.c +++ b/gsk/gpu/gskglframe.c @@ -160,6 +160,15 @@ gsk_gl_frame_create_storage_buffer (GskGpuFrame *frame, return gsk_gl_copied_buffer_new (GL_UNIFORM_BUFFER, size); } +static void +gsk_gl_frame_write_texture_vertex_data (GskGpuFrame *self, + guchar *data, + GskGpuImage **images, + GskGpuSampler *samplers, + gsize n_images) +{ +} + static void gsk_gl_frame_submit (GskGpuFrame *frame, GskRenderPassType pass_type, @@ -218,6 +227,7 @@ gsk_gl_frame_class_init (GskGLFrameClass *klass) gpu_frame_class->create_descriptors = gsk_gl_frame_create_descriptors; gpu_frame_class->create_vertex_buffer = gsk_gl_frame_create_vertex_buffer; gpu_frame_class->create_storage_buffer = gsk_gl_frame_create_storage_buffer; + gpu_frame_class->write_texture_vertex_data = gsk_gl_frame_write_texture_vertex_data; gpu_frame_class->submit = gsk_gl_frame_submit; object_class->finalize = gsk_gl_frame_finalize; diff --git a/gsk/gpu/gskgpuframe.c b/gsk/gpu/gskgpuframe.c index f7ed1083fc..0aa3e8eaf2 100644 --- a/gsk/gpu/gskgpuframe.c +++ b/gsk/gpu/gskgpuframe.c @@ -37,6 +37,7 @@ struct _GskGpuFramePrivate GskGpuRenderer *renderer; GskGpuDevice *device; GskGpuOptimizations optimizations; + gsize texture_vertex_size; gint64 timestamp; GskGpuOps ops; @@ -175,6 +176,28 @@ gsk_gpu_frame_setup (GskGpuFrame *self, GSK_GPU_FRAME_GET_CLASS (self)->setup (self); } +/* + * gsk_gpu_frame_set_texture_vertex_size: + * @self: the frame + * @texture_vertex_size: bytes to reserve in the vertex data per + * texture rendered + * + * Some renderers want to attach vertex data for textures, usually + * for supporting bindless textures. This is the number of bytes + * reserved per texture. + * + * GskGpuFrameClass::write_texture_vertex_data() is used to write that + * data. + **/ +void +gsk_gpu_frame_set_texture_vertex_size (GskGpuFrame *self, + gsize texture_vertex_size) +{ + GskGpuFramePrivate *priv = gsk_gpu_frame_get_instance_private (self); + + priv->texture_vertex_size = texture_vertex_size; +} + void gsk_gpu_frame_begin (GskGpuFrame *self, GdkDrawContext *context, @@ -476,6 +499,15 @@ round_up (gsize number, gsize divisor) return (number + divisor - 1) / divisor * divisor; } +gsize +gsk_gpu_frame_get_texture_vertex_size (GskGpuFrame *self, + gsize n_textures) +{ + GskGpuFramePrivate *priv = gsk_gpu_frame_get_instance_private (self); + + return priv->texture_vertex_size * n_textures; +} + gsize gsk_gpu_frame_reserve_vertex_data (GskGpuFrame *self, gsize size) @@ -535,6 +567,16 @@ gsk_gpu_frame_ensure_storage_buffer (GskGpuFrame *self) priv->storage_buffer_data = gsk_gpu_buffer_map (priv->storage_buffer); } +void +gsk_gpu_frame_write_texture_vertex_data (GskGpuFrame *self, + guchar *data, + GskGpuImage **images, + GskGpuSampler *samplers, + gsize n_images) +{ + GSK_GPU_FRAME_GET_CLASS (self)->write_texture_vertex_data (self, data, images, samplers, n_images); +} + GskGpuBuffer * gsk_gpu_frame_write_storage_buffer (GskGpuFrame *self, const guchar *data, diff --git a/gsk/gpu/gskgpuframeprivate.h b/gsk/gpu/gskgpuframeprivate.h index 9d120d68cf..10be903a77 100644 --- a/gsk/gpu/gskgpuframeprivate.h +++ b/gsk/gpu/gskgpuframeprivate.h @@ -41,6 +41,11 @@ struct _GskGpuFrameClass gsize size); GskGpuBuffer * (* create_storage_buffer) (GskGpuFrame *self, gsize size); + void (* write_texture_vertex_data) (GskGpuFrame *self, + guchar *data, + GskGpuImage **images, + GskGpuSampler *samplers, + gsize n_images); void (* submit) (GskGpuFrame *self, GskRenderPassType pass_type, GskGpuBuffer *vertex_buffer, @@ -54,6 +59,10 @@ void gsk_gpu_frame_setup (GskGpuF GskGpuRenderer *renderer, GskGpuDevice *device, GskGpuOptimizations optimizations); +void gsk_gpu_frame_set_texture_vertex_size (GskGpuFrame *self, + gsize texture_vertex_size); +gsize gsk_gpu_frame_get_texture_vertex_size (GskGpuFrame *self, + gsize n_textures); void gsk_gpu_frame_begin (GskGpuFrame *self, GdkDrawContext *context, @@ -78,6 +87,11 @@ gsize gsk_gpu_frame_reserve_vertex_data (GskGpuF gsize size); guchar * gsk_gpu_frame_get_vertex_data (GskGpuFrame *self, gsize offset); +void gsk_gpu_frame_write_texture_vertex_data (GskGpuFrame *self, + guchar *data, + GskGpuImage **images, + GskGpuSampler *samplers, + gsize n_images); GskGpuBuffer * gsk_gpu_frame_write_storage_buffer (GskGpuFrame *self, const guchar *data, gsize size, diff --git a/gsk/gpu/gskgpushaderop.c b/gsk/gpu/gskgpushaderop.c index 599f7a20da..d927fe7e6a 100644 --- a/gsk/gpu/gskgpushaderop.c +++ b/gsk/gpu/gskgpushaderop.c @@ -248,9 +248,19 @@ gsk_gpu_shader_op_alloc (GskGpuFrame *frame, { GskGpuOp *last; GskGpuShaderOp *last_shader; - gsize i, vertex_offset; + gsize i, vertex_offset, vertex_size, texture_vertex_size; + guchar *vertex_data; - vertex_offset = gsk_gpu_frame_reserve_vertex_data (frame, op_class->vertex_size); + texture_vertex_size = gsk_gpu_frame_get_texture_vertex_size (frame, op_class->n_textures); + vertex_size = texture_vertex_size + op_class->vertex_size; + vertex_offset = gsk_gpu_frame_reserve_vertex_data (frame, vertex_size); + vertex_data = gsk_gpu_frame_get_vertex_data (frame, vertex_offset); + + gsk_gpu_frame_write_texture_vertex_data (frame, + vertex_data, + images, + samplers, + op_class->n_textures); last = gsk_gpu_frame_get_last_op (frame); /* careful: We're casting without checking, but the if() does the check */ @@ -260,7 +270,7 @@ gsk_gpu_shader_op_alloc (GskGpuFrame *frame, last_shader->color_states == color_states && last_shader->variation == variation && last_shader->clip == clip && - last_shader->vertex_offset + last_shader->n_ops * op_class->vertex_size == vertex_offset && + last_shader->vertex_offset + last_shader->n_ops * vertex_size == vertex_offset && (op_class->n_textures < 1 || (last_shader->images[0] == images[0] && last_shader->samplers[0] == samplers[0])) && (op_class->n_textures < 2 || (last_shader->images[1] == images[1] && last_shader->samplers[1] == samplers[1]))) { @@ -287,6 +297,6 @@ gsk_gpu_shader_op_alloc (GskGpuFrame *frame, } } - *((gpointer *) out_vertex_data) = gsk_gpu_frame_get_vertex_data (frame, vertex_offset); + *((gpointer *) out_vertex_data) = vertex_data + texture_vertex_size; } diff --git a/gsk/gpu/gskvulkanframe.c b/gsk/gpu/gskvulkanframe.c index ce75043350..20bf03a647 100644 --- a/gsk/gpu/gskvulkanframe.c +++ b/gsk/gpu/gskvulkanframe.c @@ -355,6 +355,15 @@ gsk_vulkan_frame_create_storage_buffer (GskGpuFrame *frame, return gsk_vulkan_buffer_new_storage (GSK_VULKAN_DEVICE (gsk_gpu_frame_get_device (frame)), size); } +static void +gsk_vulkan_frame_write_texture_vertex_data (GskGpuFrame *self, + guchar *data, + GskGpuImage **images, + GskGpuSampler *samplers, + gsize n_images) +{ +} + static void gsk_vulkan_frame_submit (GskGpuFrame *frame, GskRenderPassType pass_type, @@ -481,6 +490,7 @@ gsk_vulkan_frame_class_init (GskVulkanFrameClass *klass) gpu_frame_class->create_descriptors = gsk_vulkan_frame_create_descriptors; gpu_frame_class->create_vertex_buffer = gsk_vulkan_frame_create_vertex_buffer; gpu_frame_class->create_storage_buffer = gsk_vulkan_frame_create_storage_buffer; + gpu_frame_class->write_texture_vertex_data = gsk_vulkan_frame_write_texture_vertex_data; gpu_frame_class->submit = gsk_vulkan_frame_submit; object_class->finalize = gsk_vulkan_frame_finalize; From 8109e8e3b6fdf357381efebb69bafe32c9cc67db Mon Sep 17 00:00:00 2001 From: Benjamin Otte Date: Sat, 20 Jul 2024 01:42:59 +0200 Subject: [PATCH 15/28] gpu: Add GskGpuShaderFlags This is just blowing up GskGpuShaderClip to hold more information so that we don't need even more specialization constants. --- gsk/gpu/gskgldevice.c | 46 +++++++++++------------------- gsk/gpu/gskgldeviceprivate.h | 2 +- gsk/gpu/gskglframe.c | 4 +-- gsk/gpu/gskglframeprivate.h | 2 +- gsk/gpu/gskgpuopprivate.h | 2 +- gsk/gpu/gskgpuprint.c | 7 +++-- gsk/gpu/gskgpuprintprivate.h | 4 +-- gsk/gpu/gskgpushaderflagsprivate.h | 25 ++++++++++++++++ gsk/gpu/gskgpushaderop.c | 23 +++++++++------ gsk/gpu/gskgpushaderopprivate.h | 2 +- gsk/gpu/gskgputypesprivate.h | 3 ++ gsk/gpu/gskvulkandevice.c | 37 ++++++++++++------------ gsk/gpu/gskvulkandeviceprivate.h | 2 +- gsk/gpu/shaders/common-vulkan.glsl | 2 +- gsk/gpu/shaders/common.glsl | 2 ++ 15 files changed, 94 insertions(+), 69 deletions(-) create mode 100644 gsk/gpu/gskgpushaderflagsprivate.h diff --git a/gsk/gpu/gskgldevice.c b/gsk/gpu/gskgldevice.c index e67b30618a..4ea27cb1c6 100644 --- a/gsk/gpu/gskgldevice.c +++ b/gsk/gpu/gskgldevice.c @@ -3,6 +3,7 @@ #include "gskgldeviceprivate.h" #include "gskdebugprivate.h" +#include "gskgpushaderflagsprivate.h" #include "gskgpushaderopprivate.h" #include "gskglbufferprivate.h" #include "gskglimageprivate.h" @@ -34,9 +35,9 @@ typedef struct _GLProgramKey GLProgramKey; struct _GLProgramKey { const GskGpuShaderOpClass *op_class; + GskGpuShaderFlags flags; GskGpuColorStates color_states; guint32 variation; - GskGpuShaderClip clip; guint n_external_textures; }; @@ -48,9 +49,8 @@ gl_program_key_hash (gconstpointer data) const GLProgramKey *key = data; return GPOINTER_TO_UINT (key->op_class) ^ - key->clip ^ - (key->variation << 2) ^ - (key->n_external_textures << 24) ^ + ((key->flags << 11) | (key->flags >> 21)) ^ + ((key->variation << 21) | ( key->variation >> 11)) ^ key->color_states; } @@ -62,9 +62,9 @@ gl_program_key_equal (gconstpointer a, const GLProgramKey *keyb = b; return keya->op_class == keyb->op_class && + keya->flags == keyb->flags && keya->color_states == keyb->color_states && keya->variation == keyb->variation && - keya->clip == keyb->clip && keya->n_external_textures == keyb->n_external_textures; } @@ -380,9 +380,9 @@ static GLuint gsk_gl_device_load_shader (GskGLDevice *self, const char *program_name, GLenum shader_type, + GskGpuShaderFlags flags, GskGpuColorStates color_states, guint32 variation, - GskGpuShaderClip clip, guint n_external_textures, GError **error) { @@ -391,13 +391,14 @@ gsk_gl_device_load_shader (GskGLDevice *self, GBytes *bytes; GLuint shader_id; + g_assert ((n_external_textures > 0) == gsk_gpu_shader_flags_has_external_textures (flags)); preamble = g_string_new (NULL); g_string_append (preamble, self->version_string); g_string_append (preamble, "\n"); if (self->api == GDK_GL_API_GLES) { - if (n_external_textures > 0) + if (gsk_gpu_shader_flags_has_external_textures (flags)) { g_string_append (preamble, "#extension GL_OES_EGL_image_external_essl3 : require\n"); g_string_append (preamble, "#extension GL_OES_EGL_image_external : require\n"); @@ -407,7 +408,7 @@ gsk_gl_device_load_shader (GskGLDevice *self, } else { - g_assert (n_external_textures == 0); + g_assert (!gsk_gpu_shader_flags_has_external_textures (flags)); } g_string_append_printf (preamble, "#define N_TEXTURES %u\n", 16 - 3 * n_external_textures); @@ -428,25 +429,10 @@ gsk_gl_device_load_shader (GskGLDevice *self, return 0; } + g_string_append_printf (preamble, "#define GSK_FLAGS %uu\n", flags); g_string_append_printf (preamble, "#define GSK_COLOR_STATES %uu\n", color_states); g_string_append_printf (preamble, "#define GSK_VARIATION %uu\n", variation); - switch (clip) - { - case GSK_GPU_SHADER_CLIP_NONE: - g_string_append (preamble, "#define GSK_SHADER_CLIP GSK_GPU_SHADER_CLIP_NONE\n"); - break; - case GSK_GPU_SHADER_CLIP_RECT: - g_string_append (preamble, "#define GSK_SHADER_CLIP GSK_GPU_SHADER_CLIP_RECT\n"); - break; - case GSK_GPU_SHADER_CLIP_ROUNDED: - g_string_append (preamble, "#define GSK_SHADER_CLIP GSK_GPU_SHADER_CLIP_ROUNDED\n"); - break; - default: - g_assert_not_reached (); - break; - } - resource_name = g_strconcat ("/org/gtk/libgsk/shaders/gl/", program_name, ".glsl", NULL); bytes = g_resources_lookup_data (resource_name, 0, error); g_free (resource_name); @@ -482,9 +468,9 @@ gsk_gl_device_load_shader (GskGLDevice *self, static GLuint gsk_gl_device_load_program (GskGLDevice *self, const GskGpuShaderOpClass *op_class, + GskGpuShaderFlags flags, GskGpuColorStates color_states, guint32 variation, - GskGpuShaderClip clip, guint n_external_textures, GError **error) { @@ -492,11 +478,11 @@ gsk_gl_device_load_program (GskGLDevice *self, GLuint vertex_shader_id, fragment_shader_id, program_id; GLint link_status; - vertex_shader_id = gsk_gl_device_load_shader (self, op_class->shader_name, GL_VERTEX_SHADER, color_states, variation, clip, n_external_textures, error); + vertex_shader_id = gsk_gl_device_load_shader (self, op_class->shader_name, GL_VERTEX_SHADER, flags, color_states, variation, n_external_textures, error); if (vertex_shader_id == 0) return 0; - fragment_shader_id = gsk_gl_device_load_shader (self, op_class->shader_name, GL_FRAGMENT_SHADER, color_states, variation, clip, n_external_textures, error); + fragment_shader_id = gsk_gl_device_load_shader (self, op_class->shader_name, GL_FRAGMENT_SHADER, flags, color_states, variation, n_external_textures, error); if (fragment_shader_id == 0) return 0; @@ -554,18 +540,18 @@ gsk_gl_device_load_program (GskGLDevice *self, void gsk_gl_device_use_program (GskGLDevice *self, const GskGpuShaderOpClass *op_class, + GskGpuShaderFlags flags, GskGpuColorStates color_states, guint32 variation, - GskGpuShaderClip clip, guint n_external_textures) { GError *error = NULL; GLuint program_id; GLProgramKey key = { .op_class = op_class, + .flags = flags, .color_states = color_states, .variation = variation, - .clip = clip, .n_external_textures = n_external_textures }; guint i, n_textures; @@ -577,7 +563,7 @@ gsk_gl_device_use_program (GskGLDevice *self, return; } - program_id = gsk_gl_device_load_program (self, op_class, color_states, variation, clip, n_external_textures, &error); + program_id = gsk_gl_device_load_program (self, op_class, flags, color_states, variation, n_external_textures, &error); if (program_id == 0) { g_critical ("Failed to load shader program: %s", error->message); diff --git a/gsk/gpu/gskgldeviceprivate.h b/gsk/gpu/gskgldeviceprivate.h index 0dbfe97049..e5d474ee33 100644 --- a/gsk/gpu/gskgldeviceprivate.h +++ b/gsk/gpu/gskgldeviceprivate.h @@ -13,9 +13,9 @@ GskGpuDevice * gsk_gl_device_get_for_display (GdkDisp void gsk_gl_device_use_program (GskGLDevice *self, const GskGpuShaderOpClass *op_class, + GskGpuShaderFlags flags, GskGpuColorStates color_states, guint32 variation, - GskGpuShaderClip clip, guint n_external_textures); GLuint gsk_gl_device_get_sampler_id (GskGLDevice *self, diff --git a/gsk/gpu/gskglframe.c b/gsk/gpu/gskglframe.c index 99d340899f..e8b9dbbae3 100644 --- a/gsk/gpu/gskglframe.c +++ b/gsk/gpu/gskglframe.c @@ -248,18 +248,18 @@ gsk_gl_frame_init (GskGLFrame *self) void gsk_gl_frame_use_program (GskGLFrame *self, const GskGpuShaderOpClass *op_class, + GskGpuShaderFlags flags, GskGpuColorStates color_states, guint32 variation, - GskGpuShaderClip clip, guint n_external_textures) { GLuint vao; gsk_gl_device_use_program (GSK_GL_DEVICE (gsk_gpu_frame_get_device (GSK_GPU_FRAME (self))), op_class, + flags, color_states, variation, - clip, n_external_textures); vao = GPOINTER_TO_UINT (g_hash_table_lookup (self->vaos, op_class)); diff --git a/gsk/gpu/gskglframeprivate.h b/gsk/gpu/gskglframeprivate.h index 1205e3e0b8..4462917994 100644 --- a/gsk/gpu/gskglframeprivate.h +++ b/gsk/gpu/gskglframeprivate.h @@ -10,9 +10,9 @@ G_DECLARE_FINAL_TYPE (GskGLFrame, gsk_gl_frame, GSK, GL_FRAME, GskGpuFrame) void gsk_gl_frame_use_program (GskGLFrame *self, const GskGpuShaderOpClass *op_class, + GskGpuShaderFlags flags, GskGpuColorStates color_states, guint32 variation, - GskGpuShaderClip clip, guint n_external_textures); void gsk_gl_frame_bind_globals (GskGLFrame *self); diff --git a/gsk/gpu/gskgpuopprivate.h b/gsk/gpu/gskgpuopprivate.h index 2203749e50..4eb332016e 100644 --- a/gsk/gpu/gskgpuopprivate.h +++ b/gsk/gpu/gskgpuopprivate.h @@ -25,9 +25,9 @@ struct _GskGLCommandState gsize flip_y; struct { const GskGpuOpClass *op_class; + GskGpuShaderFlags flags; GskGpuColorStates color_states; guint32 variation; - GskGpuShaderClip clip; gsize n_external; } current_program; GskGLDescriptors *desc; diff --git a/gsk/gpu/gskgpuprint.c b/gsk/gpu/gskgpuprint.c index c2169c5581..0c493010ed 100644 --- a/gsk/gpu/gskgpuprint.c +++ b/gsk/gpu/gskgpuprint.c @@ -5,6 +5,7 @@ #include "gskgpucolorstatesprivate.h" #include "gskgpudescriptorsprivate.h" #include "gskgpuimageprivate.h" +#include "gskgpushaderflagsprivate.h" void gsk_gpu_print_indent (GString *string, @@ -14,9 +15,11 @@ gsk_gpu_print_indent (GString *string, } void -gsk_gpu_print_shader_clip (GString *string, - GskGpuShaderClip clip) +gsk_gpu_print_shader_flags (GString *string, + GskGpuShaderFlags flags) { + GskGpuShaderClip clip = gsk_gpu_shader_flags_get_clip (flags); + switch (clip) { case GSK_GPU_SHADER_CLIP_NONE: diff --git a/gsk/gpu/gskgpuprintprivate.h b/gsk/gpu/gskgpuprintprivate.h index f7f3ab123b..9f77b5adb1 100644 --- a/gsk/gpu/gskgpuprintprivate.h +++ b/gsk/gpu/gskgpuprintprivate.h @@ -17,8 +17,8 @@ void gsk_gpu_print_newline (GString void gsk_gpu_print_string (GString *string, const char *s); -void gsk_gpu_print_shader_clip (GString *string, - GskGpuShaderClip clip); +void gsk_gpu_print_shader_flags (GString *string, + GskGpuShaderFlags flags); void gsk_gpu_print_color_states (GString *string, GskGpuColorStates color_states); void gsk_gpu_print_enum (GString *string, diff --git a/gsk/gpu/gskgpushaderflagsprivate.h b/gsk/gpu/gskgpushaderflagsprivate.h new file mode 100644 index 0000000000..eb2a5b06ba --- /dev/null +++ b/gsk/gpu/gskgpushaderflagsprivate.h @@ -0,0 +1,25 @@ +#pragma once + +#include "gskgputypesprivate.h" + +static inline GskGpuShaderFlags +gsk_gpu_shader_flags_create (GskGpuShaderClip clip, + gboolean texture0_is_external, + gboolean texture1_is_external) +{ + return (clip & GSK_GPU_SHADER_CLIP_MASK) | + (texture0_is_external ? 1 << GSK_GPU_SHADER_CLIP_SHIFT : 0) | + (texture1_is_external ? 1 << (GSK_GPU_SHADER_CLIP_SHIFT + 1) : 0); +} + +static inline gboolean +gsk_gpu_shader_flags_has_external_textures (GskGpuShaderFlags flags) +{ + return flags & (3 << GSK_GPU_SHADER_CLIP_SHIFT) ? TRUE : FALSE; +} + +static inline GskGpuShaderClip +gsk_gpu_shader_flags_get_clip (GskGpuShaderFlags flags) +{ + return flags & GSK_GPU_SHADER_CLIP_MASK; +} diff --git a/gsk/gpu/gskgpushaderop.c b/gsk/gpu/gskgpushaderop.c index d927fe7e6a..58a97da0f9 100644 --- a/gsk/gpu/gskgpushaderop.c +++ b/gsk/gpu/gskgpushaderop.c @@ -4,6 +4,7 @@ #include "gskgpuframeprivate.h" #include "gskgpuprintprivate.h" +#include "gskgpushaderflagsprivate.h" #include "gskgldescriptorsprivate.h" #include "gskgldeviceprivate.h" #include "gskglframeprivate.h" @@ -53,7 +54,7 @@ gsk_gpu_shader_op_print (GskGpuOp *op, for (i = 0; i < self->n_ops; i++) { gsk_gpu_print_op (string, indent, shader_name); - gsk_gpu_print_shader_clip (string, self->clip); + gsk_gpu_print_shader_flags (string, self->flags); gsk_gpu_print_color_states (string, self->color_states); shader_class->print_instance (self, instance + i * shader_class->vertex_size, @@ -96,9 +97,9 @@ gsk_gpu_shader_op_vk_command_n (GskGpuOp *op, if (next->op_class != op->op_class || next_shader->desc != self->desc || + next_shader->flags != self->flags || next_shader->color_states != self->color_states || next_shader->variation != self->variation || - next_shader->clip != self->clip || next_shader->vertex_offset != self->vertex_offset + n_ops * shader_op_class->vertex_size) break; @@ -110,9 +111,9 @@ gsk_gpu_shader_op_vk_command_n (GskGpuOp *op, gsk_vulkan_device_get_vk_pipeline (GSK_VULKAN_DEVICE (gsk_gpu_frame_get_device (frame)), gsk_vulkan_descriptors_get_pipeline_layout (state->desc), shader_op_class, + self->flags, self->color_states, self->variation, - self->clip, state->blend, state->vk_format, state->vk_render_pass)); @@ -157,19 +158,19 @@ gsk_gpu_shader_op_gl_command_n (GskGpuOp *op, if (state->current_program.op_class != op->op_class || state->current_program.color_states != self->color_states || state->current_program.variation != self->variation || - state->current_program.clip != self->clip || + state->current_program.flags != self->flags || state->current_program.n_external != n_external) { state->current_program.op_class = op->op_class; + state->current_program.flags = self->flags; state->current_program.color_states = self->color_states; state->current_program.variation = self->variation; - state->current_program.clip = self->clip; state->current_program.n_external = n_external; gsk_gl_frame_use_program (GSK_GL_FRAME (frame), shader_op_class, + self->flags, self->color_states, self->variation, - self->clip, n_external); } @@ -191,9 +192,9 @@ gsk_gpu_shader_op_gl_command_n (GskGpuOp *op, if (next->op_class != op->op_class || next_shader->desc != self->desc || + next_shader->flags != self->flags || next_shader->color_states != self->color_states || next_shader->variation != self->variation || - next_shader->clip != self->clip || next_shader->vertex_offset != self->vertex_offset + n_ops * shader_op_class->vertex_size || (shader_op_class->n_textures > 0 && (next_shader->images[0] != self->images[0] || next_shader->samplers[0] != self->samplers[0])) || (shader_op_class->n_textures > 1 && (next_shader->images[1] != self->images[1] || next_shader->samplers[1] != self->samplers[1]))) @@ -250,7 +251,11 @@ gsk_gpu_shader_op_alloc (GskGpuFrame *frame, GskGpuShaderOp *last_shader; gsize i, vertex_offset, vertex_size, texture_vertex_size; guchar *vertex_data; + GskGpuShaderFlags flags; + flags = gsk_gpu_shader_flags_create (clip, + op_class->n_textures > 0 && (gsk_gpu_image_get_flags (images[0]) & GSK_GPU_IMAGE_EXTERNAL), + op_class->n_textures > 1 && (gsk_gpu_image_get_flags (images[1]) & GSK_GPU_IMAGE_EXTERNAL)); texture_vertex_size = gsk_gpu_frame_get_texture_vertex_size (frame, op_class->n_textures); vertex_size = texture_vertex_size + op_class->vertex_size; vertex_offset = gsk_gpu_frame_reserve_vertex_data (frame, vertex_size); @@ -269,7 +274,7 @@ gsk_gpu_shader_op_alloc (GskGpuFrame *frame, last->op_class == (const GskGpuOpClass *) op_class && last_shader->color_states == color_states && last_shader->variation == variation && - last_shader->clip == clip && + last_shader->flags == flags && last_shader->vertex_offset + last_shader->n_ops * vertex_size == vertex_offset && (op_class->n_textures < 1 || (last_shader->images[0] == images[0] && last_shader->samplers[0] == samplers[0])) && (op_class->n_textures < 2 || (last_shader->images[1] == images[1] && last_shader->samplers[1] == samplers[1]))) @@ -281,9 +286,9 @@ gsk_gpu_shader_op_alloc (GskGpuFrame *frame, GskGpuShaderOp *self; self = (GskGpuShaderOp *) gsk_gpu_op_alloc (frame, &op_class->parent_class); + self->flags = flags; self->color_states = color_states; self->variation = variation; - self->clip = clip; self->vertex_offset = vertex_offset; if (desc) self->desc = g_object_ref (desc); diff --git a/gsk/gpu/gskgpushaderopprivate.h b/gsk/gpu/gskgpushaderopprivate.h index 4a88124062..2f073e2cad 100644 --- a/gsk/gpu/gskgpushaderopprivate.h +++ b/gsk/gpu/gskgpushaderopprivate.h @@ -25,9 +25,9 @@ struct _GskGpuShaderOp GskGpuDescriptors *desc; GskGpuImage *images[2]; GskGpuSampler samplers[2]; + GskGpuShaderFlags flags; GskGpuColorStates color_states; guint32 variation; - GskGpuShaderClip clip; gsize vertex_offset; gsize n_ops; }; diff --git a/gsk/gpu/gskgputypesprivate.h b/gsk/gpu/gskgputypesprivate.h index a8fcb3e7f3..3ad278367f 100644 --- a/gsk/gpu/gskgputypesprivate.h +++ b/gsk/gpu/gskgputypesprivate.h @@ -15,6 +15,7 @@ typedef struct _GskGpuFrame GskGpuFrame; typedef struct _GskGpuImage GskGpuImage; typedef struct _GskGpuOp GskGpuOp; typedef struct _GskGpuOpClass GskGpuOpClass; +typedef guint32 GskGpuShaderFlags; typedef struct _GskGpuShaderImage GskGpuShaderImage; typedef struct _GskGpuShaderOp GskGpuShaderOp; typedef struct _GskGpuShaderOpClass GskGpuShaderOpClass; @@ -48,6 +49,8 @@ typedef enum { GSK_GPU_SHADER_CLIP_RECT, GSK_GPU_SHADER_CLIP_ROUNDED } GskGpuShaderClip; +#define GSK_GPU_SHADER_CLIP_SHIFT 2 +#define GSK_GPU_SHADER_CLIP_MASK ((1 << GSK_GPU_SHADER_CLIP_SHIFT) - 1) typedef enum { GSK_GPU_BLEND_NONE, diff --git a/gsk/gpu/gskvulkandevice.c b/gsk/gpu/gskvulkandevice.c index 86b9995066..9e3291d847 100644 --- a/gsk/gpu/gskvulkandevice.c +++ b/gsk/gpu/gskvulkandevice.c @@ -77,9 +77,9 @@ struct _ConversionCacheEntry struct _PipelineCacheKey { const GskGpuShaderOpClass *op_class; + GskGpuShaderFlags flags; GskGpuColorStates color_states; guint32 variation; - GskGpuShaderClip clip; GskGpuBlend blend; VkFormat format; VkPipeline pipeline; @@ -117,10 +117,11 @@ pipeline_cache_key_hash (gconstpointer data) const PipelineCacheKey *key = data; return GPOINTER_TO_UINT (key->op_class) ^ - key->clip ^ - (key->variation << 2) ^ - (key->blend << 6) ^ - (key->format << 8); + key->flags ^ + (key->color_states << 8) ^ + (key->variation << 16) ^ + (key->blend << 24) ^ + (key->format << 21) ^ (key->format >> 11); } static gboolean @@ -131,8 +132,9 @@ pipeline_cache_key_equal (gconstpointer a, const PipelineCacheKey *keyb = b; return keya->op_class == keyb->op_class && + keya->flags == keyb->flags && + keya->color_states == keyb->color_states && keya->variation == keyb->variation && - keya->clip == keyb->clip && keya->blend == keyb->blend && keya->format == keyb->format; } @@ -903,7 +905,7 @@ gsk_vulkan_device_get_vk_render_pass (GskVulkanDevice *self, typedef struct _GskVulkanShaderSpecialization GskVulkanShaderSpecialization; struct _GskVulkanShaderSpecialization { - guint32 clip; + guint32 flags; guint32 n_immutable_samplers; guint32 n_samplers; guint32 n_buffers; @@ -964,9 +966,9 @@ VkPipeline gsk_vulkan_device_get_vk_pipeline (GskVulkanDevice *self, GskVulkanPipelineLayout *layout, const GskGpuShaderOpClass *op_class, + GskGpuShaderFlags flags, GskGpuColorStates color_states, guint32 variation, - GskGpuShaderClip clip, GskGpuBlend blend, VkFormat format, VkRenderPass render_pass) @@ -978,14 +980,13 @@ gsk_vulkan_device_get_vk_pipeline (GskVulkanDevice *self, const char *version_string; char *vertex_shader_name, *fragment_shader_name; G_GNUC_UNUSED gint64 begin_time = GDK_PROFILER_CURRENT_TIME; - const char *clip_name[] = { "NONE", "RECT", "ROUNDED" }; const char *blend_name[] = { "NONE", "OVER", "ADD", "CLEAR" }; cache_key = (PipelineCacheKey) { .op_class = op_class, .color_states = color_states, .variation = variation, - .clip = clip, + .flags = flags, .blend = blend, .format = format, }; @@ -1027,7 +1028,7 @@ gsk_vulkan_device_get_vk_pipeline (GskVulkanDevice *self, .pMapEntries = (VkSpecializationMapEntry[6]) { { .constantID = 0, - .offset = G_STRUCT_OFFSET (GskVulkanShaderSpecialization, clip), + .offset = G_STRUCT_OFFSET (GskVulkanShaderSpecialization, flags), .size = sizeof (guint32), }, { @@ -1058,7 +1059,7 @@ gsk_vulkan_device_get_vk_pipeline (GskVulkanDevice *self, }, .dataSize = sizeof (GskVulkanShaderSpecialization), .pData = &(GskVulkanShaderSpecialization) { - .clip = clip, + .flags = flags, .n_immutable_samplers = MAX (1, layout->setup.n_immutable_samplers), .n_samplers = layout->setup.n_samplers - MAX (3 * layout->setup.n_immutable_samplers, 1), .n_buffers = layout->setup.n_buffers, @@ -1077,7 +1078,7 @@ gsk_vulkan_device_get_vk_pipeline (GskVulkanDevice *self, .pMapEntries = (VkSpecializationMapEntry[6]) { { .constantID = 0, - .offset = G_STRUCT_OFFSET (GskVulkanShaderSpecialization, clip), + .offset = G_STRUCT_OFFSET (GskVulkanShaderSpecialization, flags), .size = sizeof (guint32), }, { @@ -1108,7 +1109,7 @@ gsk_vulkan_device_get_vk_pipeline (GskVulkanDevice *self, }, .dataSize = sizeof (GskVulkanShaderSpecialization), .pData = &(GskVulkanShaderSpecialization) { - .clip = clip, + .flags = flags, .n_immutable_samplers = MAX (1, layout->setup.n_immutable_samplers), .n_samplers = layout->setup.n_samplers - MAX (3 * layout->setup.n_immutable_samplers, 1), .n_buffers = layout->setup.n_buffers, @@ -1170,22 +1171,22 @@ gsk_vulkan_device_get_vk_pipeline (GskVulkanDevice *self, &pipeline); gdk_profiler_end_markf (begin_time, - "Create Vulkan pipeline", "%s version=%s color states=%u variation=%u clip=%s blend=%s format=%u", + "Create Vulkan pipeline", "%s version=%s color states=%u variation=%u clip=%u blend=%s format=%u", op_class->shader_name, version_string + 1, + flags, color_states, variation, - clip_name[clip], blend_name[blend], format); GSK_DEBUG (SHADERS, - "Create Vulkan pipeline (%s %s, %u/%u/%s/%s/%u) for layout (%" G_GSIZE_FORMAT "/%" G_GSIZE_FORMAT "/%" G_GSIZE_FORMAT ")", + "Create Vulkan pipeline (%s %s, %u/%u/%u/%s/%u) for layout (%" G_GSIZE_FORMAT "/%" G_GSIZE_FORMAT "/%" G_GSIZE_FORMAT ")", op_class->shader_name, version_string + 1, + flags, color_states, variation, - clip_name[clip], blend_name[blend], format, layout->setup.n_buffers, diff --git a/gsk/gpu/gskvulkandeviceprivate.h b/gsk/gpu/gskvulkandeviceprivate.h index 01d439b64b..888eb71dd2 100644 --- a/gsk/gpu/gskvulkandeviceprivate.h +++ b/gsk/gpu/gskvulkandeviceprivate.h @@ -73,9 +73,9 @@ VkRenderPass gsk_vulkan_device_get_vk_render_pass (GskVulk VkPipeline gsk_vulkan_device_get_vk_pipeline (GskVulkanDevice *self, GskVulkanPipelineLayout*layout, const GskGpuShaderOpClass *op_class, + GskGpuShaderFlags flags, GskGpuColorStates color_states, guint32 variation, - GskGpuShaderClip clip, GskGpuBlend blend, VkFormat format, VkRenderPass render_pass); diff --git a/gsk/gpu/shaders/common-vulkan.glsl b/gsk/gpu/shaders/common-vulkan.glsl index 2a2f49f91d..875d76a23f 100644 --- a/gsk/gpu/shaders/common-vulkan.glsl +++ b/gsk/gpu/shaders/common-vulkan.glsl @@ -10,7 +10,7 @@ layout(push_constant) uniform PushConstants { vec2 scale; } push; -layout(constant_id=0) const uint GSK_SHADER_CLIP = GSK_GPU_SHADER_CLIP_NONE; +layout(constant_id=0) const uint GSK_FLAGS = 0; layout(constant_id=1) const uint GSK_N_IMMUTABLE_SAMPLERS = 32; layout(constant_id=2) const uint GSK_N_SAMPLERS = 32; layout(constant_id=3) const uint GSK_N_BUFFERS = 32; diff --git a/gsk/gpu/shaders/common.glsl b/gsk/gpu/shaders/common.glsl index c921a31dbc..4b79f35aa8 100644 --- a/gsk/gpu/shaders/common.glsl +++ b/gsk/gpu/shaders/common.glsl @@ -13,6 +13,8 @@ void main_clip_rounded (void); #include "common-gl.glsl" #endif +#define GSK_SHADER_CLIP (GSK_FLAGS & 3u) + #include "color.glsl" #include "rect.glsl" #include "roundedrect.glsl" From 7b76170f4681a9fd9190ef1c54195d48663f27e6 Mon Sep 17 00:00:00 2001 From: Benjamin Otte Date: Sat, 20 Jul 2024 10:25:17 +0200 Subject: [PATCH 16/28] gpu: Flip the big switch Rewrite all shaders to use 2 predefined samplers called GSK_TEXTURE0 and GSK_TEXTURE1 instead of wrapper functions. On GL and Vulkan compat mode, these map directly to samplers. On Vulkan proper, they map to 2 indices into the texture array, like before. From now on, the old nvidia GPUs - ie the 3xx drivers - should start working again. Fixes: #6564 Fixes: #6574 Fixes: #6654 --- gsk/gpu/gskgldevice.c | 19 +- gsk/gpu/gskglframe.c | 5 +- gsk/gpu/gskgpublendmodeop.c | 6 +- gsk/gpu/gskgpublurop.c | 3 +- gsk/gpu/gskgpucolorizeop.c | 3 +- gsk/gpu/gskgpucolormatrixop.c | 3 +- gsk/gpu/gskgpuconvertop.c | 3 +- gsk/gpu/gskgpucrossfadeop.c | 6 +- gsk/gpu/gskgpumaskop.c | 6 +- gsk/gpu/gskgpuopprivate.h | 2 + gsk/gpu/gskgpushaderop.c | 16 +- gsk/gpu/gskgputextureop.c | 3 +- gsk/gpu/shaders/common-gl.glsl | 357 +-------- gsk/gpu/shaders/common-vulkan.glsl | 983 +------------------------ gsk/gpu/shaders/common.glsl | 14 +- gsk/gpu/shaders/gskgpublendmode.glsl | 16 +- gsk/gpu/shaders/gskgpublur.glsl | 9 +- gsk/gpu/shaders/gskgpucolorize.glsl | 6 +- gsk/gpu/shaders/gskgpucolormatrix.glsl | 5 +- gsk/gpu/shaders/gskgpuconvert.glsl | 11 +- gsk/gpu/shaders/gskgpucrossfade.glsl | 18 +- gsk/gpu/shaders/gskgpumask.glsl | 14 +- gsk/gpu/shaders/gskgputexture.glsl | 5 +- 23 files changed, 81 insertions(+), 1432 deletions(-) diff --git a/gsk/gpu/gskgldevice.c b/gsk/gpu/gskgldevice.c index 4ea27cb1c6..5eff73f707 100644 --- a/gsk/gpu/gskgldevice.c +++ b/gsk/gpu/gskgldevice.c @@ -554,7 +554,6 @@ gsk_gl_device_use_program (GskGLDevice *self, .variation = variation, .n_external_textures = n_external_textures }; - guint i, n_textures; program_id = GPOINTER_TO_UINT (g_hash_table_lookup (self->gl_programs, &key)); if (program_id) @@ -575,21 +574,9 @@ gsk_gl_device_use_program (GskGLDevice *self, glUseProgram (program_id); - n_textures = 16 - 3 * n_external_textures; - - for (i = 0; i < n_external_textures; i++) - { - char *name = g_strdup_printf ("external_textures[%u]", i); - glUniform1i (glGetUniformLocation (program_id, name), n_textures + 3 * i); - g_free (name); - } - - for (i = 0; i < n_textures; i++) - { - char *name = g_strdup_printf ("textures[%u]", i); - glUniform1i (glGetUniformLocation (program_id, name), i); - g_free (name); - } + /* space by 3 because external textures may need 3 texture units */ + glUniform1i (glGetUniformLocation (program_id, "GSK_TEXTURE0"), 0); + glUniform1i (glGetUniformLocation (program_id, "GSK_TEXTURE1"), 3); } GLuint diff --git a/gsk/gpu/gskglframe.c b/gsk/gpu/gskglframe.c index e8b9dbbae3..bcff6fdcf4 100644 --- a/gsk/gpu/gskglframe.c +++ b/gsk/gpu/gskglframe.c @@ -176,7 +176,10 @@ gsk_gl_frame_submit (GskGpuFrame *frame, GskGpuOp *op) { GskGLFrame *self = GSK_GL_FRAME (frame); - GskGLCommandState state = { 0, }; + GskGLCommandState state = { + /* rest is 0 */ + .current_samplers = { GSK_GPU_SAMPLER_N_SAMPLERS, GSK_GPU_SAMPLER_N_SAMPLERS } + }; glEnable (GL_SCISSOR_TEST); diff --git a/gsk/gpu/gskgpublendmodeop.c b/gsk/gpu/gskgpublendmodeop.c index 5fa68b5ec7..bf0d9940e3 100644 --- a/gsk/gpu/gskgpublendmodeop.c +++ b/gsk/gpu/gskgpublendmodeop.c @@ -25,9 +25,9 @@ gsk_gpu_blend_mode_op_print_instance (GskGpuShaderOp *shader, gsk_gpu_print_enum (string, GSK_TYPE_BLEND_MODE, shader->variation); gsk_gpu_print_rect (string, instance->rect); - gsk_gpu_print_image_descriptor (string, shader->desc, instance->bottom_id); + gsk_gpu_print_image (string, shader->images[0]); gsk_gpu_print_enum (string, GSK_TYPE_BLEND_MODE, shader->variation); - gsk_gpu_print_image_descriptor (string, shader->desc, instance->top_id); + gsk_gpu_print_image (string, shader->images[1]); } static const GskGpuShaderOpClass GSK_GPU_BLEND_MODE_OP_CLASS = { @@ -78,7 +78,5 @@ gsk_gpu_blend_mode_op (GskGpuFrame *frame, gsk_gpu_rect_to_float (rect, offset, instance->rect); instance->opacity = opacity; gsk_gpu_rect_to_float (bottom->bounds, offset, instance->bottom_rect); - instance->bottom_id = bottom->descriptor; gsk_gpu_rect_to_float (top->bounds, offset, instance->top_rect); - instance->top_id = top->descriptor; } diff --git a/gsk/gpu/gskgpublurop.c b/gsk/gpu/gskgpublurop.c index 390884fa17..24f59e90c3 100644 --- a/gsk/gpu/gskgpublurop.c +++ b/gsk/gpu/gskgpublurop.c @@ -28,7 +28,7 @@ gsk_gpu_blur_op_print_instance (GskGpuShaderOp *shader, g_string_append_printf (string, "%g,%g ", instance->blur_direction[0], instance->blur_direction[1]); gsk_gpu_print_rect (string, instance->rect); - gsk_gpu_print_image_descriptor (string, shader->desc, instance->tex_id); + gsk_gpu_print_image (string, shader->images[0]); } static const GskGpuShaderOpClass GSK_GPU_BLUR_OP_CLASS = { @@ -80,7 +80,6 @@ gsk_gpu_blur_op_full (GskGpuFrame *frame, gsk_gpu_rect_to_float (image->bounds, offset, instance->tex_rect); graphene_vec2_to_float (blur_direction, instance->blur_direction); gsk_gpu_color_to_float (blur_color, instance->blur_color); - instance->tex_id = image->descriptor; } void diff --git a/gsk/gpu/gskgpucolorizeop.c b/gsk/gpu/gskgpucolorizeop.c index 8e62bcc05b..e5bc2a07ed 100644 --- a/gsk/gpu/gskgpucolorizeop.c +++ b/gsk/gpu/gskgpucolorizeop.c @@ -23,7 +23,7 @@ gsk_gpu_colorize_op_print_instance (GskGpuShaderOp *shader, GskGpuColorizeInstance *instance = (GskGpuColorizeInstance *) instance_; gsk_gpu_print_rect (string, instance->rect); - gsk_gpu_print_image_descriptor (string, shader->desc, instance->tex_id); + gsk_gpu_print_image (string, shader->images[0]); gsk_gpu_print_rgba (string, instance->color); } @@ -72,6 +72,5 @@ gsk_gpu_colorize_op (GskGpuFrame *frame, gsk_gpu_rect_to_float (image->coverage ? image->coverage : image->bounds, offset, instance->rect); gsk_gpu_rect_to_float (image->bounds, offset, instance->tex_rect); - instance->tex_id = image->descriptor; gsk_gpu_color_to_float (color, instance->color); } diff --git a/gsk/gpu/gskgpucolormatrixop.c b/gsk/gpu/gskgpucolormatrixop.c index 26a0fa553f..0e8ee568f3 100644 --- a/gsk/gpu/gskgpucolormatrixop.c +++ b/gsk/gpu/gskgpucolormatrixop.c @@ -23,7 +23,7 @@ gsk_gpu_color_matrix_op_print_instance (GskGpuShaderOp *shader, GskGpuColormatrixInstance *instance = (GskGpuColormatrixInstance *) instance_; gsk_gpu_print_rect (string, instance->rect); - gsk_gpu_print_image_descriptor (string, shader->desc, instance->tex_id); + gsk_gpu_print_image (string, shader->images[0]); } static const GskGpuShaderOpClass GSK_GPU_COLOR_MATRIX_OP_CLASS = { @@ -72,7 +72,6 @@ gsk_gpu_color_matrix_op (GskGpuFrame *frame, gsk_gpu_rect_to_float (image->coverage, offset, instance->rect); gsk_gpu_rect_to_float (image->bounds, offset, instance->tex_rect); - instance->tex_id = image->descriptor; graphene_matrix_to_float (color_matrix, instance->color_matrix); graphene_vec4_to_float (color_offset, instance->color_offset); } diff --git a/gsk/gpu/gskgpuconvertop.c b/gsk/gpu/gskgpuconvertop.c index 77aa1235ea..96dbc9cb1a 100644 --- a/gsk/gpu/gskgpuconvertop.c +++ b/gsk/gpu/gskgpuconvertop.c @@ -27,7 +27,7 @@ gsk_gpu_convert_op_print_instance (GskGpuShaderOp *shader, GskGpuConvertInstance *instance = (GskGpuConvertInstance *) instance_; gsk_gpu_print_rect (string, instance->rect); - gsk_gpu_print_image_descriptor (string, shader->desc, instance->tex_id); + gsk_gpu_print_image (string, shader->images[0]); if (shader->variation & VARIATION_STRAIGHT_ALPHA) gsk_gpu_print_string (string, "straight"); } @@ -79,7 +79,6 @@ gsk_gpu_convert_op (GskGpuFrame *frame, gsk_gpu_rect_to_float (image->coverage, offset, instance->rect); gsk_gpu_rect_to_float (image->bounds, offset, instance->tex_rect); - instance->tex_id = image->descriptor; instance->opacity = opacity; } diff --git a/gsk/gpu/gskgpucrossfadeop.c b/gsk/gpu/gskgpucrossfadeop.c index f86a0c20af..3f6a8e399d 100644 --- a/gsk/gpu/gskgpucrossfadeop.c +++ b/gsk/gpu/gskgpucrossfadeop.c @@ -23,8 +23,8 @@ gsk_gpu_cross_fade_op_print_instance (GskGpuShaderOp *shader, GskGpuCrossfadeInstance *instance = (GskGpuCrossfadeInstance *) instance_; gsk_gpu_print_rect (string, instance->rect); - gsk_gpu_print_image_descriptor (string, shader->desc, instance->start_id); - gsk_gpu_print_image_descriptor (string, shader->desc, instance->end_id); + gsk_gpu_print_image (string, shader->images[0]); + gsk_gpu_print_image (string, shader->images[1]); g_string_append_printf (string, "%g%%", 100 * instance->opacity_progress[1]); } @@ -78,7 +78,5 @@ gsk_gpu_cross_fade_op (GskGpuFrame *frame, instance->opacity_progress[0] = opacity; instance->opacity_progress[1] = progress; gsk_gpu_rect_to_float (start->bounds, offset, instance->start_rect); - instance->start_id = start->descriptor; gsk_gpu_rect_to_float (end->bounds, offset, instance->end_rect); - instance->end_id = end->descriptor; } diff --git a/gsk/gpu/gskgpumaskop.c b/gsk/gpu/gskgpumaskop.c index b58efe0a12..73d5cbde17 100644 --- a/gsk/gpu/gskgpumaskop.c +++ b/gsk/gpu/gskgpumaskop.c @@ -25,8 +25,8 @@ gsk_gpu_mask_op_print_instance (GskGpuShaderOp *shader, gsk_gpu_print_enum (string, GSK_TYPE_MASK_MODE, shader->variation); gsk_gpu_print_rect (string, instance->rect); - gsk_gpu_print_image_descriptor (string, shader->desc, instance->source_id); - gsk_gpu_print_image_descriptor (string, shader->desc, instance->mask_id); + gsk_gpu_print_image (string, shader->images[0]); + gsk_gpu_print_image (string, shader->images[1]); } static const GskGpuShaderOpClass GSK_GPU_MASK_OP_CLASS = { @@ -76,8 +76,6 @@ gsk_gpu_mask_op (GskGpuFrame *frame, gsk_gpu_rect_to_float (rect, offset, instance->rect); gsk_gpu_rect_to_float (source->bounds, offset, instance->source_rect); - instance->source_id = source->descriptor; gsk_gpu_rect_to_float (mask->bounds, offset, instance->mask_rect); - instance->mask_id = mask->descriptor; instance->opacity = opacity; } diff --git a/gsk/gpu/gskgpuopprivate.h b/gsk/gpu/gskgpuopprivate.h index 4eb332016e..e2687f55e5 100644 --- a/gsk/gpu/gskgpuopprivate.h +++ b/gsk/gpu/gskgpuopprivate.h @@ -30,6 +30,8 @@ struct _GskGLCommandState guint32 variation; gsize n_external; } current_program; + GskGpuImage *current_images[2]; + GskGpuSampler current_samplers[2]; GskGLDescriptors *desc; }; diff --git a/gsk/gpu/gskgpushaderop.c b/gsk/gpu/gskgpushaderop.c index 58a97da0f9..ee016ba0bc 100644 --- a/gsk/gpu/gskgpushaderop.c +++ b/gsk/gpu/gskgpushaderop.c @@ -174,10 +174,20 @@ gsk_gpu_shader_op_gl_command_n (GskGpuOp *op, n_external); } - if (desc != state->desc && desc) + for (i = 0; i < shader_op_class->n_textures; i++) { - gsk_gl_descriptors_use (desc); - state->desc = desc; + if (state->current_images[i] != self->images[i]) + { + glActiveTexture (GL_TEXTURE0 + 3 * i); + gsk_gl_image_bind_texture (GSK_GL_IMAGE (self->images[i])); + state->current_images[i] = self->images[i]; + } + if (state->current_samplers[i] != self->samplers[i]) + { + glBindSampler (3 * i, gsk_gl_device_get_sampler_id (GSK_GL_DEVICE (gsk_gpu_frame_get_device (frame)), + self->samplers[i])); + state->current_samplers[i] = self->samplers[i]; + } } if (gsk_gpu_frame_should_optimize (frame, GSK_GPU_OPTIMIZE_MERGE)) diff --git a/gsk/gpu/gskgputextureop.c b/gsk/gpu/gskgputextureop.c index 5dd4e605c1..8d12aa0165 100644 --- a/gsk/gpu/gskgputextureop.c +++ b/gsk/gpu/gskgputextureop.c @@ -23,7 +23,7 @@ gsk_gpu_texture_op_print_instance (GskGpuShaderOp *shader, GskGpuTextureInstance *instance = (GskGpuTextureInstance *) instance_; gsk_gpu_print_rect (string, instance->rect); - gsk_gpu_print_image_descriptor (string, shader->desc, instance->tex_id); + gsk_gpu_print_image (string, shader->images[0]); } static const GskGpuShaderOpClass GSK_GPU_TEXTURE_OP_CLASS = { @@ -69,5 +69,4 @@ gsk_gpu_texture_op (GskGpuFrame *frame, gsk_gpu_rect_to_float (image->coverage ? image->coverage : image->bounds, offset, instance->rect); gsk_gpu_rect_to_float (image->bounds, offset, instance->tex_rect); - instance->tex_id = image->descriptor; } diff --git a/gsk/gpu/shaders/common-gl.glsl b/gsk/gpu/shaders/common-gl.glsl index cf4f1ac609..c4b2555fa2 100644 --- a/gsk/gpu/shaders/common-gl.glsl +++ b/gsk/gpu/shaders/common-gl.glsl @@ -1,5 +1,8 @@ precision highp float; +#define GSK_TEXTURE0_IS_EXTERNAL GSK_FLAGS & 4u +#define GSK_TEXTURE1_IS_EXTERNAL GSK_FLAGS & 8u + #if __VERSION__ < 420 || (defined(GSK_GLES) && __VERSION__ < 310) layout(std140) #else @@ -17,13 +20,6 @@ uniform PushConstants #define GSK_GLOBAL_CLIP_RECT push.clip[0] #define GSK_GLOBAL_SCALE push.scale -#if N_EXTERNAL_TEXTURES > 0 -uniform samplerExternalOES external_textures[N_EXTERNAL_TEXTURES]; -#endif -#if N_TEXTURES > 0 -uniform sampler2D textures[N_TEXTURES]; -#endif - #define GSK_VERTEX_INDEX gl_VertexID @@ -38,348 +34,23 @@ uniform sampler2D textures[N_TEXTURES]; #define PASS(_loc) in #define PASS_FLAT(_loc) flat in -#if __VERSION__ < 400 || defined(GSK_GLES) +#if GSK_N_TEXTURES > 0 -vec4 -gsk_texture (uint id, - vec2 pos) -{ - if ((id & 1u) != 0u) - { - switch (id >> 1u) - { - case 0u: -#if N_EXTERNAL_TEXTURES > 0 - return texture (external_textures[0], pos); +#if GSK_TEXTURE0_IS_EXTERNAL +uniform samplerExternalOES GSK_TEXTURE0; +#else +uniform sampler2D GSK_TEXTURE0; #endif -#if N_EXTERNAL_TEXTURES > 1 - case 1u: - return texture (external_textures[1], pos); -#endif - case 2u: -#if N_EXTERNAL_TEXTURES > 2 - return texture (external_textures[2], pos); -#endif - case 3u: -#if N_EXTERNAL_TEXTURES > 3 - return texture (external_textures[3], pos); -#endif - case 4u: -#if N_EXTERNAL_TEXTURES > 4 - return texture (external_textures[4], pos); -#endif - case 5u: -#if N_EXTERNAL_TEXTURES > 5 - return texture (external_textures[5], pos); -#endif - default: - break; - } - } - else - { - switch (id >> 1u) - { - case 0u: -#if N_TEXTURES > 0 - return texture (textures[0], pos); -#endif - case 1u: -#if N_TEXTURES > 1 - return texture (textures[1], pos); -#endif - case 2u: -#if N_TEXTURES > 2 - return texture (textures[2], pos); -#endif - case 3u: -#if N_TEXTURES > 3 - return texture (textures[3], pos); -#endif - case 4u: -#if N_TEXTURES > 4 - return texture (textures[4], pos); -#endif - case 5u: -#if N_TEXTURES > 5 - return texture (textures[5], pos); -#endif - case 6u: -#if N_TEXTURES > 6 - return texture (textures[6], pos); -#endif - case 7u: -#if N_TEXTURES > 7 - return texture (textures[7], pos); -#endif - case 8u: -#if N_TEXTURES > 8 - return texture (textures[8], pos); -#endif - case 9u: -#if N_TEXTURES > 9 - return texture (textures[9], pos); -#endif - case 10u: -#if N_TEXTURES > 10 - return texture (textures[10], pos); -#endif - case 11u: -#if N_TEXTURES > 11 - return texture (textures[11], pos); -#endif - case 12u: -#if N_TEXTURES > 12 - return texture (textures[12], pos); -#endif - case 13u: -#if N_TEXTURES > 13 - return texture (textures[13], pos); -#endif - case 14u: -#if N_TEXTURES > 14 - return texture (textures[14], pos); -#endif - case 15u: -#if N_TEXTURES > 15 - return texture (textures[15], pos); -#endif - default: - break; - } - } - return vec4 (1.0, 0.0, 0.8, 1.0); -} -ivec2 -gsk_texture_size (uint id, - int lod) -{ - if ((id & 1u) != 0u) - { - switch (id >> 1u) - { - case 0u: -#if N_EXTERNAL_TEXTURES > 0 - return textureSize (external_textures[0], lod); -#endif -#if N_EXTERNAL_TEXTURES > 1 - case 1u: - return textureSize (external_textures[1], lod); -#endif - case 2u: -#if N_EXTERNAL_TEXTURES > 2 - return textureSize (external_textures[2], lod); -#endif - case 3u: -#if N_EXTERNAL_TEXTURES > 3 - return textureSize (external_textures[3], lod); -#endif - case 4u: -#if N_EXTERNAL_TEXTURES > 4 - return textureSize (external_textures[4], lod); -#endif - case 5u: -#if N_EXTERNAL_TEXTURES > 5 - return textureSize (external_textures[5], lod); -#endif - default: - break; - } - } - else - { - switch (id >> 1u) - { - case 0u: -#if N_TEXTURES > 0 - return textureSize (textures[0], lod); -#endif - case 1u: -#if N_TEXTURES > 1 - return textureSize (textures[1], lod); -#endif - case 2u: -#if N_TEXTURES > 2 - return textureSize (textures[2], lod); -#endif - case 3u: -#if N_TEXTURES > 3 - return textureSize (textures[3], lod); -#endif - case 4u: -#if N_TEXTURES > 4 - return textureSize (textures[4], lod); -#endif - case 5u: -#if N_TEXTURES > 5 - return textureSize (textures[5], lod); -#endif - case 6u: -#if N_TEXTURES > 6 - return textureSize (textures[6], lod); -#endif - case 7u: -#if N_TEXTURES > 7 - return textureSize (textures[7], lod); -#endif - case 8u: -#if N_TEXTURES > 8 - return textureSize (textures[8], lod); -#endif - case 9u: -#if N_TEXTURES > 9 - return textureSize (textures[9], lod); -#endif - case 10u: -#if N_TEXTURES > 10 - return textureSize (textures[10], lod); -#endif - case 11u: -#if N_TEXTURES > 11 - return textureSize (textures[11], lod); -#endif - case 12u: -#if N_TEXTURES > 12 - return textureSize (textures[12], lod); -#endif - case 13u: -#if N_TEXTURES > 13 - return textureSize (textures[13], lod); -#endif - case 14u: -#if N_TEXTURES > 14 - return textureSize (textures[14], lod); -#endif - case 15u: -#if N_TEXTURES > 15 - return textureSize (textures[15], lod); -#endif - default: - break; - } - } - return ivec2 (1, 1); -} +#if GSK_N_TEXTURES > 1 -vec4 -gsk_texel_fetch (uint id, - ivec2 pos, - int lod) -{ - if ((id & 1u) != 0u) - { - switch (id >> 1u) - { - case 0u: -#if N_EXTERNAL_TEXTURES > 0 - return texelFetch (external_textures[0], pos, lod); +#if GSK_TEXTURE1_IS_EXTERNAL +uniform samplerExternalOES GSK_TEXTURE1; +#else +uniform sampler2D GSK_TEXTURE1; #endif -#if N_EXTERNAL_TEXTURES > 1 - case 1u: - return texelFetch (external_textures[1], pos, lod); -#endif - case 2u: -#if N_EXTERNAL_TEXTURES > 2 - return texelFetch (external_textures[2], pos, lod); -#endif - case 3u: -#if N_EXTERNAL_TEXTURES > 3 - return texelFetch (external_textures[3], pos, lod); -#endif - case 4u: -#if N_EXTERNAL_TEXTURES > 4 - return texelFetch (external_textures[4], pos, lod); -#endif - case 5u: -#if N_EXTERNAL_TEXTURES > 5 - return texelFetch (external_textures[5], pos, lod); -#endif - default: - break; - } - } - else - { - switch (id >> 1u) - { - case 0u: -#if N_TEXTURES > 0 - return texelFetch (textures[0], pos, lod); -#endif - case 1u: -#if N_TEXTURES > 1 - return texelFetch (textures[1], pos, lod); -#endif - case 2u: -#if N_TEXTURES > 2 - return texelFetch (textures[2], pos, lod); -#endif - case 3u: -#if N_TEXTURES > 3 - return texelFetch (textures[3], pos, lod); -#endif - case 4u: -#if N_TEXTURES > 4 - return texelFetch (textures[4], pos, lod); -#endif - case 5u: -#if N_TEXTURES > 5 - return texelFetch (textures[5], pos, lod); -#endif - case 6u: -#if N_TEXTURES > 6 - return texelFetch (textures[6], pos, lod); -#endif - case 7u: -#if N_TEXTURES > 7 - return texelFetch (textures[7], pos, lod); -#endif - case 8u: -#if N_TEXTURES > 8 - return texelFetch (textures[8], pos, lod); -#endif - case 9u: -#if N_TEXTURES > 9 - return texelFetch (textures[9], pos, lod); -#endif - case 10u: -#if N_TEXTURES > 10 - return texelFetch (textures[10], pos, lod); -#endif - case 11u: -#if N_TEXTURES > 11 - return texelFetch (textures[11], pos, lod); -#endif - case 12u: -#if N_TEXTURES > 12 - return texelFetch (textures[12], pos, lod); -#endif - case 13u: -#if N_TEXTURES > 13 - return texelFetch (textures[13], pos, lod); -#endif - case 14u: -#if N_TEXTURES > 14 - return texelFetch (textures[14], pos, lod); -#endif - case 15u: -#if N_TEXTURES > 15 - return texelFetch (textures[15], pos, lod); -#endif - default: - break; - } - } - return vec4 (1.0, 0.0, 0.8, 1.0); -} - -#else /* !GSK_GLES */ - -#define gsk_texture(id, pos) texture (textures[id >> 1], pos) -#define gsk_texture_size(id, lod) textureSize (textures[id >> 1], lod) -#define gsk_texel_fetch(id, pos, lod) texelFetch (textures[id >> 1], pos, lod) +#endif #endif layout(location = 0) out vec4 out_color; diff --git a/gsk/gpu/shaders/common-vulkan.glsl b/gsk/gpu/shaders/common-vulkan.glsl index 875d76a23f..6380c4cdb8 100644 --- a/gsk/gpu/shaders/common-vulkan.glsl +++ b/gsk/gpu/shaders/common-vulkan.glsl @@ -40,987 +40,8 @@ layout(set = 0, binding = 1) uniform sampler2D textures[GSK_N_SAMPLERS]; layout(location = 0) out vec4 out_color; -vec4 -gsk_texture (uint id, - vec2 pos) -{ - if ((id & 1) != 0) - { - id >>= 1; - if (id < 16) - { - if (id < 8) - { - if (id < 4) - { - if (id < 2) - { - if (id < 1) - return texture (immutable_textures[0], pos); - else if (GSK_N_IMMUTABLE_SAMPLERS > 1) - return texture (immutable_textures[1], pos); - } - else if (GSK_N_IMMUTABLE_SAMPLERS > 2) - { - if (id < 3) - return texture (immutable_textures[2], pos); - else if (GSK_N_IMMUTABLE_SAMPLERS > 3) - return texture (immutable_textures[3], pos); - } - } - else if (GSK_N_IMMUTABLE_SAMPLERS > 4) - { - if (id < 6) - { - if (id < 5) - return texture (immutable_textures[4], pos); - else if (GSK_N_IMMUTABLE_SAMPLERS > 5) - return texture (immutable_textures[5], pos); - } - else if (GSK_N_IMMUTABLE_SAMPLERS > 6) - { - if (id < 7) - return texture (immutable_textures[6], pos); - else if (GSK_N_IMMUTABLE_SAMPLERS > 7) - return texture (immutable_textures[7], pos); - } - } - } - else if (GSK_N_IMMUTABLE_SAMPLERS > 8) - { - if (id < 12) - { - if (id < 10) - { - if (id < 9) - return texture (immutable_textures[8], pos); - else if (GSK_N_IMMUTABLE_SAMPLERS > 9) - return texture (immutable_textures[9], pos); - } - else if (GSK_N_IMMUTABLE_SAMPLERS > 10) - { - if (id < 11) - return texture (immutable_textures[10], pos); - else if (GSK_N_IMMUTABLE_SAMPLERS > 11) - return texture (immutable_textures[11], pos); - } - } - else if (GSK_N_IMMUTABLE_SAMPLERS > 12) - { - if (id < 14) - { - if (id < 13) - return texture (immutable_textures[12], pos); - else if (GSK_N_IMMUTABLE_SAMPLERS > 13) - return texture (immutable_textures[13], pos); - } - else if (GSK_N_IMMUTABLE_SAMPLERS > 14) - { - if (id < 15) - return texture (immutable_textures[14], pos); - else if (GSK_N_IMMUTABLE_SAMPLERS > 15) - return texture (immutable_textures[15], pos); - } - } - } - } - else if (GSK_N_IMMUTABLE_SAMPLERS > 16) - { - if (id < 24) - { - if (id < 20) - { - if (id < 18) - { - if (id < 17) - return texture (immutable_textures[16], pos); - else if (GSK_N_IMMUTABLE_SAMPLERS > 17) - return texture (immutable_textures[17], pos); - } - else if (GSK_N_IMMUTABLE_SAMPLERS > 18) - { - if (id < 19) - return texture (immutable_textures[18], pos); - else if (GSK_N_IMMUTABLE_SAMPLERS > 19) - return texture (immutable_textures[19], pos); - } - } - else if (GSK_N_IMMUTABLE_SAMPLERS > 20) - { - if (id < 22) - { - if (id < 21) - return texture (immutable_textures[20], pos); - else if (GSK_N_IMMUTABLE_SAMPLERS > 21) - return texture (immutable_textures[21], pos); - } - else if (GSK_N_IMMUTABLE_SAMPLERS > 22) - { - if (id < 23) - return texture (immutable_textures[22], pos); - else if (GSK_N_IMMUTABLE_SAMPLERS > 23) - return texture (immutable_textures[23], pos); - } - } - } - else if (GSK_N_IMMUTABLE_SAMPLERS > 24) - { - if (id < 28) - { - if (id < 26) - { - if (id < 25) - return texture (immutable_textures[24], pos); - else if (GSK_N_IMMUTABLE_SAMPLERS > 25) - return texture (immutable_textures[25], pos); - } - else if (GSK_N_IMMUTABLE_SAMPLERS > 26) - { - if (id < 27) - return texture (immutable_textures[26], pos); - else if (GSK_N_IMMUTABLE_SAMPLERS > 27) - return texture (immutable_textures[27], pos); - } - } - else if (GSK_N_IMMUTABLE_SAMPLERS > 28) - { - if (id < 30) - { - if (id < 29) - return texture (immutable_textures[28], pos); - else if (GSK_N_IMMUTABLE_SAMPLERS > 29) - return texture (immutable_textures[29], pos); - } - else if (GSK_N_IMMUTABLE_SAMPLERS > 30) - { - if (id < 31) - return texture (immutable_textures[30], pos); - else if (GSK_N_IMMUTABLE_SAMPLERS > 31) - return texture (immutable_textures[31], pos); - } - } - } - } - } - else - { - id >>= 1; -#ifdef HAVE_VULKAN_1_2 - return texture (textures[nonuniformEXT (id)], pos); -#else - if (id < 16) - { - if (id < 8) - { - if (id < 4) - { - if (id < 2) - { - if (id < 1) - return texture (textures[0], pos); - else if (GSK_N_SAMPLERS > 1) - return texture (textures[1], pos); - } - else if (GSK_N_SAMPLERS > 2) - { - if (id < 3) - return texture (textures[2], pos); - else if (GSK_N_SAMPLERS > 3) - return texture (textures[3], pos); - } - } - else if (GSK_N_SAMPLERS > 4) - { - if (id < 6) - { - if (id < 5) - return texture (textures[4], pos); - else if (GSK_N_SAMPLERS > 5) - return texture (textures[5], pos); - } - else if (GSK_N_SAMPLERS > 6) - { - if (id < 7) - return texture (textures[6], pos); - else if (GSK_N_SAMPLERS > 7) - return texture (textures[7], pos); - } - } - } - else if (GSK_N_SAMPLERS > 8) - { - if (id < 12) - { - if (id < 10) - { - if (id < 9) - return texture (textures[8], pos); - else if (GSK_N_SAMPLERS > 9) - return texture (textures[9], pos); - } - else if (GSK_N_SAMPLERS > 10) - { - if (id < 11) - return texture (textures[10], pos); - else if (GSK_N_SAMPLERS > 11) - return texture (textures[11], pos); - } - } - else if (GSK_N_SAMPLERS > 12) - { - if (id < 14) - { - if (id < 13) - return texture (textures[12], pos); - else if (GSK_N_SAMPLERS > 13) - return texture (textures[13], pos); - } - else if (GSK_N_SAMPLERS > 14) - { - if (id < 15) - return texture (textures[14], pos); - else if (GSK_N_SAMPLERS > 15) - return texture (textures[15], pos); - } - } - } - } - else if (GSK_N_SAMPLERS > 16) - { - if (id < 24) - { - if (id < 20) - { - if (id < 18) - { - if (id < 17) - return texture (textures[16], pos); - else if (GSK_N_SAMPLERS > 17) - return texture (textures[17], pos); - } - else if (GSK_N_SAMPLERS > 18) - { - if (id < 19) - return texture (textures[18], pos); - else if (GSK_N_SAMPLERS > 19) - return texture (textures[19], pos); - } - } - else if (GSK_N_SAMPLERS > 20) - { - if (id < 22) - { - if (id < 21) - return texture (textures[20], pos); - else if (GSK_N_SAMPLERS > 21) - return texture (textures[21], pos); - } - else if (GSK_N_SAMPLERS > 22) - { - if (id < 23) - return texture (textures[22], pos); - else if (GSK_N_SAMPLERS > 23) - return texture (textures[23], pos); - } - } - } - else if (GSK_N_SAMPLERS > 24) - { - if (id < 28) - { - if (id < 26) - { - if (id < 25) - return texture (textures[24], pos); - else if (GSK_N_SAMPLERS > 25) - return texture (textures[25], pos); - } - else if (GSK_N_SAMPLERS > 26) - { - if (id < 27) - return texture (textures[26], pos); - else if (GSK_N_SAMPLERS > 27) - return texture (textures[27], pos); - } - } - else if (GSK_N_SAMPLERS > 28) - { - if (id < 30) - { - if (id < 29) - return texture (textures[28], pos); - else if (GSK_N_SAMPLERS > 29) - return texture (textures[29], pos); - } - else if (GSK_N_SAMPLERS > 30) - { - if (id < 31) - return texture (textures[30], pos); - else if (GSK_N_SAMPLERS > 31) - return texture (textures[31], pos); - } - } - } - } -#endif - } - return vec4 (1.0, 0.0, 0.8, 1.0); -} - -ivec2 -gsk_texture_size (uint id, - int lod) -{ - if ((id & 1) != 0) - { - id >>= 1; - if (id < 16) - { - if (id < 8) - { - if (id < 4) - { - if (id < 2) - { - if (id < 1) - return textureSize (immutable_textures[0], lod); - else if (GSK_N_IMMUTABLE_SAMPLERS > 1) - return textureSize (immutable_textures[1], lod); - } - else if (GSK_N_IMMUTABLE_SAMPLERS > 2) - { - if (id < 3) - return textureSize (immutable_textures[2], lod); - else if (GSK_N_IMMUTABLE_SAMPLERS > 3) - return textureSize (immutable_textures[3], lod); - } - } - else if (GSK_N_IMMUTABLE_SAMPLERS > 4) - { - if (id < 6) - { - if (id < 5) - return textureSize (immutable_textures[4], lod); - else if (GSK_N_IMMUTABLE_SAMPLERS > 5) - return textureSize (immutable_textures[5], lod); - } - else if (GSK_N_IMMUTABLE_SAMPLERS > 6) - { - if (id < 7) - return textureSize (immutable_textures[6], lod); - else if (GSK_N_IMMUTABLE_SAMPLERS > 7) - return textureSize (immutable_textures[7], lod); - } - } - } - else if (GSK_N_IMMUTABLE_SAMPLERS > 8) - { - if (id < 12) - { - if (id < 10) - { - if (id < 9) - return textureSize (immutable_textures[8], lod); - else if (GSK_N_IMMUTABLE_SAMPLERS > 9) - return textureSize (immutable_textures[9], lod); - } - else if (GSK_N_IMMUTABLE_SAMPLERS > 10) - { - if (id < 11) - return textureSize (immutable_textures[10], lod); - else if (GSK_N_IMMUTABLE_SAMPLERS > 11) - return textureSize (immutable_textures[11], lod); - } - } - else if (GSK_N_IMMUTABLE_SAMPLERS > 12) - { - if (id < 14) - { - if (id < 13) - return textureSize (immutable_textures[12], lod); - else if (GSK_N_IMMUTABLE_SAMPLERS > 13) - return textureSize (immutable_textures[13], lod); - } - else if (GSK_N_IMMUTABLE_SAMPLERS > 14) - { - if (id < 15) - return textureSize (immutable_textures[14], lod); - else if (GSK_N_IMMUTABLE_SAMPLERS > 15) - return textureSize (immutable_textures[15], lod); - } - } - } - } - else if (GSK_N_IMMUTABLE_SAMPLERS > 16) - { - if (id < 24) - { - if (id < 20) - { - if (id < 18) - { - if (id < 17) - return textureSize (immutable_textures[16], lod); - else if (GSK_N_IMMUTABLE_SAMPLERS > 17) - return textureSize (immutable_textures[17], lod); - } - else if (GSK_N_IMMUTABLE_SAMPLERS > 18) - { - if (id < 19) - return textureSize (immutable_textures[18], lod); - else if (GSK_N_IMMUTABLE_SAMPLERS > 19) - return textureSize (immutable_textures[19], lod); - } - } - else if (GSK_N_IMMUTABLE_SAMPLERS > 20) - { - if (id < 22) - { - if (id < 21) - return textureSize (immutable_textures[20], lod); - else if (GSK_N_IMMUTABLE_SAMPLERS > 21) - return textureSize (immutable_textures[21], lod); - } - else if (GSK_N_IMMUTABLE_SAMPLERS > 22) - { - if (id < 23) - return textureSize (immutable_textures[22], lod); - else if (GSK_N_IMMUTABLE_SAMPLERS > 23) - return textureSize (immutable_textures[23], lod); - } - } - } - else if (GSK_N_IMMUTABLE_SAMPLERS > 24) - { - if (id < 28) - { - if (id < 26) - { - if (id < 25) - return textureSize (immutable_textures[24], lod); - else if (GSK_N_IMMUTABLE_SAMPLERS > 25) - return textureSize (immutable_textures[25], lod); - } - else if (GSK_N_IMMUTABLE_SAMPLERS > 26) - { - if (id < 27) - return textureSize (immutable_textures[26], lod); - else if (GSK_N_IMMUTABLE_SAMPLERS > 27) - return textureSize (immutable_textures[27], lod); - } - } - else if (GSK_N_IMMUTABLE_SAMPLERS > 28) - { - if (id < 30) - { - if (id < 29) - return textureSize (immutable_textures[28], lod); - else if (GSK_N_IMMUTABLE_SAMPLERS > 29) - return textureSize (immutable_textures[29], lod); - } - else if (GSK_N_IMMUTABLE_SAMPLERS > 30) - { - if (id < 31) - return textureSize (immutable_textures[30], lod); - else if (GSK_N_IMMUTABLE_SAMPLERS > 31) - return textureSize (immutable_textures[31], lod); - } - } - } - } - } - else - { - id >>= 1; -#ifdef HAVE_VULKAN_1_2 - return textureSize (textures[nonuniformEXT (id)], lod); -#else - if (id < 16) - { - if (id < 8) - { - if (id < 4) - { - if (id < 2) - { - if (id < 1) - return textureSize (textures[0], lod); - else if (GSK_N_SAMPLERS > 1) - return textureSize (textures[1], lod); - } - else if (GSK_N_SAMPLERS > 2) - { - if (id < 3) - return textureSize (textures[2], lod); - else if (GSK_N_SAMPLERS > 3) - return textureSize (textures[3], lod); - } - } - else if (GSK_N_SAMPLERS > 4) - { - if (id < 6) - { - if (id < 5) - return textureSize (textures[4], lod); - else if (GSK_N_SAMPLERS > 5) - return textureSize (textures[5], lod); - } - else if (GSK_N_SAMPLERS > 6) - { - if (id < 7) - return textureSize (textures[6], lod); - else if (GSK_N_SAMPLERS > 7) - return textureSize (textures[7], lod); - } - } - } - else if (GSK_N_SAMPLERS > 8) - { - if (id < 12) - { - if (id < 10) - { - if (id < 9) - return textureSize (textures[8], lod); - else if (GSK_N_SAMPLERS > 9) - return textureSize (textures[9], lod); - } - else if (GSK_N_SAMPLERS > 10) - { - if (id < 11) - return textureSize (textures[10], lod); - else if (GSK_N_SAMPLERS > 11) - return textureSize (textures[11], lod); - } - } - else if (GSK_N_SAMPLERS > 12) - { - if (id < 14) - { - if (id < 13) - return textureSize (textures[12], lod); - else if (GSK_N_SAMPLERS > 13) - return textureSize (textures[13], lod); - } - else if (GSK_N_SAMPLERS > 14) - { - if (id < 15) - return textureSize (textures[14], lod); - else if (GSK_N_SAMPLERS > 15) - return textureSize (textures[15], lod); - } - } - } - } - else if (GSK_N_SAMPLERS > 16) - { - if (id < 24) - { - if (id < 20) - { - if (id < 18) - { - if (id < 17) - return textureSize (textures[16], lod); - else if (GSK_N_SAMPLERS > 17) - return textureSize (textures[17], lod); - } - else if (GSK_N_SAMPLERS > 18) - { - if (id < 19) - return textureSize (textures[18], lod); - else if (GSK_N_SAMPLERS > 19) - return textureSize (textures[19], lod); - } - } - else if (GSK_N_SAMPLERS > 20) - { - if (id < 22) - { - if (id < 21) - return textureSize (textures[20], lod); - else if (GSK_N_SAMPLERS > 21) - return textureSize (textures[21], lod); - } - else if (GSK_N_SAMPLERS > 22) - { - if (id < 23) - return textureSize (textures[22], lod); - else if (GSK_N_SAMPLERS > 23) - return textureSize (textures[23], lod); - } - } - } - else if (GSK_N_SAMPLERS > 24) - { - if (id < 28) - { - if (id < 26) - { - if (id < 25) - return textureSize (textures[24], lod); - else if (GSK_N_SAMPLERS > 25) - return textureSize (textures[25], lod); - } - else if (GSK_N_SAMPLERS > 26) - { - if (id < 27) - return textureSize (textures[26], lod); - else if (GSK_N_SAMPLERS > 27) - return textureSize (textures[27], lod); - } - } - else if (GSK_N_SAMPLERS > 28) - { - if (id < 30) - { - if (id < 29) - return textureSize (textures[28], lod); - else if (GSK_N_SAMPLERS > 29) - return textureSize (textures[29], lod); - } - else if (GSK_N_SAMPLERS > 30) - { - if (id < 31) - return textureSize (textures[30], lod); - else if (GSK_N_SAMPLERS > 31) - return textureSize (textures[31], lod); - } - } - } - } -#endif - } - return ivec2 (1, 1); -} - -vec4 -gsk_texel_fetch (uint id, - ivec2 pos, - int lod) -{ - if ((id & 1) != 0) - { - id >>= 1; - if (id < 16) - { - if (id < 8) - { - if (id < 4) - { - if (id < 2) - { - if (id < 1) - return texelFetch (immutable_textures[0], pos, lod); - else if (GSK_N_IMMUTABLE_SAMPLERS > 1) - return texelFetch (immutable_textures[1], pos, lod); - } - else if (GSK_N_IMMUTABLE_SAMPLERS > 2) - { - if (id < 3) - return texelFetch (immutable_textures[2], pos, lod); - else if (GSK_N_IMMUTABLE_SAMPLERS > 3) - return texelFetch (immutable_textures[3], pos, lod); - } - } - else if (GSK_N_IMMUTABLE_SAMPLERS > 4) - { - if (id < 6) - { - if (id < 5) - return texelFetch (immutable_textures[4], pos, lod); - else if (GSK_N_IMMUTABLE_SAMPLERS > 5) - return texelFetch (immutable_textures[5], pos, lod); - } - else if (GSK_N_IMMUTABLE_SAMPLERS > 6) - { - if (id < 7) - return texelFetch (immutable_textures[6], pos, lod); - else if (GSK_N_IMMUTABLE_SAMPLERS > 7) - return texelFetch (immutable_textures[7], pos, lod); - } - } - } - else if (GSK_N_IMMUTABLE_SAMPLERS > 8) - { - if (id < 12) - { - if (id < 10) - { - if (id < 9) - return texelFetch (immutable_textures[8], pos, lod); - else if (GSK_N_IMMUTABLE_SAMPLERS > 9) - return texelFetch (immutable_textures[9], pos, lod); - } - else if (GSK_N_IMMUTABLE_SAMPLERS > 10) - { - if (id < 11) - return texelFetch (immutable_textures[10], pos, lod); - else if (GSK_N_IMMUTABLE_SAMPLERS > 11) - return texelFetch (immutable_textures[11], pos, lod); - } - } - else if (GSK_N_IMMUTABLE_SAMPLERS > 12) - { - if (id < 14) - { - if (id < 13) - return texelFetch (immutable_textures[12], pos, lod); - else if (GSK_N_IMMUTABLE_SAMPLERS > 13) - return texelFetch (immutable_textures[13], pos, lod); - } - else if (GSK_N_IMMUTABLE_SAMPLERS > 14) - { - if (id < 15) - return texelFetch (immutable_textures[14], pos, lod); - else if (GSK_N_IMMUTABLE_SAMPLERS > 15) - return texelFetch (immutable_textures[15], pos, lod); - } - } - } - } - else if (GSK_N_IMMUTABLE_SAMPLERS > 16) - { - if (id < 24) - { - if (id < 20) - { - if (id < 18) - { - if (id < 17) - return texelFetch (immutable_textures[16], pos, lod); - else if (GSK_N_IMMUTABLE_SAMPLERS > 17) - return texelFetch (immutable_textures[17], pos, lod); - } - else if (GSK_N_IMMUTABLE_SAMPLERS > 18) - { - if (id < 19) - return texelFetch (immutable_textures[18], pos, lod); - else if (GSK_N_IMMUTABLE_SAMPLERS > 19) - return texelFetch (immutable_textures[19], pos, lod); - } - } - else if (GSK_N_IMMUTABLE_SAMPLERS > 20) - { - if (id < 22) - { - if (id < 21) - return texelFetch (immutable_textures[20], pos, lod); - else if (GSK_N_IMMUTABLE_SAMPLERS > 21) - return texelFetch (immutable_textures[21], pos, lod); - } - else if (GSK_N_IMMUTABLE_SAMPLERS > 22) - { - if (id < 23) - return texelFetch (immutable_textures[22], pos, lod); - else if (GSK_N_IMMUTABLE_SAMPLERS > 23) - return texelFetch (immutable_textures[23], pos, lod); - } - } - } - else if (GSK_N_IMMUTABLE_SAMPLERS > 24) - { - if (id < 28) - { - if (id < 26) - { - if (id < 25) - return texelFetch (immutable_textures[24], pos, lod); - else if (GSK_N_IMMUTABLE_SAMPLERS > 25) - return texelFetch (immutable_textures[25], pos, lod); - } - else if (GSK_N_IMMUTABLE_SAMPLERS > 26) - { - if (id < 27) - return texelFetch (immutable_textures[26], pos, lod); - else if (GSK_N_IMMUTABLE_SAMPLERS > 27) - return texelFetch (immutable_textures[27], pos, lod); - } - } - else if (GSK_N_IMMUTABLE_SAMPLERS > 28) - { - if (id < 30) - { - if (id < 29) - return texelFetch (immutable_textures[28], pos, lod); - else if (GSK_N_IMMUTABLE_SAMPLERS > 29) - return texelFetch (immutable_textures[29], pos, lod); - } - else if (GSK_N_IMMUTABLE_SAMPLERS > 30) - { - if (id < 31) - return texelFetch (immutable_textures[30], pos, lod); - else if (GSK_N_IMMUTABLE_SAMPLERS > 31) - return texelFetch (immutable_textures[31], pos, lod); - } - } - } - } - } - else - { - id >>= 1; -#ifdef HAVE_VULKAN_1_2 - return texelFetch (textures[nonuniformEXT (id)], pos, lod); -#else - if (id < 16) - { - if (id < 8) - { - if (id < 4) - { - if (id < 2) - { - if (id < 1) - return texelFetch (textures[0], pos, lod); - else if (GSK_N_SAMPLERS > 1) - return texelFetch (textures[1], pos, lod); - } - else if (GSK_N_SAMPLERS > 2) - { - if (id < 3) - return texelFetch (textures[2], pos, lod); - else if (GSK_N_SAMPLERS > 3) - return texelFetch (textures[3], pos, lod); - } - } - else if (GSK_N_SAMPLERS > 4) - { - if (id < 6) - { - if (id < 5) - return texelFetch (textures[4], pos, lod); - else if (GSK_N_SAMPLERS > 5) - return texelFetch (textures[5], pos, lod); - } - else if (GSK_N_SAMPLERS > 6) - { - if (id < 7) - return texelFetch (textures[6], pos, lod); - else if (GSK_N_SAMPLERS > 7) - return texelFetch (textures[7], pos, lod); - } - } - } - else if (GSK_N_SAMPLERS > 8) - { - if (id < 12) - { - if (id < 10) - { - if (id < 9) - return texelFetch (textures[8], pos, lod); - else if (GSK_N_SAMPLERS > 9) - return texelFetch (textures[9], pos, lod); - } - else if (GSK_N_SAMPLERS > 10) - { - if (id < 11) - return texelFetch (textures[10], pos, lod); - else if (GSK_N_SAMPLERS > 11) - return texelFetch (textures[11], pos, lod); - } - } - else if (GSK_N_SAMPLERS > 12) - { - if (id < 14) - { - if (id < 13) - return texelFetch (textures[12], pos, lod); - else if (GSK_N_SAMPLERS > 13) - return texelFetch (textures[13], pos, lod); - } - else if (GSK_N_SAMPLERS > 14) - { - if (id < 15) - return texelFetch (textures[14], pos, lod); - else if (GSK_N_SAMPLERS > 15) - return texelFetch (textures[15], pos, lod); - } - } - } - } - else if (GSK_N_SAMPLERS > 16) - { - if (id < 24) - { - if (id < 20) - { - if (id < 18) - { - if (id < 17) - return texelFetch (textures[16], pos, lod); - else if (GSK_N_SAMPLERS > 17) - return texelFetch (textures[17], pos, lod); - } - else if (GSK_N_SAMPLERS > 18) - { - if (id < 19) - return texelFetch (textures[18], pos, lod); - else if (GSK_N_SAMPLERS > 19) - return texelFetch (textures[19], pos, lod); - } - } - else if (GSK_N_SAMPLERS > 20) - { - if (id < 22) - { - if (id < 21) - return texelFetch (textures[20], pos, lod); - else if (GSK_N_SAMPLERS > 21) - return texelFetch (textures[21], pos, lod); - } - else if (GSK_N_SAMPLERS > 22) - { - if (id < 23) - return texelFetch (textures[22], pos, lod); - else if (GSK_N_SAMPLERS > 23) - return texelFetch (textures[23], pos, lod); - } - } - } - else if (GSK_N_SAMPLERS > 24) - { - if (id < 28) - { - if (id < 26) - { - if (id < 25) - return texelFetch (textures[24], pos, lod); - else if (GSK_N_SAMPLERS > 25) - return texelFetch (textures[25], pos, lod); - } - else if (GSK_N_SAMPLERS > 26) - { - if (id < 27) - return texelFetch (textures[26], pos, lod); - else if (GSK_N_SAMPLERS > 27) - return texelFetch (textures[27], pos, lod); - } - } - else if (GSK_N_SAMPLERS > 28) - { - if (id < 30) - { - if (id < 29) - return texelFetch (textures[28], pos, lod); - else if (GSK_N_SAMPLERS > 29) - return texelFetch (textures[29], pos, lod); - } - else if (GSK_N_SAMPLERS > 30) - { - if (id < 31) - return texelFetch (textures[30], pos, lod); - else if (GSK_N_SAMPLERS > 31) - return texelFetch (textures[31], pos, lod); - } - } - } - } -#endif - } - return vec4 (1.0, 0.0, 0.8, 1.0); -} +#define GSK_TEXTURE0 textures[0] +#define GSK_TEXTURE1 textures[1] void gsk_set_output_color (vec4 color) diff --git a/gsk/gpu/shaders/common.glsl b/gsk/gpu/shaders/common.glsl index 4b79f35aa8..86e60c5679 100644 --- a/gsk/gpu/shaders/common.glsl +++ b/gsk/gpu/shaders/common.glsl @@ -127,23 +127,23 @@ main (void) #ifdef GSK_FRAGMENT_SHADER vec4 -gsk_texture_straight_alpha (uint tex_id, - vec2 pos) +gsk_texture_straight_alpha (sampler2D tex, + vec2 pos) { - vec2 size = vec2 (gsk_texture_size (tex_id, 0)); + vec2 size = vec2 (textureSize (tex, 0)); pos *= size; size -= vec2 (1.0); /* GL_CLAMP_TO_EDGE */ pos = clamp (pos - 0.5, vec2 (0.0), size); ivec2 ipos = ivec2 (pos); pos = fract (pos); - vec4 tl = gsk_texel_fetch (tex_id, ipos, 0); + vec4 tl = texelFetch (tex, ipos, 0); tl.rgb *= tl.a; - vec4 tr = gsk_texel_fetch (tex_id, ipos + ivec2(1, 0), 0); + vec4 tr = texelFetch (tex, ipos + ivec2(1, 0), 0); tr.rgb *= tr.a; - vec4 bl = gsk_texel_fetch (tex_id, ipos + ivec2(0, 1), 0); + vec4 bl = texelFetch (tex, ipos + ivec2(0, 1), 0); bl.rgb *= bl.a; - vec4 br = gsk_texel_fetch (tex_id, ipos + ivec2(1, 1), 0); + vec4 br = texelFetch (tex, ipos + ivec2(1, 1), 0); br.rgb *= br.a; return mix (mix (tl, tr, pos.x), mix (bl, br, pos.x), pos.y); } diff --git a/gsk/gpu/shaders/gskgpublendmode.glsl b/gsk/gpu/shaders/gskgpublendmode.glsl index 46f6ae706f..e37920bb4c 100644 --- a/gsk/gpu/shaders/gskgpublendmode.glsl +++ b/gsk/gpu/shaders/gskgpublendmode.glsl @@ -8,19 +8,15 @@ PASS_FLAT(1) Rect _bottom_rect; PASS_FLAT(2) Rect _top_rect; PASS(3) vec2 _bottom_coord; PASS(4) vec2 _top_coord; -PASS_FLAT(5) uint _bottom_id; -PASS_FLAT(6) uint _top_id; -PASS_FLAT(7) float _opacity; +PASS_FLAT(5) float _opacity; #ifdef GSK_VERTEX_SHADER IN(0) vec4 in_rect; IN(1) vec4 in_bottom_rect; -IN(2) uint in_bottom_id; -IN(3) vec4 in_top_rect; -IN(4) uint in_top_id; -IN(5) float in_opacity; +IN(2) vec4 in_top_rect; +IN(3) float in_opacity; void run (out vec2 pos) @@ -35,12 +31,10 @@ run (out vec2 pos) Rect bottom_rect = rect_from_gsk (in_bottom_rect); _bottom_rect = bottom_rect; _bottom_coord = rect_get_coord (bottom_rect, pos); - _bottom_id = in_bottom_id; Rect top_rect = rect_from_gsk (in_top_rect); _top_rect = top_rect; _top_coord = rect_get_coord (top_rect, pos); - _top_id = in_top_id; } #endif @@ -53,10 +47,10 @@ void run (out vec4 color, out vec2 position) { - vec4 bottom_color = gsk_texture (_bottom_id, _bottom_coord); + vec4 bottom_color = texture (GSK_TEXTURE0, _bottom_coord); bottom_color = output_color_alpha (bottom_color, rect_coverage (_bottom_rect, _pos)); - vec4 top_color = gsk_texture (_top_id, _top_coord); + vec4 top_color = texture (GSK_TEXTURE1, _top_coord); top_color = output_color_alpha (top_color, rect_coverage (_top_rect, _pos)); color = blend_mode (bottom_color, top_color, GSK_VARIATION); diff --git a/gsk/gpu/shaders/gskgpublur.glsl b/gsk/gpu/shaders/gskgpublur.glsl index 71a5bee40e..42eb39cc2f 100644 --- a/gsk/gpu/shaders/gskgpublur.glsl +++ b/gsk/gpu/shaders/gskgpublur.glsl @@ -12,7 +12,6 @@ PASS_FLAT(2) vec4 _blur_color; PASS(3) vec2 _tex_coord; PASS_FLAT(4) vec2 _tex_blur_step; PASS_FLAT(5) uint _samples_per_side; -PASS_FLAT(6) uint _tex_id; PASS_FLAT(7) vec3 _initial_gaussian; @@ -22,7 +21,6 @@ IN(0) vec4 in_rect; IN(1) vec4 in_blur_color; IN(2) vec4 in_tex_rect; IN(3) vec2 in_blur_direction; -IN(4) uint in_tex_id; void run (out vec2 pos) @@ -36,7 +34,6 @@ run (out vec2 pos) _blur_color = output_color_from_alt (in_blur_color); Rect tex_rect = rect_from_gsk (in_tex_rect); _tex_coord = rect_get_coord (tex_rect, pos); - _tex_id = in_tex_id; float blur_radius = length (GSK_GLOBAL_SCALE * in_blur_direction); _tex_blur_step = GSK_GLOBAL_SCALE * in_blur_direction / blur_radius / rect_size (tex_rect); @@ -58,15 +55,15 @@ run (out vec4 color, out vec2 position) { vec3 incremental_gaussian = _initial_gaussian; - vec4 sum = gsk_texture (_tex_id, _tex_coord) * incremental_gaussian.x; + vec4 sum = texture (GSK_TEXTURE0, _tex_coord) * incremental_gaussian.x; float coefficient_sum = incremental_gaussian.x; incremental_gaussian.xy *= incremental_gaussian.yz; vec2 p = _tex_blur_step; for (uint i = 0u; i < _samples_per_side; i++) { - sum += gsk_texture (_tex_id, _tex_coord - p) * incremental_gaussian.x; - sum += gsk_texture (_tex_id, _tex_coord + p) * incremental_gaussian.x; + sum += texture (GSK_TEXTURE0, _tex_coord - p) * incremental_gaussian.x; + sum += texture (GSK_TEXTURE0, _tex_coord + p) * incremental_gaussian.x; coefficient_sum += 2.0 * incremental_gaussian.x; incremental_gaussian.xy *= incremental_gaussian.yz; diff --git a/gsk/gpu/shaders/gskgpucolorize.glsl b/gsk/gpu/shaders/gskgpucolorize.glsl index 6051d9645d..6ef50b2cbe 100644 --- a/gsk/gpu/shaders/gskgpucolorize.glsl +++ b/gsk/gpu/shaders/gskgpucolorize.glsl @@ -6,8 +6,6 @@ PASS(0) vec2 _pos; PASS_FLAT(1) Rect _rect; PASS_FLAT(2) vec4 _color; PASS(3) vec2 _tex_coord; -PASS_FLAT(4) uint _tex_id; - #ifdef GSK_VERTEX_SHADER @@ -15,7 +13,6 @@ PASS_FLAT(4) uint _tex_id; IN(0) vec4 in_rect; IN(1) vec4 in_color; IN(2) vec4 in_tex_rect; -IN(3) uint in_tex_id; void run (out vec2 pos) @@ -28,7 +25,6 @@ run (out vec2 pos) _rect = r; _color = output_color_from_alt (in_color); _tex_coord = rect_get_coord (rect_from_gsk (in_tex_rect), pos); - _tex_id = in_tex_id; } #endif @@ -41,7 +37,7 @@ void run (out vec4 color, out vec2 position) { - float alpha = gsk_texture (_tex_id, _tex_coord).a * rect_coverage (_rect, _pos); + float alpha = texture (GSK_TEXTURE0, _tex_coord).a * rect_coverage (_rect, _pos); color = output_color_alpha (_color, alpha); position = _pos; } diff --git a/gsk/gpu/shaders/gskgpucolormatrix.glsl b/gsk/gpu/shaders/gskgpucolormatrix.glsl index ba3d0d8cc0..203b483663 100644 --- a/gsk/gpu/shaders/gskgpucolormatrix.glsl +++ b/gsk/gpu/shaders/gskgpucolormatrix.glsl @@ -7,7 +7,6 @@ PASS_FLAT(4) vec4 _color_offset; PASS(5) vec2 _pos; PASS_FLAT(6) Rect _rect; PASS(7) vec2 _tex_coord; -PASS_FLAT(8) uint _tex_id; #ifdef GSK_VERTEX_SHADER @@ -16,7 +15,6 @@ IN(0) mat4 in_color_matrix; IN(4) vec4 in_color_offset; IN(5) vec4 in_rect; IN(6) vec4 in_tex_rect; -IN(7) uint in_tex_id; void run (out vec2 pos) @@ -28,7 +26,6 @@ run (out vec2 pos) _pos = pos; _rect = r; _tex_coord = rect_get_coord (rect_from_gsk (in_tex_rect), pos); - _tex_id = in_tex_id; _color_matrix = in_color_matrix; _color_offset = in_color_offset; } @@ -43,7 +40,7 @@ void run (out vec4 color, out vec2 position) { - vec4 pixel = gsk_texture (_tex_id, _tex_coord); + vec4 pixel = texture (GSK_TEXTURE0, _tex_coord); pixel = alt_color_from_output (pixel); pixel = _color_matrix * pixel + _color_offset; diff --git a/gsk/gpu/shaders/gskgpuconvert.glsl b/gsk/gpu/shaders/gskgpuconvert.glsl index 2d85820a9d..f44c197877 100644 --- a/gsk/gpu/shaders/gskgpuconvert.glsl +++ b/gsk/gpu/shaders/gskgpuconvert.glsl @@ -10,15 +10,13 @@ PASS(0) vec2 _pos; PASS_FLAT(1) Rect _rect; PASS(2) vec2 _tex_coord; -PASS_FLAT(3) uint _tex_id; -PASS_FLAT(4) float _opacity; +PASS_FLAT(3) float _opacity; #ifdef GSK_VERTEX_SHADER IN(0) vec4 in_rect; IN(1) vec4 in_tex_rect; -IN(2) uint in_tex_id; -IN(3) float in_opacity; +IN(2) float in_opacity; void run (out vec2 pos) @@ -30,7 +28,6 @@ run (out vec2 pos) _pos = pos; _rect = r; _tex_coord = rect_get_coord (rect_from_gsk (in_tex_rect), pos); - _tex_id = in_tex_id; _opacity = in_opacity; } @@ -46,9 +43,9 @@ run (out vec4 color, { vec4 pixel; if (HAS_VARIATION (VARIATION_STRAIGHT_ALPHA)) - pixel = gsk_texture_straight_alpha (_tex_id, _tex_coord); + pixel = gsk_texture_straight_alpha (GSK_TEXTURE0, _tex_coord); else - pixel = gsk_texture (_tex_id, _tex_coord); + pixel = texture (GSK_TEXTURE0, _tex_coord); pixel = output_color_from_alt (pixel); diff --git a/gsk/gpu/shaders/gskgpucrossfade.glsl b/gsk/gpu/shaders/gskgpucrossfade.glsl index 7d6051aec6..3713647bda 100644 --- a/gsk/gpu/shaders/gskgpucrossfade.glsl +++ b/gsk/gpu/shaders/gskgpucrossfade.glsl @@ -7,20 +7,16 @@ PASS_FLAT(1) Rect _start_rect; PASS_FLAT(2) Rect _end_rect; PASS(3) vec2 _start_coord; PASS(4) vec2 _end_coord; -PASS_FLAT(5) uint _start_id; -PASS_FLAT(6) uint _end_id; -PASS_FLAT(7) float _start_opacity; -PASS_FLAT(8) float _end_opacity; +PASS_FLAT(5) float _start_opacity; +PASS_FLAT(6) float _end_opacity; #ifdef GSK_VERTEX_SHADER IN(0) vec4 in_rect; IN(1) vec4 in_start_rect; -IN(2) uint in_start_id; -IN(3) vec4 in_end_rect; -IN(4) uint in_end_id; -IN(5) vec2 in_opacity_progress; +IN(2) vec4 in_end_rect; +IN(3) vec2 in_opacity_progress; void run (out vec2 pos) @@ -34,13 +30,11 @@ run (out vec2 pos) Rect start_rect = rect_from_gsk (in_start_rect); _start_rect = start_rect; _start_coord = rect_get_coord (start_rect, pos); - _start_id = in_start_id; _start_opacity = in_opacity_progress[0] * (1.0 - in_opacity_progress[1]); Rect end_rect = rect_from_gsk (in_end_rect); _end_rect = end_rect; _end_coord = rect_get_coord (end_rect, pos); - _end_id = in_end_id; _end_opacity = in_opacity_progress[0] * in_opacity_progress[1]; } @@ -54,10 +48,10 @@ void run (out vec4 color, out vec2 position) { - vec4 start = output_color_alpha (gsk_texture (_start_id, _start_coord), + vec4 start = output_color_alpha (texture (GSK_TEXTURE0, _start_coord), rect_coverage (_start_rect, _pos) * _start_opacity); - vec4 end = output_color_alpha (gsk_texture (_end_id, _end_coord), + vec4 end = output_color_alpha (texture (GSK_TEXTURE1, _end_coord), rect_coverage (_end_rect, _pos) * _end_opacity); diff --git a/gsk/gpu/shaders/gskgpumask.glsl b/gsk/gpu/shaders/gskgpumask.glsl index 27ac1bd431..159724ad10 100644 --- a/gsk/gpu/shaders/gskgpumask.glsl +++ b/gsk/gpu/shaders/gskgpumask.glsl @@ -9,8 +9,6 @@ PASS_FLAT(1) Rect _source_rect; PASS_FLAT(2) Rect _mask_rect; PASS(3) vec2 _source_coord; PASS(4) vec2 _mask_coord; -PASS_FLAT(5) uint _source_id; -PASS_FLAT(6) uint _mask_id; PASS_FLAT(7) float _opacity; @@ -18,10 +16,8 @@ PASS_FLAT(7) float _opacity; IN(0) vec4 in_rect; IN(1) vec4 in_source_rect; -IN(2) uint in_source_id; -IN(3) vec4 in_mask_rect; -IN(4) uint in_mask_id; -IN(5) float in_opacity; +IN(2) vec4 in_mask_rect; +IN(3) float in_opacity; void run (out vec2 pos) @@ -34,11 +30,9 @@ run (out vec2 pos) Rect source_rect = rect_from_gsk (in_source_rect); _source_rect = source_rect; _source_coord = rect_get_coord (source_rect, pos); - _source_id = in_source_id; Rect mask_rect = rect_from_gsk (in_mask_rect); _mask_rect = mask_rect; _mask_coord = rect_get_coord (mask_rect, pos); - _mask_id = in_mask_id; _opacity = in_opacity; } @@ -52,9 +46,9 @@ void run (out vec4 color, out vec2 position) { - vec4 source = gsk_texture (_source_id, _source_coord); + vec4 source = texture (GSK_TEXTURE0, _source_coord); source = output_color_alpha (source, rect_coverage (_source_rect, _pos)); - vec4 mask = gsk_texture (_mask_id, _mask_coord); + vec4 mask = texture (GSK_TEXTURE1, _mask_coord); mask = output_color_alpha (mask, rect_coverage (_mask_rect, _pos)); float alpha = _opacity; diff --git a/gsk/gpu/shaders/gskgputexture.glsl b/gsk/gpu/shaders/gskgputexture.glsl index 4fc29a0045..ac74aa7628 100644 --- a/gsk/gpu/shaders/gskgputexture.glsl +++ b/gsk/gpu/shaders/gskgputexture.glsl @@ -5,7 +5,6 @@ PASS(0) vec2 _pos; PASS_FLAT(1) Rect _rect; PASS(2) vec2 _tex_coord; -PASS_FLAT(3) uint _tex_id; @@ -13,7 +12,6 @@ PASS_FLAT(3) uint _tex_id; IN(0) vec4 in_rect; IN(1) vec4 in_tex_rect; -IN(2) uint in_tex_id; void run (out vec2 pos) @@ -25,7 +23,6 @@ run (out vec2 pos) _pos = pos; _rect = r; _tex_coord = rect_get_coord (rect_from_gsk (in_tex_rect), pos); - _tex_id = in_tex_id; } #endif @@ -38,7 +35,7 @@ void run (out vec4 color, out vec2 position) { - color = gsk_texture (_tex_id, _tex_coord) * + color = texture (GSK_TEXTURE0, _tex_coord) * rect_coverage (_rect, _pos); position = _pos; } From 1b2156493b1ba4100dbbadb593d6a5edb77016c8 Mon Sep 17 00:00:00 2001 From: Benjamin Otte Date: Sat, 20 Jul 2024 11:01:07 +0200 Subject: [PATCH 17/28] gpu: Remove descriptors They are no longer a thing with the new way we manage textures. --- gsk/gpu/gskgldescriptors.c | 117 -------- gsk/gpu/gskgldescriptorsprivate.h | 19 -- gsk/gpu/gskgldevice.c | 21 +- gsk/gpu/gskgldeviceprivate.h | 3 +- gsk/gpu/gskglframe.c | 14 +- gsk/gpu/gskglframeprivate.h | 3 +- gsk/gpu/gskgpublendmodeop.c | 2 - gsk/gpu/gskgpublendmodeopprivate.h | 1 - gsk/gpu/gskgpublurop.c | 6 - gsk/gpu/gskgpubluropprivate.h | 2 - gsk/gpu/gskgpuborderop.c | 1 - gsk/gpu/gskgpuboxshadowop.c | 1 - gsk/gpu/gskgpucolorizeop.c | 2 - gsk/gpu/gskgpucolorizeopprivate.h | 1 - gsk/gpu/gskgpucolormatrixop.c | 2 - gsk/gpu/gskgpucolormatrixopprivate.h | 1 - gsk/gpu/gskgpucolorop.c | 1 - gsk/gpu/gskgpuconicgradientop.c | 1 - gsk/gpu/gskgpuconvertop.c | 2 - gsk/gpu/gskgpuconvertopprivate.h | 1 - gsk/gpu/gskgpucrossfadeop.c | 2 - gsk/gpu/gskgpucrossfadeopprivate.h | 1 - gsk/gpu/gskgpudescriptors.c | 159 ----------- gsk/gpu/gskgpudescriptorsprivate.h | 51 ---- gsk/gpu/gskgpuframe.c | 6 - gsk/gpu/gskgpuframeprivate.h | 2 - gsk/gpu/gskgpuglobalsop.c | 5 +- gsk/gpu/gskgpulineargradientop.c | 1 - gsk/gpu/gskgpumaskop.c | 2 - gsk/gpu/gskgpumaskopprivate.h | 1 - gsk/gpu/gskgpumipmapop.c | 2 +- gsk/gpu/gskgpunodeprocessor.c | 179 +------------ gsk/gpu/gskgpuopprivate.h | 3 - gsk/gpu/gskgpuprint.c | 10 - gsk/gpu/gskgpuprintprivate.h | 3 - gsk/gpu/gskgpuradialgradientop.c | 1 - gsk/gpu/gskgpurenderpassop.c | 3 +- gsk/gpu/gskgpuroundedcolorop.c | 1 - gsk/gpu/gskgpushaderop.c | 29 +- gsk/gpu/gskgpushaderopprivate.h | 3 - gsk/gpu/gskgputextureop.c | 2 - gsk/gpu/gskgputextureopprivate.h | 1 - gsk/gpu/gskgputypesprivate.h | 3 - gsk/gpu/gskvulkandescriptors.c | 51 ---- gsk/gpu/gskvulkandescriptorsprivate.h | 47 ---- gsk/gpu/gskvulkanframe.c | 64 +---- gsk/gpu/gskvulkanrealdescriptors.c | 308 ---------------------- gsk/gpu/gskvulkanrealdescriptorsprivate.h | 22 -- gsk/gpu/gskvulkansubdescriptors.c | 93 ------- gsk/gpu/gskvulkansubdescriptorsprivate.h | 14 - gsk/meson.build | 5 - 51 files changed, 25 insertions(+), 1250 deletions(-) delete mode 100644 gsk/gpu/gskgldescriptors.c delete mode 100644 gsk/gpu/gskgldescriptorsprivate.h delete mode 100644 gsk/gpu/gskgpudescriptors.c delete mode 100644 gsk/gpu/gskgpudescriptorsprivate.h delete mode 100644 gsk/gpu/gskvulkandescriptors.c delete mode 100644 gsk/gpu/gskvulkandescriptorsprivate.h delete mode 100644 gsk/gpu/gskvulkanrealdescriptors.c delete mode 100644 gsk/gpu/gskvulkanrealdescriptorsprivate.h delete mode 100644 gsk/gpu/gskvulkansubdescriptors.c delete mode 100644 gsk/gpu/gskvulkansubdescriptorsprivate.h diff --git a/gsk/gpu/gskgldescriptors.c b/gsk/gpu/gskgldescriptors.c deleted file mode 100644 index 2a6b5b16d3..0000000000 --- a/gsk/gpu/gskgldescriptors.c +++ /dev/null @@ -1,117 +0,0 @@ -#include "config.h" - -#include "gskgldescriptorsprivate.h" - -#include "gskglimageprivate.h" - -struct _GskGLDescriptors -{ - GskGpuDescriptors parent_instance; - - GskGLDevice *device; - guint n_external; -}; - -G_DEFINE_TYPE (GskGLDescriptors, gsk_gl_descriptors, GSK_TYPE_GPU_DESCRIPTORS) - -static void -gsk_gl_descriptors_finalize (GObject *object) -{ - GskGLDescriptors *self = GSK_GL_DESCRIPTORS (object); - - g_object_unref (self->device); - - G_OBJECT_CLASS (gsk_gl_descriptors_parent_class)->finalize (object); -} - -static gboolean -gsk_gl_descriptors_add_image (GskGpuDescriptors *desc, - GskGpuImage *image, - GskGpuSampler sampler, - guint32 *out_descriptor) -{ - GskGLDescriptors *self = GSK_GL_DESCRIPTORS (desc); - gsize used_texture_units; - - used_texture_units = gsk_gpu_descriptors_get_n_images (desc) + 2 * self->n_external; - - if (gsk_gpu_image_get_flags (image) & GSK_GPU_IMAGE_EXTERNAL) - { - if (16 - used_texture_units < 3) - return FALSE; - - *out_descriptor = (self->n_external << 1) | 1; - self->n_external++; - return TRUE; - } - else - { - if (used_texture_units >= 16) - return FALSE; - - *out_descriptor = (gsk_gpu_descriptors_get_n_images (desc) - self->n_external) << 1; - return TRUE; - } -} - -static void -gsk_gl_descriptors_class_init (GskGLDescriptorsClass *klass) -{ - GskGpuDescriptorsClass *descriptors_class = GSK_GPU_DESCRIPTORS_CLASS (klass); - GObjectClass *object_class = G_OBJECT_CLASS (klass); - - object_class->finalize = gsk_gl_descriptors_finalize; - - descriptors_class->add_image = gsk_gl_descriptors_add_image; -} - -static void -gsk_gl_descriptors_init (GskGLDescriptors *self) -{ -} - -GskGpuDescriptors * -gsk_gl_descriptors_new (GskGLDevice *device) -{ - GskGLDescriptors *self; - - self = g_object_new (GSK_TYPE_GL_DESCRIPTORS, NULL); - - self->device = g_object_ref (device); - - return GSK_GPU_DESCRIPTORS (self); -} - -guint -gsk_gl_descriptors_get_n_external (GskGLDescriptors *self) -{ - return self->n_external; -} - -void -gsk_gl_descriptors_use (GskGLDescriptors *self) -{ - GskGpuDescriptors *desc = GSK_GPU_DESCRIPTORS (self); - gsize i, ext, n_textures; - - n_textures = 16 - 3 * self->n_external; - ext = 0; - - for (i = 0; i < gsk_gpu_descriptors_get_n_images (desc); i++) - { - GskGLImage *image = GSK_GL_IMAGE (gsk_gpu_descriptors_get_image (desc, i)); - - if (gsk_gpu_image_get_flags (GSK_GPU_IMAGE (image)) & GSK_GPU_IMAGE_EXTERNAL) - { - glActiveTexture (GL_TEXTURE0 + n_textures + 3 * ext); - gsk_gl_image_bind_texture (image); - ext++; - } - else - { - glActiveTexture (GL_TEXTURE0 + i - ext); - gsk_gl_image_bind_texture (image); - glBindSampler (i - ext, gsk_gl_device_get_sampler_id (self->device, gsk_gpu_descriptors_get_sampler (desc, i))); - } - } -} diff --git a/gsk/gpu/gskgldescriptorsprivate.h b/gsk/gpu/gskgldescriptorsprivate.h deleted file mode 100644 index 1e618efccf..0000000000 --- a/gsk/gpu/gskgldescriptorsprivate.h +++ /dev/null @@ -1,19 +0,0 @@ -#pragma once - -#include "gskgpudescriptorsprivate.h" - -#include "gskgldeviceprivate.h" - -G_BEGIN_DECLS - -#define GSK_TYPE_GL_DESCRIPTORS (gsk_gl_descriptors_get_type ()) - -G_DECLARE_FINAL_TYPE (GskGLDescriptors, gsk_gl_descriptors, GSK, GL_DESCRIPTORS, GskGpuDescriptors) - -GskGpuDescriptors * gsk_gl_descriptors_new (GskGLDevice *device); - -guint gsk_gl_descriptors_get_n_external (GskGLDescriptors *self); -void gsk_gl_descriptors_use (GskGLDescriptors *self); - -G_END_DECLS - diff --git a/gsk/gpu/gskgldevice.c b/gsk/gpu/gskgldevice.c index 5eff73f707..de773ac135 100644 --- a/gsk/gpu/gskgldevice.c +++ b/gsk/gpu/gskgldevice.c @@ -38,7 +38,6 @@ struct _GLProgramKey GskGpuShaderFlags flags; GskGpuColorStates color_states; guint32 variation; - guint n_external_textures; }; G_DEFINE_TYPE (GskGLDevice, gsk_gl_device, GSK_TYPE_GPU_DEVICE) @@ -64,8 +63,7 @@ gl_program_key_equal (gconstpointer a, return keya->op_class == keyb->op_class && keya->flags == keyb->flags && keya->color_states == keyb->color_states && - keya->variation == keyb->variation && - keya->n_external_textures == keyb->n_external_textures; + keya->variation == keyb->variation; } static GskGpuImage * @@ -383,7 +381,6 @@ gsk_gl_device_load_shader (GskGLDevice *self, GskGpuShaderFlags flags, GskGpuColorStates color_states, guint32 variation, - guint n_external_textures, GError **error) { GString *preamble; @@ -391,7 +388,6 @@ gsk_gl_device_load_shader (GskGLDevice *self, GBytes *bytes; GLuint shader_id; - g_assert ((n_external_textures > 0) == gsk_gpu_shader_flags_has_external_textures (flags)); preamble = g_string_new (NULL); g_string_append (preamble, self->version_string); @@ -404,16 +400,12 @@ gsk_gl_device_load_shader (GskGLDevice *self, g_string_append (preamble, "#extension GL_OES_EGL_image_external : require\n"); } g_string_append (preamble, "#define GSK_GLES 1\n"); - g_assert (3 * n_external_textures <= 16); } else { g_assert (!gsk_gpu_shader_flags_has_external_textures (flags)); } - g_string_append_printf (preamble, "#define N_TEXTURES %u\n", 16 - 3 * n_external_textures); - g_string_append_printf (preamble, "#define N_EXTERNAL_TEXTURES %u\n", n_external_textures); - switch (shader_type) { case GL_VERTEX_SHADER: @@ -471,18 +463,17 @@ gsk_gl_device_load_program (GskGLDevice *self, GskGpuShaderFlags flags, GskGpuColorStates color_states, guint32 variation, - guint n_external_textures, GError **error) { G_GNUC_UNUSED gint64 begin_time = GDK_PROFILER_CURRENT_TIME; GLuint vertex_shader_id, fragment_shader_id, program_id; GLint link_status; - vertex_shader_id = gsk_gl_device_load_shader (self, op_class->shader_name, GL_VERTEX_SHADER, flags, color_states, variation, n_external_textures, error); + vertex_shader_id = gsk_gl_device_load_shader (self, op_class->shader_name, GL_VERTEX_SHADER, flags, color_states, variation, error); if (vertex_shader_id == 0) return 0; - fragment_shader_id = gsk_gl_device_load_shader (self, op_class->shader_name, GL_FRAGMENT_SHADER, flags, color_states, variation, n_external_textures, error); + fragment_shader_id = gsk_gl_device_load_shader (self, op_class->shader_name, GL_FRAGMENT_SHADER, flags, color_states, variation, error); if (fragment_shader_id == 0) return 0; @@ -542,8 +533,7 @@ gsk_gl_device_use_program (GskGLDevice *self, const GskGpuShaderOpClass *op_class, GskGpuShaderFlags flags, GskGpuColorStates color_states, - guint32 variation, - guint n_external_textures) + guint32 variation) { GError *error = NULL; GLuint program_id; @@ -552,7 +542,6 @@ gsk_gl_device_use_program (GskGLDevice *self, .flags = flags, .color_states = color_states, .variation = variation, - .n_external_textures = n_external_textures }; program_id = GPOINTER_TO_UINT (g_hash_table_lookup (self->gl_programs, &key)); @@ -562,7 +551,7 @@ gsk_gl_device_use_program (GskGLDevice *self, return; } - program_id = gsk_gl_device_load_program (self, op_class, flags, color_states, variation, n_external_textures, &error); + program_id = gsk_gl_device_load_program (self, op_class, flags, color_states, variation, &error); if (program_id == 0) { g_critical ("Failed to load shader program: %s", error->message); diff --git a/gsk/gpu/gskgldeviceprivate.h b/gsk/gpu/gskgldeviceprivate.h index e5d474ee33..03c2b9bb6a 100644 --- a/gsk/gpu/gskgldeviceprivate.h +++ b/gsk/gpu/gskgldeviceprivate.h @@ -15,8 +15,7 @@ void gsk_gl_device_use_program (GskGLDe const GskGpuShaderOpClass *op_class, GskGpuShaderFlags flags, GskGpuColorStates color_states, - guint32 variation, - guint n_external_textures); + guint32 variation); GLuint gsk_gl_device_get_sampler_id (GskGLDevice *self, GskGpuSampler sampler); diff --git a/gsk/gpu/gskglframe.c b/gsk/gpu/gskglframe.c index bcff6fdcf4..4fcd13dc08 100644 --- a/gsk/gpu/gskglframe.c +++ b/gsk/gpu/gskglframe.c @@ -6,7 +6,6 @@ #include "gskgpuopprivate.h" #include "gskgpushaderopprivate.h" #include "gskglbufferprivate.h" -#include "gskgldescriptorsprivate.h" #include "gskgldeviceprivate.h" #include "gskglimageprivate.h" @@ -125,12 +124,6 @@ gsk_gl_frame_upload_texture (GskGpuFrame *frame, return GSK_GPU_FRAME_CLASS (gsk_gl_frame_parent_class)->upload_texture (frame, with_mipmap, texture); } -static GskGpuDescriptors * -gsk_gl_frame_create_descriptors (GskGpuFrame *frame) -{ - return GSK_GPU_DESCRIPTORS (gsk_gl_descriptors_new (GSK_GL_DEVICE (gsk_gpu_frame_get_device (frame)))); -} - static GskGpuBuffer * gsk_gl_frame_create_vertex_buffer (GskGpuFrame *frame, gsize size) @@ -227,7 +220,6 @@ gsk_gl_frame_class_init (GskGLFrameClass *klass) gpu_frame_class->wait = gsk_gl_frame_wait; gpu_frame_class->cleanup = gsk_gl_frame_cleanup; gpu_frame_class->upload_texture = gsk_gl_frame_upload_texture; - gpu_frame_class->create_descriptors = gsk_gl_frame_create_descriptors; gpu_frame_class->create_vertex_buffer = gsk_gl_frame_create_vertex_buffer; gpu_frame_class->create_storage_buffer = gsk_gl_frame_create_storage_buffer; gpu_frame_class->write_texture_vertex_data = gsk_gl_frame_write_texture_vertex_data; @@ -253,8 +245,7 @@ gsk_gl_frame_use_program (GskGLFrame *self, const GskGpuShaderOpClass *op_class, GskGpuShaderFlags flags, GskGpuColorStates color_states, - guint32 variation, - guint n_external_textures) + guint32 variation) { GLuint vao; @@ -262,8 +253,7 @@ gsk_gl_frame_use_program (GskGLFrame *self, op_class, flags, color_states, - variation, - n_external_textures); + variation); vao = GPOINTER_TO_UINT (g_hash_table_lookup (self->vaos, op_class)); if (vao) diff --git a/gsk/gpu/gskglframeprivate.h b/gsk/gpu/gskglframeprivate.h index 4462917994..1cbe7fb50b 100644 --- a/gsk/gpu/gskglframeprivate.h +++ b/gsk/gpu/gskglframeprivate.h @@ -12,8 +12,7 @@ void gsk_gl_frame_use_program (GskGLFr const GskGpuShaderOpClass *op_class, GskGpuShaderFlags flags, GskGpuColorStates color_states, - guint32 variation, - guint n_external_textures); + guint32 variation); void gsk_gl_frame_bind_globals (GskGLFrame *self); diff --git a/gsk/gpu/gskgpublendmodeop.c b/gsk/gpu/gskgpublendmodeop.c index bf0d9940e3..a8f8d149b6 100644 --- a/gsk/gpu/gskgpublendmodeop.c +++ b/gsk/gpu/gskgpublendmodeop.c @@ -55,7 +55,6 @@ static const GskGpuShaderOpClass GSK_GPU_BLEND_MODE_OP_CLASS = { void gsk_gpu_blend_mode_op (GskGpuFrame *frame, GskGpuShaderClip clip, - GskGpuDescriptors *desc, const graphene_rect_t *rect, const graphene_point_t *offset, float opacity, @@ -70,7 +69,6 @@ gsk_gpu_blend_mode_op (GskGpuFrame *frame, gsk_gpu_color_states_create_equal (TRUE, TRUE), blend_mode, clip, - desc, (GskGpuImage *[2]) { bottom->image, top->image }, (GskGpuSampler[2]) { bottom->sampler, top->sampler }, &instance); diff --git a/gsk/gpu/gskgpublendmodeopprivate.h b/gsk/gpu/gskgpublendmodeopprivate.h index 1087211871..f0d10d28ad 100644 --- a/gsk/gpu/gskgpublendmodeopprivate.h +++ b/gsk/gpu/gskgpublendmodeopprivate.h @@ -8,7 +8,6 @@ G_BEGIN_DECLS void gsk_gpu_blend_mode_op (GskGpuFrame *frame, GskGpuShaderClip clip, - GskGpuDescriptors *desc, const graphene_rect_t *rect, const graphene_point_t *offset, float opacity, diff --git a/gsk/gpu/gskgpublurop.c b/gsk/gpu/gskgpublurop.c index 24f59e90c3..9a6e1cf0de 100644 --- a/gsk/gpu/gskgpublurop.c +++ b/gsk/gpu/gskgpublurop.c @@ -58,7 +58,6 @@ gsk_gpu_blur_op_full (GskGpuFrame *frame, GskGpuShaderClip clip, GskGpuColorStates color_states, guint32 variation, - GskGpuDescriptors *desc, const graphene_point_t *offset, const GskGpuShaderImage *image, const graphene_vec2_t *blur_direction, @@ -71,7 +70,6 @@ gsk_gpu_blur_op_full (GskGpuFrame *frame, color_states, variation, clip, - desc, (GskGpuImage *[1]) { image->image }, (GskGpuSampler[1]) { image->sampler }, &instance); @@ -86,7 +84,6 @@ void gsk_gpu_blur_op (GskGpuFrame *frame, GskGpuShaderClip clip, GskGpuColorStates color_states, - GskGpuDescriptors *desc, const graphene_point_t *offset, const GskGpuShaderImage *image, const graphene_vec2_t *blur_direction) @@ -95,7 +92,6 @@ gsk_gpu_blur_op (GskGpuFrame *frame, clip, color_states, 0, - desc, offset, image, blur_direction, @@ -106,7 +102,6 @@ void gsk_gpu_blur_shadow_op (GskGpuFrame *frame, GskGpuShaderClip clip, GskGpuColorStates color_states, - GskGpuDescriptors *desc, const graphene_point_t *offset, const GskGpuShaderImage *image, const graphene_vec2_t *blur_direction, @@ -116,7 +111,6 @@ gsk_gpu_blur_shadow_op (GskGpuFrame *frame, clip, color_states, VARIATION_COLORIZE, - desc, offset, image, blur_direction, diff --git a/gsk/gpu/gskgpubluropprivate.h b/gsk/gpu/gskgpubluropprivate.h index 85f2fab41c..7cec908151 100644 --- a/gsk/gpu/gskgpubluropprivate.h +++ b/gsk/gpu/gskgpubluropprivate.h @@ -9,7 +9,6 @@ G_BEGIN_DECLS void gsk_gpu_blur_op (GskGpuFrame *frame, GskGpuShaderClip clip, GskGpuColorStates color_states, - GskGpuDescriptors *desc, const graphene_point_t *offset, const GskGpuShaderImage *image, const graphene_vec2_t *blur_direction); @@ -17,7 +16,6 @@ void gsk_gpu_blur_op (GskGpuF void gsk_gpu_blur_shadow_op (GskGpuFrame *frame, GskGpuShaderClip clip, GskGpuColorStates color_states, - GskGpuDescriptors *desc, const graphene_point_t *offset, const GskGpuShaderImage *image, const graphene_vec2_t *blur_direction, diff --git a/gsk/gpu/gskgpuborderop.c b/gsk/gpu/gskgpuborderop.c index c8313724ec..01a9f2cc6a 100644 --- a/gsk/gpu/gskgpuborderop.c +++ b/gsk/gpu/gskgpuborderop.c @@ -114,7 +114,6 @@ gsk_gpu_border_op (GskGpuFrame *frame, clip, NULL, NULL, - NULL, &instance); gsk_rounded_rect_to_float (outline, offset, instance->outline); diff --git a/gsk/gpu/gskgpuboxshadowop.c b/gsk/gpu/gskgpuboxshadowop.c index 92c8aa8a56..a97c3bdcc0 100644 --- a/gsk/gpu/gskgpuboxshadowop.c +++ b/gsk/gpu/gskgpuboxshadowop.c @@ -98,7 +98,6 @@ gsk_gpu_box_shadow_op (GskGpuFrame *frame, clip, NULL, NULL, - NULL, &instance); gsk_gpu_rect_to_float (bounds, offset, instance->bounds); diff --git a/gsk/gpu/gskgpucolorizeop.c b/gsk/gpu/gskgpucolorizeop.c index e5bc2a07ed..c73000efb3 100644 --- a/gsk/gpu/gskgpucolorizeop.c +++ b/gsk/gpu/gskgpucolorizeop.c @@ -53,7 +53,6 @@ void gsk_gpu_colorize_op (GskGpuFrame *frame, GskGpuShaderClip clip, GskGpuColorStates color_states, - GskGpuDescriptors *descriptors, const graphene_point_t *offset, const GskGpuShaderImage *image, const float color[4]) @@ -65,7 +64,6 @@ gsk_gpu_colorize_op (GskGpuFrame *frame, color_states, 0, clip, - descriptors, (GskGpuImage *[1]) { image->image }, (GskGpuSampler[1]) { image->sampler }, &instance); diff --git a/gsk/gpu/gskgpucolorizeopprivate.h b/gsk/gpu/gskgpucolorizeopprivate.h index 3fe39f4aa4..d123d6404e 100644 --- a/gsk/gpu/gskgpucolorizeopprivate.h +++ b/gsk/gpu/gskgpucolorizeopprivate.h @@ -9,7 +9,6 @@ G_BEGIN_DECLS void gsk_gpu_colorize_op (GskGpuFrame *frame, GskGpuShaderClip clip, GskGpuColorStates color_states, - GskGpuDescriptors *desc, const graphene_point_t *offset, const GskGpuShaderImage *image, const float color[4]); diff --git a/gsk/gpu/gskgpucolormatrixop.c b/gsk/gpu/gskgpucolormatrixop.c index 0e8ee568f3..77d2af7d0a 100644 --- a/gsk/gpu/gskgpucolormatrixop.c +++ b/gsk/gpu/gskgpucolormatrixop.c @@ -52,7 +52,6 @@ void gsk_gpu_color_matrix_op (GskGpuFrame *frame, GskGpuShaderClip clip, GskGpuColorStates color_states, - GskGpuDescriptors *desc, const graphene_point_t *offset, const GskGpuShaderImage *image, const graphene_matrix_t *color_matrix, @@ -65,7 +64,6 @@ gsk_gpu_color_matrix_op (GskGpuFrame *frame, color_states, 0, clip, - desc, (GskGpuImage *[1]) { image->image }, (GskGpuSampler[1]) { image->sampler }, &instance); diff --git a/gsk/gpu/gskgpucolormatrixopprivate.h b/gsk/gpu/gskgpucolormatrixopprivate.h index b32e654bb7..f1b6667bfa 100644 --- a/gsk/gpu/gskgpucolormatrixopprivate.h +++ b/gsk/gpu/gskgpucolormatrixopprivate.h @@ -9,7 +9,6 @@ G_BEGIN_DECLS void gsk_gpu_color_matrix_op (GskGpuFrame *frame, GskGpuShaderClip clip, GskGpuColorStates color_states, - GskGpuDescriptors *desc, const graphene_point_t *offset, const GskGpuShaderImage *image, const graphene_matrix_t *color_matrix, diff --git a/gsk/gpu/gskgpucolorop.c b/gsk/gpu/gskgpucolorop.c index 21930c76da..7ab894b292 100644 --- a/gsk/gpu/gskgpucolorop.c +++ b/gsk/gpu/gskgpucolorop.c @@ -67,7 +67,6 @@ gsk_gpu_color_op (GskGpuFrame *frame, clip, NULL, NULL, - NULL, &instance); gsk_gpu_rect_to_float (rect, offset, instance->rect); diff --git a/gsk/gpu/gskgpuconicgradientop.c b/gsk/gpu/gskgpuconicgradientop.c index 5c56cb49a5..24348cf195 100644 --- a/gsk/gpu/gskgpuconicgradientop.c +++ b/gsk/gpu/gskgpuconicgradientop.c @@ -74,7 +74,6 @@ gsk_gpu_conic_gradient_op (GskGpuFrame *frame, clip, NULL, NULL, - NULL, &instance); gsk_gpu_rect_to_float (rect, offset, instance->rect); diff --git a/gsk/gpu/gskgpuconvertop.c b/gsk/gpu/gskgpuconvertop.c index 96dbc9cb1a..c58507ad95 100644 --- a/gsk/gpu/gskgpuconvertop.c +++ b/gsk/gpu/gskgpuconvertop.c @@ -59,7 +59,6 @@ gsk_gpu_convert_op (GskGpuFrame *frame, GskGpuShaderClip clip, GskGpuColorStates color_states, float opacity, - GskGpuDescriptors *desc, gboolean straight_alpha, const graphene_point_t *offset, const GskGpuShaderImage *image) @@ -72,7 +71,6 @@ gsk_gpu_convert_op (GskGpuFrame *frame, (opacity < 1.0 ? VARIATION_OPACITY : 0) | (straight_alpha ? VARIATION_STRAIGHT_ALPHA : 0), clip, - desc, (GskGpuImage *[1]) { image->image }, (GskGpuSampler[1]) { image->sampler }, &instance); diff --git a/gsk/gpu/gskgpuconvertopprivate.h b/gsk/gpu/gskgpuconvertopprivate.h index b4b79d05f3..5d2d9c7b35 100644 --- a/gsk/gpu/gskgpuconvertopprivate.h +++ b/gsk/gpu/gskgpuconvertopprivate.h @@ -10,7 +10,6 @@ void gsk_gpu_convert_op (GskGpuF GskGpuShaderClip clip, GskGpuColorStates color_states, float opacity, - GskGpuDescriptors *desc, gboolean straight_alpha, const graphene_point_t *offset, const GskGpuShaderImage *image); diff --git a/gsk/gpu/gskgpucrossfadeop.c b/gsk/gpu/gskgpucrossfadeop.c index 3f6a8e399d..3a24b40269 100644 --- a/gsk/gpu/gskgpucrossfadeop.c +++ b/gsk/gpu/gskgpucrossfadeop.c @@ -54,7 +54,6 @@ void gsk_gpu_cross_fade_op (GskGpuFrame *frame, GskGpuShaderClip clip, GskGpuColorStates color_states, - GskGpuDescriptors *desc, const graphene_rect_t *rect, const graphene_point_t *offset, float opacity, @@ -69,7 +68,6 @@ gsk_gpu_cross_fade_op (GskGpuFrame *frame, color_states, 0, clip, - desc, (GskGpuImage *[2]) { start->image, end->image }, (GskGpuSampler[2]) { start->sampler, end->sampler }, &instance); diff --git a/gsk/gpu/gskgpucrossfadeopprivate.h b/gsk/gpu/gskgpucrossfadeopprivate.h index ceb7d1fcc1..a6b86ec02f 100644 --- a/gsk/gpu/gskgpucrossfadeopprivate.h +++ b/gsk/gpu/gskgpucrossfadeopprivate.h @@ -9,7 +9,6 @@ G_BEGIN_DECLS void gsk_gpu_cross_fade_op (GskGpuFrame *frame, GskGpuShaderClip clip, GskGpuColorStates color_states, - GskGpuDescriptors *desc, const graphene_rect_t *rect, const graphene_point_t *offset, float opacity, diff --git a/gsk/gpu/gskgpudescriptors.c b/gsk/gpu/gskgpudescriptors.c deleted file mode 100644 index 7749c9607c..0000000000 --- a/gsk/gpu/gskgpudescriptors.c +++ /dev/null @@ -1,159 +0,0 @@ -#include "config.h" - -#include "gskgpudescriptorsprivate.h" - -typedef struct _GskGpuImageEntry GskGpuImageEntry; -typedef struct _GskGpuBufferEntry GskGpuBufferEntry; - -struct _GskGpuImageEntry -{ - GskGpuImage *image; - GskGpuSampler sampler; - guint32 descriptor; -}; - -static void -gsk_gpu_image_entry_clear (gpointer data) -{ - GskGpuImageEntry *entry = data; - - g_object_unref (entry->image); -} - -#define GDK_ARRAY_NAME gsk_gpu_image_entries -#define GDK_ARRAY_TYPE_NAME GskGpuImageEntries -#define GDK_ARRAY_ELEMENT_TYPE GskGpuImageEntry -#define GDK_ARRAY_FREE_FUNC gsk_gpu_image_entry_clear -#define GDK_ARRAY_BY_VALUE 1 -#define GDK_ARRAY_PREALLOC 16 -#define GDK_ARRAY_NO_MEMSET 1 -#include "gdk/gdkarrayimpl.c" - -typedef struct _GskGpuDescriptorsPrivate GskGpuDescriptorsPrivate; - -struct _GskGpuDescriptorsPrivate -{ - GskGpuImageEntries images; -}; - -G_DEFINE_TYPE_WITH_PRIVATE (GskGpuDescriptors, gsk_gpu_descriptors, G_TYPE_OBJECT) - -static void -gsk_gpu_descriptors_finalize (GObject *object) -{ - GskGpuDescriptors *self = GSK_GPU_DESCRIPTORS (object); - GskGpuDescriptorsPrivate *priv = gsk_gpu_descriptors_get_instance_private (self); - - gsk_gpu_image_entries_clear (&priv->images); - - G_OBJECT_CLASS (gsk_gpu_descriptors_parent_class)->finalize (object); -} - -static void -gsk_gpu_descriptors_class_init (GskGpuDescriptorsClass *klass) -{ - GObjectClass *object_class = G_OBJECT_CLASS (klass); - - object_class->finalize = gsk_gpu_descriptors_finalize; -} - -static void -gsk_gpu_descriptors_init (GskGpuDescriptors *self) -{ - GskGpuDescriptorsPrivate *priv = gsk_gpu_descriptors_get_instance_private (self); - - gsk_gpu_image_entries_init (&priv->images); -} - -gsize -gsk_gpu_descriptors_get_n_images (GskGpuDescriptors *self) -{ - GskGpuDescriptorsPrivate *priv = gsk_gpu_descriptors_get_instance_private (self); - - return gsk_gpu_image_entries_get_size (&priv->images); -} - -void -gsk_gpu_descriptors_set_size (GskGpuDescriptors *self, - gsize n_images) -{ - GskGpuDescriptorsPrivate *priv = gsk_gpu_descriptors_get_instance_private (self); - - g_assert (n_images <= gsk_gpu_image_entries_get_size (&priv->images)); - gsk_gpu_image_entries_set_size (&priv->images, n_images); -} - -GskGpuImage * -gsk_gpu_descriptors_get_image (GskGpuDescriptors *self, - gsize id) -{ - GskGpuDescriptorsPrivate *priv = gsk_gpu_descriptors_get_instance_private (self); - const GskGpuImageEntry *entry = gsk_gpu_image_entries_get (&priv->images, id); - - return entry->image; -} - -GskGpuSampler -gsk_gpu_descriptors_get_sampler (GskGpuDescriptors *self, - gsize id) -{ - GskGpuDescriptorsPrivate *priv = gsk_gpu_descriptors_get_instance_private (self); - const GskGpuImageEntry *entry = gsk_gpu_image_entries_get (&priv->images, id); - - return entry->sampler; -} - -gsize -gsk_gpu_descriptors_find_image (GskGpuDescriptors *self, - guint32 descriptor) -{ - GskGpuDescriptorsPrivate *priv = gsk_gpu_descriptors_get_instance_private (self); - gsize i; - - for (i = 0; i < gsk_gpu_image_entries_get_size (&priv->images); i++) - { - const GskGpuImageEntry *entry = gsk_gpu_image_entries_get (&priv->images, i); - - if (entry->descriptor == descriptor) - return i; - } - - g_return_val_if_reached ((gsize) -1); -} - -gboolean -gsk_gpu_descriptors_add_image (GskGpuDescriptors *self, - GskGpuImage *image, - GskGpuSampler sampler, - guint32 *out_descriptor) -{ - GskGpuDescriptorsPrivate *priv = gsk_gpu_descriptors_get_instance_private (self); - gsize i; - guint32 descriptor; - - for (i = 0; i < gsk_gpu_image_entries_get_size (&priv->images); i++) - { - const GskGpuImageEntry *entry = gsk_gpu_image_entries_get (&priv->images, i); - - if (entry->image == image && entry->sampler == sampler) - { - *out_descriptor = entry->descriptor; - return TRUE; - } - } - - if (!GSK_GPU_DESCRIPTORS_GET_CLASS (self)->add_image (self, image, sampler, &descriptor)) - return FALSE; - - gsk_gpu_image_entries_append (&priv->images, - &(GskGpuImageEntry) { - .image = g_object_ref (image), - .sampler = sampler, - .descriptor = descriptor - }); - - *out_descriptor = descriptor; - - return TRUE; -} - diff --git a/gsk/gpu/gskgpudescriptorsprivate.h b/gsk/gpu/gskgpudescriptorsprivate.h deleted file mode 100644 index c64db7d661..0000000000 --- a/gsk/gpu/gskgpudescriptorsprivate.h +++ /dev/null @@ -1,51 +0,0 @@ -#pragma once - -#include "gskgputypesprivate.h" - -G_BEGIN_DECLS - -#define GSK_TYPE_GPU_DESCRIPTORS (gsk_gpu_descriptors_get_type ()) -#define GSK_GPU_DESCRIPTORS(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), GSK_TYPE_GPU_DESCRIPTORS, GskGpuDescriptors)) -#define GSK_GPU_DESCRIPTORS_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), GSK_TYPE_GPU_DESCRIPTORS, GskGpuDescriptorsClass)) -#define GSK_IS_GPU_DESCRIPTORS(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), GSK_TYPE_GPU_DESCRIPTORS)) -#define GSK_IS_GPU_DESCRIPTORS_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), GSK_TYPE_GPU_DESCRIPTORS)) -#define GSK_GPU_DESCRIPTORS_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GSK_TYPE_GPU_DESCRIPTORS, GskGpuDescriptorsClass)) - -typedef struct _GskGpuDescriptorsClass GskGpuDescriptorsClass; - -struct _GskGpuDescriptors -{ - GObject parent_instance; -}; - -struct _GskGpuDescriptorsClass -{ - GObjectClass parent_class; - - gboolean (* add_image) (GskGpuDescriptors *self, - GskGpuImage *image, - GskGpuSampler sampler, - guint32 *out_id); -}; - -GType gsk_gpu_descriptors_get_type (void) G_GNUC_CONST; - -gsize gsk_gpu_descriptors_get_n_images (GskGpuDescriptors *self); -void gsk_gpu_descriptors_set_size (GskGpuDescriptors *self, - gsize n_images); -GskGpuImage * gsk_gpu_descriptors_get_image (GskGpuDescriptors *self, - gsize id); -GskGpuSampler gsk_gpu_descriptors_get_sampler (GskGpuDescriptors *self, - gsize id); -gsize gsk_gpu_descriptors_find_image (GskGpuDescriptors *self, - guint32 descriptor); - -gboolean gsk_gpu_descriptors_add_image (GskGpuDescriptors *self, - GskGpuImage *image, - GskGpuSampler sampler, - guint32 *out_descriptor); - - -G_DEFINE_AUTOPTR_CLEANUP_FUNC(GskGpuDescriptors, g_object_unref) - -G_END_DECLS diff --git a/gsk/gpu/gskgpuframe.c b/gsk/gpu/gskgpuframe.c index 0aa3e8eaf2..8ac2b6edad 100644 --- a/gsk/gpu/gskgpuframe.c +++ b/gsk/gpu/gskgpuframe.c @@ -473,12 +473,6 @@ gsk_gpu_frame_upload_texture (GskGpuFrame *self, return image; } -GskGpuDescriptors * -gsk_gpu_frame_create_descriptors (GskGpuFrame *self) -{ - return GSK_GPU_FRAME_GET_CLASS (self)->create_descriptors (self); -} - static GskGpuBuffer * gsk_gpu_frame_create_vertex_buffer (GskGpuFrame *self, gsize size) diff --git a/gsk/gpu/gskgpuframeprivate.h b/gsk/gpu/gskgpuframeprivate.h index 10be903a77..384977a4e1 100644 --- a/gsk/gpu/gskgpuframeprivate.h +++ b/gsk/gpu/gskgpuframeprivate.h @@ -36,7 +36,6 @@ struct _GskGpuFrameClass GskGpuImage * (* upload_texture) (GskGpuFrame *self, gboolean with_mipmap, GdkTexture *texture); - GskGpuDescriptors * (* create_descriptors) (GskGpuFrame *self); GskGpuBuffer * (* create_vertex_buffer) (GskGpuFrame *self, gsize size); GskGpuBuffer * (* create_storage_buffer) (GskGpuFrame *self, @@ -82,7 +81,6 @@ gpointer gsk_gpu_frame_alloc_op (GskGpuF GskGpuImage * gsk_gpu_frame_upload_texture (GskGpuFrame *self, gboolean with_mipmap, GdkTexture *texture); -GskGpuDescriptors * gsk_gpu_frame_create_descriptors (GskGpuFrame *self); gsize gsk_gpu_frame_reserve_vertex_data (GskGpuFrame *self, gsize size); guchar * gsk_gpu_frame_get_vertex_data (GskGpuFrame *self, diff --git a/gsk/gpu/gskgpuglobalsop.c b/gsk/gpu/gskgpuglobalsop.c index e7a0f45289..432f69cf43 100644 --- a/gsk/gpu/gskgpuglobalsop.c +++ b/gsk/gpu/gskgpuglobalsop.c @@ -9,7 +9,6 @@ #ifdef GDK_RENDERING_VULKAN #include "gskvulkandeviceprivate.h" #include "gskvulkanframeprivate.h" -#include "gskvulkandescriptorsprivate.h" #endif typedef struct _GskGpuGlobalsOp GskGpuGlobalsOp; @@ -51,8 +50,8 @@ gsk_gpu_globals_op_vk_command (GskGpuOp *op, GskGpuGlobalsOp *self = (GskGpuGlobalsOp *) op; vkCmdPushConstants (state->vk_command_buffer, - gsk_vulkan_device_get_vk_pipeline_layout (GSK_VULKAN_DEVICE (gsk_gpu_frame_get_device (frame)), - gsk_vulkan_descriptors_get_pipeline_layout (state->desc)), + NULL, //gsk_vulkan_device_get_vk_pipeline_layout (GSK_VULKAN_DEVICE (gsk_gpu_frame_get_device (frame)), + // gsk_vulkan_descriptors_get_pipeline_layout (state->desc)), VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT, 0, sizeof (self->instance), diff --git a/gsk/gpu/gskgpulineargradientop.c b/gsk/gpu/gskgpulineargradientop.c index 8f0c0f064e..10147528b3 100644 --- a/gsk/gpu/gskgpulineargradientop.c +++ b/gsk/gpu/gskgpulineargradientop.c @@ -79,7 +79,6 @@ gsk_gpu_linear_gradient_op (GskGpuFrame *frame, clip, NULL, NULL, - NULL, &instance); gsk_gpu_rect_to_float (rect, offset, instance->rect); diff --git a/gsk/gpu/gskgpumaskop.c b/gsk/gpu/gskgpumaskop.c index 73d5cbde17..59c8daa810 100644 --- a/gsk/gpu/gskgpumaskop.c +++ b/gsk/gpu/gskgpumaskop.c @@ -54,7 +54,6 @@ static const GskGpuShaderOpClass GSK_GPU_MASK_OP_CLASS = { void gsk_gpu_mask_op (GskGpuFrame *frame, GskGpuShaderClip clip, - GskGpuDescriptors *desc, const graphene_rect_t *rect, const graphene_point_t *offset, float opacity, @@ -69,7 +68,6 @@ gsk_gpu_mask_op (GskGpuFrame *frame, gsk_gpu_color_states_create_equal (TRUE, TRUE), mask_mode, clip, - desc, (GskGpuImage *[2]) { source->image, mask->image }, (GskGpuSampler[2]) { source->sampler, mask->sampler }, &instance); diff --git a/gsk/gpu/gskgpumaskopprivate.h b/gsk/gpu/gskgpumaskopprivate.h index 20c74b2b90..b66964011c 100644 --- a/gsk/gpu/gskgpumaskopprivate.h +++ b/gsk/gpu/gskgpumaskopprivate.h @@ -8,7 +8,6 @@ G_BEGIN_DECLS void gsk_gpu_mask_op (GskGpuFrame *frame, GskGpuShaderClip clip, - GskGpuDescriptors *desc, const graphene_rect_t *rect, const graphene_point_t *offset, float opacity, diff --git a/gsk/gpu/gskgpumipmapop.c b/gsk/gpu/gskgpumipmapop.c index f662d606db..f92583eacd 100644 --- a/gsk/gpu/gskgpumipmapop.c +++ b/gsk/gpu/gskgpumipmapop.c @@ -159,7 +159,7 @@ gsk_gpu_mipmap_op_gl_command (GskGpuOp *op, glActiveTexture (GL_TEXTURE0); gsk_gl_image_bind_texture (GSK_GL_IMAGE (self->image)); /* need to reset the images again */ - state->desc = NULL; + state->current_images[0] = NULL; glGenerateMipmap (GL_TEXTURE_2D); diff --git a/gsk/gpu/gskgpunodeprocessor.c b/gsk/gpu/gskgpunodeprocessor.c index 4960f66ae4..0c24e638ef 100644 --- a/gsk/gpu/gskgpunodeprocessor.c +++ b/gsk/gpu/gskgpunodeprocessor.c @@ -17,7 +17,6 @@ #include "gskgpuconicgradientopprivate.h" #include "gskgpuconvertopprivate.h" #include "gskgpucrossfadeopprivate.h" -#include "gskgpudescriptorsprivate.h" #include "gskgpudeviceprivate.h" #include "gskgpuframeprivate.h" #include "gskgpuglobalsopprivate.h" @@ -112,7 +111,6 @@ struct _GskGpuNodeProcessor { GskGpuFrame *frame; GdkColorState *ccs; - GskGpuDescriptors *desc; cairo_rectangle_int_t scissor; GskGpuBlend blend; graphene_point_t offset; @@ -143,7 +141,6 @@ static void gsk_gpu_node_processor_finish (GskGpuNodeProcessor *self) { g_clear_pointer (&self->modelview, gsk_transform_unref); - g_clear_object (&self->desc); } static void @@ -161,7 +158,6 @@ gsk_gpu_node_processor_init (GskGpuNodeProcessor *self, self->frame = frame; self->ccs = ccs; - self->desc = NULL; self->scissor = *clip; self->blend = GSK_GPU_BLEND_OVER; @@ -271,42 +267,6 @@ gsk_gpu_node_processor_color_states_for_rgba (GskGpuNodeProcessor *self) FALSE); } -static guint32 -gsk_gpu_node_processor_add_image (GskGpuNodeProcessor *self, - GskGpuImage *image, - GskGpuSampler sampler) -{ - guint32 descriptor; - - g_clear_object (&self->desc); - self->desc = gsk_gpu_frame_create_descriptors (self->frame); - - if (!gsk_gpu_descriptors_add_image (self->desc, image, sampler, &descriptor)) - { - g_assert_not_reached (); - return 0; - } - - return descriptor; -} - -static void -gsk_gpu_node_processor_add_two_images (GskGpuNodeProcessor *self, - GskGpuImage *image1, - GskGpuSampler sampler1, - GskGpuImage *image2, - GskGpuSampler sampler2, - guint32 *out_descriptors) -{ - g_clear_object (&self->desc); - self->desc = gsk_gpu_frame_create_descriptors (self->frame); - if (!gsk_gpu_descriptors_add_image (self->desc, image1, sampler1, &out_descriptors[0]) || - !gsk_gpu_descriptors_add_image (self->desc, image2, sampler2, &out_descriptors[1])) - { - g_assert_not_reached (); - } -} - static void rect_round_to_pixels (const graphene_rect_t *src, const graphene_vec2_t *pixel_scale, @@ -520,12 +480,10 @@ gsk_gpu_node_processor_image_op (GskGpuNodeProcessor *self, const graphene_rect_t *rect, const graphene_rect_t *tex_rect) { - guint32 descriptor; gboolean straight_alpha; g_assert (self->pending_globals == 0); - descriptor = gsk_gpu_node_processor_add_image (self, image, sampler); straight_alpha = gsk_gpu_image_get_flags (image) & GSK_GPU_IMAGE_STRAIGHT_ALPHA; if (straight_alpha || @@ -538,13 +496,11 @@ gsk_gpu_node_processor_image_op (GskGpuNodeProcessor *self, image_color_state, TRUE), self->opacity, - self->desc, straight_alpha, &self->offset, &(GskGpuShaderImage) { image, sampler, - descriptor, rect, tex_rect }); @@ -553,12 +509,10 @@ gsk_gpu_node_processor_image_op (GskGpuNodeProcessor *self, { gsk_gpu_texture_op (self->frame, gsk_gpu_clip_get_shader_clip (&self->clip, &self->offset, rect), - self->desc, &self->offset, &(GskGpuShaderImage) { image, sampler, - descriptor, rect, tex_rect }); @@ -756,15 +710,12 @@ gsk_gpu_node_processor_blur_op (GskGpuNodeProcessor *self, const graphene_point_t *shadow_offset, float blur_radius, const GdkRGBA *shadow_color, - GskGpuDescriptors *source_desc, GskGpuImage *source_image, - guint32 source_descriptor, GdkMemoryDepth source_depth, const graphene_rect_t *source_rect) { GskGpuNodeProcessor other; GskGpuImage *intermediate; - guint32 intermediate_descriptor; graphene_vec2_t direction; graphene_rect_t clip_rect, intermediate_rect; graphene_point_t real_offset; @@ -795,12 +746,10 @@ gsk_gpu_node_processor_blur_op (GskGpuNodeProcessor *self, gsk_gpu_blur_op (other.frame, gsk_gpu_clip_get_shader_clip (&other.clip, &other.offset, &intermediate_rect), gsk_gpu_node_processor_color_states_self (&other), - source_desc, &other.offset, &(GskGpuShaderImage) { source_image, GSK_GPU_SAMPLER_TRANSPARENT, - source_descriptor, &intermediate_rect, source_rect }, @@ -811,18 +760,15 @@ gsk_gpu_node_processor_blur_op (GskGpuNodeProcessor *self, real_offset = GRAPHENE_POINT_INIT (self->offset.x + shadow_offset->x, self->offset.y + shadow_offset->y); graphene_vec2_init (&direction, 0.0f, blur_radius); - intermediate_descriptor = gsk_gpu_node_processor_add_image (self, intermediate, GSK_GPU_SAMPLER_TRANSPARENT); if (shadow_color) { gsk_gpu_blur_shadow_op (self->frame, gsk_gpu_clip_get_shader_clip (&self->clip, &real_offset, rect), gsk_gpu_node_processor_color_states_for_rgba (self), - self->desc, &real_offset, &(GskGpuShaderImage) { intermediate, GSK_GPU_SAMPLER_TRANSPARENT, - intermediate_descriptor, rect, &intermediate_rect, }, @@ -834,12 +780,10 @@ gsk_gpu_node_processor_blur_op (GskGpuNodeProcessor *self, gsk_gpu_blur_op (self->frame, gsk_gpu_clip_get_shader_clip (&self->clip, &real_offset, rect), gsk_gpu_node_processor_color_states_self (self), - self->desc, &real_offset, &(GskGpuShaderImage) { intermediate, GSK_GPU_SAMPLER_TRANSPARENT, - intermediate_descriptor, rect, &intermediate_rect, }, @@ -1046,7 +990,6 @@ gsk_gpu_node_processor_add_rounded_clip_node_with_mask (GskGpuNodeProcessor *sel GskGpuNodeProcessor other; graphene_rect_t clip_bounds, child_rect; GskGpuImage *child_image, *mask_image; - guint32 descriptors[2]; if (!gsk_gpu_node_processor_clip_node_bounds (self, node, &clip_bounds)) return; @@ -1075,17 +1018,9 @@ gsk_gpu_node_processor_add_rounded_clip_node_with_mask (GskGpuNodeProcessor *sel (float[4]) { 1, 1, 1, 1 }); gsk_gpu_node_processor_finish_draw (&other, mask_image); - gsk_gpu_node_processor_add_two_images (self, - child_image, - GSK_GPU_SAMPLER_DEFAULT, - mask_image, - GSK_GPU_SAMPLER_DEFAULT, - descriptors); - gsk_gpu_node_processor_sync_globals (self, 0); gsk_gpu_mask_op (self->frame, gsk_gpu_clip_get_shader_clip (&self->clip, &self->offset, &clip_bounds), - self->desc, &clip_bounds, &self->offset, self->opacity, @@ -1093,14 +1028,12 @@ gsk_gpu_node_processor_add_rounded_clip_node_with_mask (GskGpuNodeProcessor *sel &(GskGpuShaderImage) { child_image, GSK_GPU_SAMPLER_DEFAULT, - descriptors[0], NULL, &child_rect, }, &(GskGpuShaderImage) { mask_image, GSK_GPU_SAMPLER_DEFAULT, - descriptors[1], NULL, &clip_bounds, }); @@ -2021,7 +1954,6 @@ gsk_gpu_node_processor_add_texture_scale_node (GskGpuNodeProcessor *self, GdkTexture *texture; GdkColorState *image_cs; GskScalingFilter scaling_filter; - guint32 descriptor; gboolean need_mipmap, need_offscreen; texture = gsk_texture_scale_node_get_texture (node); @@ -2073,15 +2005,12 @@ gsk_gpu_node_processor_add_texture_scale_node (GskGpuNodeProcessor *self, node); g_object_unref (image); } - descriptor = gsk_gpu_node_processor_add_image (self, offscreen, GSK_GPU_SAMPLER_DEFAULT); gsk_gpu_texture_op (self->frame, gsk_gpu_clip_get_shader_clip (&self->clip, &self->offset, &node->bounds), - self->desc, &self->offset, &(GskGpuShaderImage) { offscreen, GSK_GPU_SAMPLER_DEFAULT, - descriptor, &node->bounds, &clip_bounds }); @@ -2104,16 +2033,12 @@ gsk_gpu_node_processor_add_texture_scale_node (GskGpuNodeProcessor *self, if (need_mipmap && !(gsk_gpu_image_get_flags (image) & GSK_GPU_IMAGE_MIPMAP)) gsk_gpu_mipmap_op (self->frame, image); - descriptor = gsk_gpu_node_processor_add_image (self, image, gsk_gpu_sampler_for_scaling_filter (scaling_filter)); - gsk_gpu_texture_op (self->frame, gsk_gpu_clip_get_shader_clip (&self->clip, &self->offset, &node->bounds), - self->desc, &self->offset, &(GskGpuShaderImage) { image, gsk_gpu_sampler_for_scaling_filter (scaling_filter), - descriptor, &node->bounds, &node->bounds, }); @@ -2269,7 +2194,6 @@ gsk_gpu_node_processor_add_gradient_node (GskGpuNodeProcessor *self, graphene_rect_t bounds; gsize i, j; GskGpuImage *image; - guint32 descriptor; if (n_stops < 8) { @@ -2343,16 +2267,12 @@ gsk_gpu_node_processor_add_gradient_node (GskGpuNodeProcessor *self, gsk_gpu_node_processor_finish_draw (&other, image); - descriptor = gsk_gpu_node_processor_add_image (self, image, GSK_GPU_SAMPLER_DEFAULT); - gsk_gpu_texture_op (self->frame, gsk_gpu_clip_get_shader_clip (&self->clip, &self->offset, &bounds), - self->desc, &self->offset, &(GskGpuShaderImage) { image, GSK_GPU_SAMPLER_DEFAULT, - descriptor, &node->bounds, &bounds }); @@ -2459,7 +2379,6 @@ gsk_gpu_node_processor_add_blur_node (GskGpuNodeProcessor *self, GskGpuImage *image; graphene_rect_t tex_rect, clip_rect; float blur_radius, clip_radius; - guint32 descriptor; child = gsk_blur_node_get_child (node); blur_radius = gsk_blur_node_get_radius (node); @@ -2479,16 +2398,12 @@ gsk_gpu_node_processor_add_blur_node (GskGpuNodeProcessor *self, if (image == NULL) return; - descriptor = gsk_gpu_node_processor_add_image (self, image, GSK_GPU_SAMPLER_TRANSPARENT); - gsk_gpu_node_processor_blur_op (self, &node->bounds, graphene_point_zero (), blur_radius, NULL, - self->desc, image, - descriptor, gdk_memory_format_get_depth (gsk_gpu_image_get_format (image), gsk_gpu_image_get_flags (image) & GSK_GPU_IMAGE_SRGB), &tex_rect); @@ -2504,8 +2419,6 @@ gsk_gpu_node_processor_add_shadow_node (GskGpuNodeProcessor *self, graphene_rect_t clip_bounds, tex_rect; GskRenderNode *child; gsize i, n_shadows; - GskGpuDescriptors *desc; - guint32 descriptor; n_shadows = gsk_shadow_node_get_n_shadows (node); child = gsk_shadow_node_get_child (node); @@ -2523,9 +2436,6 @@ gsk_gpu_node_processor_add_shadow_node (GskGpuNodeProcessor *self, if (image == NULL) return; - descriptor = gsk_gpu_node_processor_add_image (self, image, GSK_GPU_SAMPLER_TRANSPARENT); - desc = self->desc; - for (i = 0; i < n_shadows; i++) { const GskShadow *shadow = gsk_shadow_node_get_shadow (node, i); @@ -2536,12 +2446,10 @@ gsk_gpu_node_processor_add_shadow_node (GskGpuNodeProcessor *self, gsk_gpu_colorize_op (self->frame, gsk_gpu_clip_get_shader_clip (&self->clip, &shadow_offset, &child->bounds), gsk_gpu_node_processor_color_states_for_rgba (self), - desc, &shadow_offset, &(GskGpuShaderImage) { image, GSK_GPU_SAMPLER_TRANSPARENT, - descriptor, &child->bounds, &tex_rect, }, @@ -2557,24 +2465,19 @@ gsk_gpu_node_processor_add_shadow_node (GskGpuNodeProcessor *self, &GRAPHENE_POINT_INIT (shadow->dx, shadow->dy), shadow->radius, &shadow->color, - desc, image, - descriptor, gdk_memory_format_get_depth (gsk_gpu_image_get_format (image), gsk_gpu_image_get_flags (image) & GSK_GPU_IMAGE_SRGB), &tex_rect); } } - descriptor = gsk_gpu_node_processor_add_image (self, image, GSK_GPU_SAMPLER_DEFAULT); gsk_gpu_texture_op (self->frame, gsk_gpu_clip_get_shader_clip (&self->clip, &self->offset, &child->bounds), - self->desc, &self->offset, &(GskGpuShaderImage) { image, GSK_GPU_SAMPLER_DEFAULT, - descriptor, &child->bounds, &tex_rect, }); @@ -2603,7 +2506,6 @@ gsk_gpu_node_processor_add_blend_node (GskGpuNodeProcessor *self, GskRenderNode *bottom_child, *top_child; graphene_rect_t bottom_rect, top_rect; GskGpuImage *bottom_image, *top_image; - guint32 descriptors[2]; bottom_child = gsk_blend_node_get_bottom_child (node); top_child = gsk_blend_node_get_top_child (node); @@ -2631,16 +2533,8 @@ gsk_gpu_node_processor_add_blend_node (GskGpuNodeProcessor *self, top_rect = *graphene_rect_zero (); } - gsk_gpu_node_processor_add_two_images (self, - bottom_image, - GSK_GPU_SAMPLER_DEFAULT, - top_image, - GSK_GPU_SAMPLER_DEFAULT, - descriptors); - gsk_gpu_blend_mode_op (self->frame, gsk_gpu_clip_get_shader_clip (&self->clip, &self->offset, &node->bounds), - self->desc, &node->bounds, &self->offset, self->opacity, @@ -2648,14 +2542,12 @@ gsk_gpu_node_processor_add_blend_node (GskGpuNodeProcessor *self, &(GskGpuShaderImage) { bottom_image, GSK_GPU_SAMPLER_DEFAULT, - descriptors[0], NULL, &bottom_rect }, &(GskGpuShaderImage) { top_image, GSK_GPU_SAMPLER_DEFAULT, - descriptors[1], NULL, &top_rect }); @@ -2671,7 +2563,6 @@ gsk_gpu_node_processor_add_cross_fade_node (GskGpuNodeProcessor *self, GskRenderNode *start_child, *end_child; graphene_rect_t start_rect, end_rect; GskGpuImage *start_image, *end_image; - guint32 descriptors[2]; float progress, old_opacity; start_child = gsk_cross_fade_node_get_start_child (node); @@ -2730,17 +2621,9 @@ gsk_gpu_node_processor_add_cross_fade_node (GskGpuNodeProcessor *self, return; } - gsk_gpu_node_processor_add_two_images (self, - start_image, - GSK_GPU_SAMPLER_DEFAULT, - end_image, - GSK_GPU_SAMPLER_DEFAULT, - descriptors); - gsk_gpu_cross_fade_op (self->frame, gsk_gpu_clip_get_shader_clip (&self->clip, &self->offset, &node->bounds), gsk_gpu_node_processor_color_states_for_rgba (self), - self->desc, &node->bounds, &self->offset, self->opacity, @@ -2748,14 +2631,12 @@ gsk_gpu_node_processor_add_cross_fade_node (GskGpuNodeProcessor *self, &(GskGpuShaderImage) { start_image, GSK_GPU_SAMPLER_DEFAULT, - descriptors[0], NULL, &start_rect }, &(GskGpuShaderImage) { end_image, GSK_GPU_SAMPLER_DEFAULT, - descriptors[1], NULL, &end_rect }); @@ -2795,16 +2676,13 @@ gsk_gpu_node_processor_add_mask_node (GskGpuNodeProcessor *self, mask_mode == GSK_MASK_MODE_ALPHA) { const GdkRGBA *rgba = gsk_color_node_get_color (source_child); - guint32 descriptor = gsk_gpu_node_processor_add_image (self, mask_image, GSK_GPU_SAMPLER_DEFAULT); gsk_gpu_colorize_op (self->frame, gsk_gpu_clip_get_shader_clip (&self->clip, &self->offset, &node->bounds), gsk_gpu_node_processor_color_states_for_rgba (self), - self->desc, &self->offset, &(GskGpuShaderImage) { mask_image, GSK_GPU_SAMPLER_DEFAULT, - descriptor, &node->bounds, &mask_rect, }, @@ -2814,7 +2692,6 @@ gsk_gpu_node_processor_add_mask_node (GskGpuNodeProcessor *self, { GskGpuImage *source_image; graphene_rect_t source_rect; - guint32 descriptors[2]; source_image = gsk_gpu_node_processor_get_node_as_image (self, &bounds, @@ -2825,16 +2702,9 @@ gsk_gpu_node_processor_add_mask_node (GskGpuNodeProcessor *self, g_object_unref (mask_image); return; } - gsk_gpu_node_processor_add_two_images (self, - source_image, - GSK_GPU_SAMPLER_DEFAULT, - mask_image, - GSK_GPU_SAMPLER_DEFAULT, - descriptors); gsk_gpu_mask_op (self->frame, gsk_gpu_clip_get_shader_clip (&self->clip, &self->offset, &node->bounds), - self->desc, &node->bounds, &self->offset, self->opacity, @@ -2842,14 +2712,12 @@ gsk_gpu_node_processor_add_mask_node (GskGpuNodeProcessor *self, &(GskGpuShaderImage) { source_image, GSK_GPU_SAMPLER_DEFAULT, - descriptors[0], NULL, &source_rect, }, &(GskGpuShaderImage) { mask_image, GSK_GPU_SAMPLER_DEFAULT, - descriptors[1], NULL, &mask_rect, }); @@ -2875,7 +2743,6 @@ gsk_gpu_node_processor_add_glyph_node (GskGpuNodeProcessor *self, float inv_align_scale_x, inv_align_scale_y; unsigned int flags_mask; GskGpuImage *last_image; - guint32 descriptor; const float inv_pango_scale = 1.f / PANGO_SCALE; if (self->opacity < 1.0 && @@ -2914,7 +2781,6 @@ gsk_gpu_node_processor_add_glyph_node (GskGpuNodeProcessor *self, inv_align_scale_y = 1 / align_scale_y; last_image = NULL; - descriptor = 0; for (i = 0; i < num_glyphs; i++) { GskGpuImage *image; @@ -2952,20 +2818,15 @@ gsk_gpu_node_processor_add_glyph_node (GskGpuNodeProcessor *self, glyph_origin.y - glyph_offset.y / scale); if (image != last_image) - { - descriptor = gsk_gpu_node_processor_add_image (self, image, GSK_GPU_SAMPLER_DEFAULT); - last_image = image; - } + last_image = image; if (glyphs[i].attr.is_color) gsk_gpu_texture_op (self->frame, gsk_gpu_clip_get_shader_clip (&self->clip, &glyph_offset, &glyph_bounds), - self->desc, &glyph_origin, &(GskGpuShaderImage) { image, GSK_GPU_SAMPLER_DEFAULT, - descriptor, &glyph_bounds, &glyph_tex_rect }); @@ -2973,12 +2834,10 @@ gsk_gpu_node_processor_add_glyph_node (GskGpuNodeProcessor *self, gsk_gpu_colorize_op (self->frame, gsk_gpu_clip_get_shader_clip (&self->clip, &glyph_offset, &glyph_bounds), gsk_gpu_node_processor_color_states_for_rgba (self), - self->desc, &glyph_origin, &(GskGpuShaderImage) { image, GSK_GPU_SAMPLER_DEFAULT, - descriptor, &glyph_bounds, &glyph_tex_rect }, @@ -2993,7 +2852,6 @@ gsk_gpu_node_processor_add_color_matrix_node (GskGpuNodeProcessor *self, GskRenderNode *node) { GskGpuImage *image; - guint32 descriptor; GskRenderNode *child; graphene_matrix_t opacity_matrix; const graphene_matrix_t *color_matrix; @@ -3022,17 +2880,13 @@ gsk_gpu_node_processor_add_color_matrix_node (GskGpuNodeProcessor *self, if (image == NULL) return; - descriptor = gsk_gpu_node_processor_add_image (self, image, GSK_GPU_SAMPLER_DEFAULT); - gsk_gpu_color_matrix_op (self->frame, gsk_gpu_clip_get_shader_clip (&self->clip, &self->offset, &node->bounds), gsk_gpu_node_processor_color_states_explicit (self, self->ccs, FALSE), - self->desc, &self->offset, &(GskGpuShaderImage) { image, GSK_GPU_SAMPLER_DEFAULT, - descriptor, &node->bounds, &tex_rect, }, @@ -3052,7 +2906,6 @@ gsk_gpu_node_processor_repeat_tile (GskGpuNodeProcessor *self, { GskGpuImage *image; graphene_rect_t clipped_child_bounds, offset_rect; - guint32 descriptor; gsk_rect_init_offset (&offset_rect, rect, @@ -3074,16 +2927,12 @@ gsk_gpu_node_processor_repeat_tile (GskGpuNodeProcessor *self, g_return_if_fail (image); - descriptor = gsk_gpu_node_processor_add_image (self, image, GSK_GPU_SAMPLER_REPEAT); - gsk_gpu_texture_op (self->frame, gsk_gpu_clip_get_shader_clip (&self->clip, &self->offset, rect), - self->desc, &self->offset, &(GskGpuShaderImage) { image, GSK_GPU_SAMPLER_REPEAT, - descriptor, rect, &GRAPHENE_RECT_INIT ( clipped_child_bounds.origin.x + x * child_bounds->size.width, @@ -3261,7 +3110,6 @@ gsk_gpu_node_processor_add_fill_node (GskGpuNodeProcessor *self, { graphene_rect_t clip_bounds, source_rect; GskGpuImage *mask_image, *source_image; - guint32 descriptors[2]; GskRenderNode *child; if (!gsk_gpu_node_processor_clip_node_bounds (self, node, &clip_bounds)) @@ -3301,16 +3149,8 @@ gsk_gpu_node_processor_add_fill_node (GskGpuNodeProcessor *self, if (source_image == NULL) return; - gsk_gpu_node_processor_add_two_images (self, - source_image, - GSK_GPU_SAMPLER_DEFAULT, - mask_image, - GSK_GPU_SAMPLER_DEFAULT, - descriptors); - gsk_gpu_mask_op (self->frame, gsk_gpu_clip_get_shader_clip (&self->clip, &self->offset, &clip_bounds), - self->desc, &clip_bounds, &self->offset, self->opacity, @@ -3318,14 +3158,12 @@ gsk_gpu_node_processor_add_fill_node (GskGpuNodeProcessor *self, &(GskGpuShaderImage) { source_image, GSK_GPU_SAMPLER_DEFAULT, - descriptors[0], NULL, &source_rect, }, &(GskGpuShaderImage) { mask_image, GSK_GPU_SAMPLER_DEFAULT, - descriptors[1], NULL, &clip_bounds, }); @@ -3369,7 +3207,6 @@ gsk_gpu_node_processor_add_stroke_node (GskGpuNodeProcessor *self, { graphene_rect_t clip_bounds, source_rect; GskGpuImage *mask_image, *source_image; - guint32 descriptors[2]; GskRenderNode *child; if (!gsk_gpu_node_processor_clip_node_bounds (self, node, &clip_bounds)) @@ -3409,16 +3246,8 @@ gsk_gpu_node_processor_add_stroke_node (GskGpuNodeProcessor *self, if (source_image == NULL) return; - gsk_gpu_node_processor_add_two_images (self, - source_image, - GSK_GPU_SAMPLER_DEFAULT, - mask_image, - GSK_GPU_SAMPLER_DEFAULT, - descriptors); - gsk_gpu_mask_op (self->frame, gsk_gpu_clip_get_shader_clip (&self->clip, &self->offset, &clip_bounds), - self->desc, &clip_bounds, &self->offset, self->opacity, @@ -3426,14 +3255,12 @@ gsk_gpu_node_processor_add_stroke_node (GskGpuNodeProcessor *self, &(GskGpuShaderImage) { source_image, GSK_GPU_SAMPLER_DEFAULT, - descriptors[0], NULL, &source_rect, }, &(GskGpuShaderImage) { mask_image, GSK_GPU_SAMPLER_DEFAULT, - descriptors[1], NULL, &clip_bounds, }); @@ -4056,7 +3883,6 @@ gsk_gpu_node_processor_process (GskGpuFrame *frame, { GskGpuImage *image; graphene_rect_t clip_bounds, tex_rect; - guint32 descriptor; /* Can't use gsk_gpu_node_processor_get_node_as_image () because of colorspaces */ if (gsk_gpu_node_processor_clip_node_bounds (&self, node, &clip_bounds)) @@ -4084,18 +3910,15 @@ gsk_gpu_node_processor_process (GskGpuFrame *frame, self.pending_globals |= GSK_GPU_GLOBAL_BLEND; gsk_gpu_node_processor_sync_globals (&self, 0); - descriptor = gsk_gpu_node_processor_add_image (&self, image, GSK_GPU_SAMPLER_DEFAULT); gsk_gpu_convert_op (self.frame, gsk_gpu_clip_get_shader_clip (&self.clip, &self.offset, &node->bounds), gsk_gpu_node_processor_color_states_explicit (&self, ccs, TRUE), self.opacity, - self.desc, FALSE, &self.offset, &(GskGpuShaderImage) { image, GSK_GPU_SAMPLER_DEFAULT, - descriptor, &node->bounds, &tex_rect }); diff --git a/gsk/gpu/gskgpuopprivate.h b/gsk/gpu/gskgpuopprivate.h index e2687f55e5..395ad596d1 100644 --- a/gsk/gpu/gskgpuopprivate.h +++ b/gsk/gpu/gskgpuopprivate.h @@ -28,11 +28,9 @@ struct _GskGLCommandState GskGpuShaderFlags flags; GskGpuColorStates color_states; guint32 variation; - gsize n_external; } current_program; GskGpuImage *current_images[2]; GskGpuSampler current_samplers[2]; - GskGLDescriptors *desc; }; #ifdef GDK_RENDERING_VULKAN @@ -43,7 +41,6 @@ struct _GskVulkanCommandState VkCommandBuffer vk_command_buffer; GskGpuBlend blend; - GskVulkanDescriptors *desc; GskVulkanSemaphores *semaphores; }; #endif diff --git a/gsk/gpu/gskgpuprint.c b/gsk/gpu/gskgpuprint.c index 0c493010ed..f68afc2288 100644 --- a/gsk/gpu/gskgpuprint.c +++ b/gsk/gpu/gskgpuprint.c @@ -3,7 +3,6 @@ #include "gskgpuprintprivate.h" #include "gskgpucolorstatesprivate.h" -#include "gskgpudescriptorsprivate.h" #include "gskgpuimageprivate.h" #include "gskgpushaderflagsprivate.h" @@ -167,12 +166,3 @@ gsk_gpu_print_image (GString *string, gdk_memory_format_get_name (gsk_gpu_image_get_format (image))); } -void -gsk_gpu_print_image_descriptor (GString *string, - GskGpuDescriptors *desc, - guint32 descriptor) -{ - gsize id = gsk_gpu_descriptors_find_image (desc, descriptor); - gsk_gpu_print_image (string, gsk_gpu_descriptors_get_image (desc, id)); -} - diff --git a/gsk/gpu/gskgpuprintprivate.h b/gsk/gpu/gskgpuprintprivate.h index 9f77b5adb1..c8359d0b47 100644 --- a/gsk/gpu/gskgpuprintprivate.h +++ b/gsk/gpu/gskgpuprintprivate.h @@ -34,6 +34,3 @@ void gsk_gpu_print_rgba (GString const float rgba[4]); void gsk_gpu_print_image (GString *string, GskGpuImage *image); -void gsk_gpu_print_image_descriptor (GString *string, - GskGpuDescriptors *desc, - guint32 descriptor); diff --git a/gsk/gpu/gskgpuradialgradientop.c b/gsk/gpu/gskgpuradialgradientop.c index c36892d4cc..3832844d36 100644 --- a/gsk/gpu/gskgpuradialgradientop.c +++ b/gsk/gpu/gskgpuradialgradientop.c @@ -81,7 +81,6 @@ gsk_gpu_radial_gradient_op (GskGpuFrame *frame, clip, NULL, NULL, - NULL, &instance); gsk_gpu_rect_to_float (rect, offset, instance->rect); diff --git a/gsk/gpu/gskgpurenderpassop.c b/gsk/gpu/gskgpurenderpassop.c index ef5b54c2eb..8965ed3a83 100644 --- a/gsk/gpu/gskgpurenderpassop.c +++ b/gsk/gpu/gskgpurenderpassop.c @@ -11,7 +11,6 @@ #include "gskrendernodeprivate.h" #ifdef GDK_RENDERING_VULKAN #include "gskvulkanimageprivate.h" -#include "gskvulkandescriptorsprivate.h" #endif typedef struct _GskGpuRenderPassOp GskGpuRenderPassOp; @@ -72,6 +71,7 @@ static void gsk_gpu_render_pass_op_do_barriers (GskGpuRenderPassOp *self, GskVulkanCommandState *state) { +#if 0 GskGpuShaderOp *shader; GskGpuOp *op; GskGpuDescriptors *desc = NULL; @@ -99,6 +99,7 @@ gsk_gpu_render_pass_op_do_barriers (GskGpuRenderPassOp *self, if (desc == NULL) gsk_vulkan_descriptors_transition (state->desc, state->semaphores, state->vk_command_buffer); +#endif } static GskGpuOp * diff --git a/gsk/gpu/gskgpuroundedcolorop.c b/gsk/gpu/gskgpuroundedcolorop.c index d1b930b853..46090c2945 100644 --- a/gsk/gpu/gskgpuroundedcolorop.c +++ b/gsk/gpu/gskgpuroundedcolorop.c @@ -66,7 +66,6 @@ gsk_gpu_rounded_color_op (GskGpuFrame *frame, clip, NULL, NULL, - NULL, &instance); gsk_rounded_rect_to_float (outline, offset, instance->outline); diff --git a/gsk/gpu/gskgpushaderop.c b/gsk/gpu/gskgpushaderop.c index ee016ba0bc..bbd2c373d3 100644 --- a/gsk/gpu/gskgpushaderop.c +++ b/gsk/gpu/gskgpushaderop.c @@ -5,12 +5,10 @@ #include "gskgpuframeprivate.h" #include "gskgpuprintprivate.h" #include "gskgpushaderflagsprivate.h" -#include "gskgldescriptorsprivate.h" #include "gskgldeviceprivate.h" #include "gskglframeprivate.h" #include "gskglimageprivate.h" #ifdef GDK_RENDERING_VULKAN -#include "gskvulkandescriptorsprivate.h" #include "gskvulkandeviceprivate.h" #endif @@ -27,7 +25,6 @@ gsk_gpu_shader_op_finish (GskGpuOp *op) { GskGpuShaderOp *self = (GskGpuShaderOp *) op; - g_clear_object (&self->desc); g_clear_object (&self->images[0]); g_clear_object (&self->images[1]); } @@ -70,9 +67,9 @@ gsk_gpu_shader_op_vk_command_n (GskGpuOp *op, GskVulkanCommandState *state, gsize instance_scale) { +#if 0 GskGpuShaderOp *self = (GskGpuShaderOp *) op; GskGpuShaderOpClass *shader_op_class = (GskGpuShaderOpClass *) op->op_class; - GskVulkanDescriptors *desc; GskGpuOp *next; gsize i, n_ops, max_ops_per_draw; @@ -126,6 +123,8 @@ gsk_gpu_shader_op_vk_command_n (GskGpuOp *op, } return next; +#endif + return NULL; } GskGpuOp * @@ -145,33 +144,23 @@ gsk_gpu_shader_op_gl_command_n (GskGpuOp *op, { GskGpuShaderOp *self = (GskGpuShaderOp *) op; GskGpuShaderOpClass *shader_op_class = (GskGpuShaderOpClass *) op->op_class; - GskGLDescriptors *desc; GskGpuOp *next; - gsize i, n_ops, n_external, max_ops_per_draw; - - desc = GSK_GL_DESCRIPTORS (self->desc); - if (desc) - n_external = gsk_gl_descriptors_get_n_external (desc); - else - n_external = 0; + gsize i, n_ops, max_ops_per_draw; if (state->current_program.op_class != op->op_class || state->current_program.color_states != self->color_states || state->current_program.variation != self->variation || - state->current_program.flags != self->flags || - state->current_program.n_external != n_external) + state->current_program.flags != self->flags) { state->current_program.op_class = op->op_class; state->current_program.flags = self->flags; state->current_program.color_states = self->color_states; state->current_program.variation = self->variation; - state->current_program.n_external = n_external; gsk_gl_frame_use_program (GSK_GL_FRAME (frame), shader_op_class, self->flags, self->color_states, - self->variation, - n_external); + self->variation); } for (i = 0; i < shader_op_class->n_textures; i++) @@ -201,7 +190,6 @@ gsk_gpu_shader_op_gl_command_n (GskGpuOp *op, GskGpuShaderOp *next_shader = (GskGpuShaderOp *) next; if (next->op_class != op->op_class || - next_shader->desc != self->desc || next_shader->flags != self->flags || next_shader->color_states != self->color_states || next_shader->variation != self->variation || @@ -252,7 +240,6 @@ gsk_gpu_shader_op_alloc (GskGpuFrame *frame, GskGpuColorStates color_states, guint32 variation, GskGpuShaderClip clip, - GskGpuDescriptors *desc, GskGpuImage **images, GskGpuSampler *samplers, gpointer out_vertex_data) @@ -300,10 +287,6 @@ gsk_gpu_shader_op_alloc (GskGpuFrame *frame, self->color_states = color_states; self->variation = variation; self->vertex_offset = vertex_offset; - if (desc) - self->desc = g_object_ref (desc); - else - self->desc = NULL; self->n_ops = 1; for (i = 0; i < op_class->n_textures; i++) { diff --git a/gsk/gpu/gskgpushaderopprivate.h b/gsk/gpu/gskgpushaderopprivate.h index 2f073e2cad..87adc73532 100644 --- a/gsk/gpu/gskgpushaderopprivate.h +++ b/gsk/gpu/gskgpushaderopprivate.h @@ -13,7 +13,6 @@ struct _GskGpuShaderImage { GskGpuImage *image; /* image to draw */ GskGpuSampler sampler; /* sampler to use for image */ - guint32 descriptor; /* FIXME: preallocated descriptor for image + sampler */ const graphene_rect_t *coverage; /* the clip area for the image or NULL for unclipped */ const graphene_rect_t *bounds; /* bounds for the image */ }; @@ -22,7 +21,6 @@ struct _GskGpuShaderOp { GskGpuOp parent_op; - GskGpuDescriptors *desc; GskGpuImage *images[2]; GskGpuSampler samplers[2]; GskGpuShaderFlags flags; @@ -54,7 +52,6 @@ void gsk_gpu_shader_op_alloc (GskGpuF GskGpuColorStates color_states, guint32 variation, GskGpuShaderClip clip, - GskGpuDescriptors *desc, GskGpuImage **images, GskGpuSampler *samplers, gpointer out_vertex_data); diff --git a/gsk/gpu/gskgputextureop.c b/gsk/gpu/gskgputextureop.c index 8d12aa0165..ed5db59e77 100644 --- a/gsk/gpu/gskgputextureop.c +++ b/gsk/gpu/gskgputextureop.c @@ -51,7 +51,6 @@ static const GskGpuShaderOpClass GSK_GPU_TEXTURE_OP_CLASS = { void gsk_gpu_texture_op (GskGpuFrame *frame, GskGpuShaderClip clip, - GskGpuDescriptors *desc, const graphene_point_t *offset, const GskGpuShaderImage *image) { @@ -62,7 +61,6 @@ gsk_gpu_texture_op (GskGpuFrame *frame, gsk_gpu_color_states_create_equal (TRUE, TRUE), 0, clip, - desc, (GskGpuImage *[1]) { image->image }, (GskGpuSampler[1]) { image->sampler }, &instance); diff --git a/gsk/gpu/gskgputextureopprivate.h b/gsk/gpu/gskgputextureopprivate.h index bb58628f2b..d6b4e7cf49 100644 --- a/gsk/gpu/gskgputextureopprivate.h +++ b/gsk/gpu/gskgputextureopprivate.h @@ -8,7 +8,6 @@ G_BEGIN_DECLS void gsk_gpu_texture_op (GskGpuFrame *frame, GskGpuShaderClip clip, - GskGpuDescriptors *desc, const graphene_point_t *offset, const GskGpuShaderImage *image); diff --git a/gsk/gpu/gskgputypesprivate.h b/gsk/gpu/gskgputypesprivate.h index 3ad278367f..9c9751cdcb 100644 --- a/gsk/gpu/gskgputypesprivate.h +++ b/gsk/gpu/gskgputypesprivate.h @@ -5,11 +5,9 @@ #include "gdk/gdkmemoryformatprivate.h" -typedef struct _GskGLDescriptors GskGLDescriptors; typedef struct _GskGpuBuffer GskGpuBuffer; typedef struct _GskGpuCache GskGpuCache; typedef guint32 GskGpuColorStates; -typedef struct _GskGpuDescriptors GskGpuDescriptors; typedef struct _GskGpuDevice GskGpuDevice; typedef struct _GskGpuFrame GskGpuFrame; typedef struct _GskGpuImage GskGpuImage; @@ -19,7 +17,6 @@ typedef guint32 GskGpuShaderFlags; typedef struct _GskGpuShaderImage GskGpuShaderImage; typedef struct _GskGpuShaderOp GskGpuShaderOp; typedef struct _GskGpuShaderOpClass GskGpuShaderOpClass; -typedef struct _GskVulkanDescriptors GskVulkanDescriptors; typedef struct _GskVulkanSemaphores GskVulkanSemaphores; typedef enum { diff --git a/gsk/gpu/gskvulkandescriptors.c b/gsk/gpu/gskvulkandescriptors.c deleted file mode 100644 index 4aca1ce356..0000000000 --- a/gsk/gpu/gskvulkandescriptors.c +++ /dev/null @@ -1,51 +0,0 @@ -#include "config.h" - -#include "gskvulkandescriptorsprivate.h" - -#include "gskvulkanframeprivate.h" -#include "gskvulkanimageprivate.h" - -G_DEFINE_TYPE (GskVulkanDescriptors, gsk_vulkan_descriptors, GSK_TYPE_GPU_DESCRIPTORS) - -static void -gsk_vulkan_descriptors_class_init (GskVulkanDescriptorsClass *klass) -{ -} - -static void -gsk_vulkan_descriptors_init (GskVulkanDescriptors *self) -{ -} - -GskVulkanPipelineLayout * -gsk_vulkan_descriptors_get_pipeline_layout (GskVulkanDescriptors *self) -{ - return GSK_VULKAN_DESCRIPTORS_GET_CLASS (self)->get_pipeline_layout (self); -} - -void -gsk_vulkan_descriptors_transition (GskVulkanDescriptors *self, - GskVulkanSemaphores *semaphores, - VkCommandBuffer vk_command_buffer) -{ - GskGpuDescriptors *desc = GSK_GPU_DESCRIPTORS (self); - gsize i; - - for (i = 0; i < gsk_gpu_descriptors_get_n_images (desc); i++) - { - gsk_vulkan_image_transition (GSK_VULKAN_IMAGE (gsk_gpu_descriptors_get_image (desc, i)), - semaphores, - vk_command_buffer, - VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, - VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, - VK_ACCESS_SHADER_READ_BIT); - } -} - -void -gsk_vulkan_descriptors_bind (GskVulkanDescriptors *self, - GskVulkanDescriptors *previous, - VkCommandBuffer vk_command_buffer) -{ - GSK_VULKAN_DESCRIPTORS_GET_CLASS (self)->bind (self, previous, vk_command_buffer); -} diff --git a/gsk/gpu/gskvulkandescriptorsprivate.h b/gsk/gpu/gskvulkandescriptorsprivate.h deleted file mode 100644 index fb8aef1b3f..0000000000 --- a/gsk/gpu/gskvulkandescriptorsprivate.h +++ /dev/null @@ -1,47 +0,0 @@ -#pragma once - -#include "gskgpudescriptorsprivate.h" - -#include "gskvulkandeviceprivate.h" - -G_BEGIN_DECLS - -#define GSK_TYPE_VULKAN_DESCRIPTORS (gsk_vulkan_descriptors_get_type ()) -#define GSK_VULKAN_DESCRIPTORS(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), GSK_TYPE_VULKAN_DESCRIPTORS, GskVulkanDescriptors)) -#define GSK_VULKAN_DESCRIPTORS_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), GSK_TYPE_VULKAN_DESCRIPTORS, GskVulkanDescriptorsClass)) -#define GSK_IS_VULKAN_DESCRIPTORS(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), GSK_TYPE_VULKAN_DESCRIPTORS)) -#define GSK_IS_VULKAN_DESCRIPTORS_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), GSK_TYPE_VULKAN_DESCRIPTORS)) -#define GSK_VULKAN_DESCRIPTORS_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GSK_TYPE_VULKAN_DESCRIPTORS, GskVulkanDescriptorsClass)) - -typedef struct _GskVulkanDescriptorsClass GskVulkanDescriptorsClass; - -struct _GskVulkanDescriptors -{ - GskGpuDescriptors parent_instance; -}; - -struct _GskVulkanDescriptorsClass -{ - GskGpuDescriptorsClass parent_class; - - GskVulkanPipelineLayout * (* get_pipeline_layout) (GskVulkanDescriptors *self); - void (* bind) (GskVulkanDescriptors *self, - GskVulkanDescriptors *previous, - VkCommandBuffer vk_command_buffer); -}; - -GType gsk_vulkan_descriptors_get_type (void) G_GNUC_CONST; - -GskVulkanPipelineLayout * gsk_vulkan_descriptors_get_pipeline_layout (GskVulkanDescriptors *self); - -void gsk_vulkan_descriptors_transition (GskVulkanDescriptors *self, - GskVulkanSemaphores *semaphores, - VkCommandBuffer vk_command_buffer); -void gsk_vulkan_descriptors_bind (GskVulkanDescriptors *self, - GskVulkanDescriptors *previous, - VkCommandBuffer vk_command_buffer); - -G_DEFINE_AUTOPTR_CLEANUP_FUNC(GskVulkanDescriptors, g_object_unref) - -G_END_DECLS - diff --git a/gsk/gpu/gskvulkanframe.c b/gsk/gpu/gskvulkanframe.c index 20bf03a647..3b5f138703 100644 --- a/gsk/gpu/gskvulkanframe.c +++ b/gsk/gpu/gskvulkanframe.c @@ -4,23 +4,13 @@ #include "gskgpuopprivate.h" #include "gskvulkanbufferprivate.h" -#include "gskvulkandescriptorsprivate.h" #include "gskvulkandeviceprivate.h" #include "gskvulkanimageprivate.h" -#include "gskvulkanrealdescriptorsprivate.h" -#include "gskvulkansubdescriptorsprivate.h" #include "gdk/gdkdmabuftextureprivate.h" #include "gdk/gdkglcontextprivate.h" #include "gdk/gdkgltextureprivate.h" -#define GDK_ARRAY_NAME gsk_descriptors -#define GDK_ARRAY_TYPE_NAME GskDescriptors -#define GDK_ARRAY_ELEMENT_TYPE GskVulkanRealDescriptors * -#define GDK_ARRAY_FREE_FUNC g_object_unref -#define GDK_ARRAY_NO_MEMSET 1 -#include "gdk/gdkarrayimpl.c" - #define GDK_ARRAY_NAME gsk_semaphores #define GDK_ARRAY_TYPE_NAME GskSemaphores #define GDK_ARRAY_ELEMENT_TYPE VkSemaphore @@ -51,8 +41,6 @@ struct _GskVulkanFrame VkCommandBuffer vk_command_buffer; VkDescriptorPool vk_descriptor_pool; - GskDescriptors descriptors; - gsize pool_n_sets; gsize pool_n_images; gsize pool_n_buffers; @@ -158,8 +146,6 @@ gsk_vulkan_frame_cleanup (GskGpuFrame *frame) 0); } - gsk_descriptors_set_size (&self->descriptors, 0); - GSK_GPU_FRAME_CLASS (gsk_vulkan_frame_parent_class)->cleanup (frame); } @@ -240,6 +226,7 @@ gsk_vulkan_frame_upload_texture (GskGpuFrame *frame, static void gsk_vulkan_frame_prepare_descriptors (GskVulkanFrame *self) { +#if 0 GskVulkanDevice *device; VkDevice vk_device; gsize i, n_images, n_sets; @@ -302,43 +289,7 @@ gsk_vulkan_frame_prepare_descriptors (GskVulkanFrame *self) gsk_vulkan_real_descriptors_update_sets (desc, self->vk_descriptor_pool); } -} - -static GskGpuDescriptors * -gsk_vulkan_frame_create_descriptors (GskGpuFrame *frame) -{ - GskVulkanFrame *self = GSK_VULKAN_FRAME (frame); - - if (gsk_vulkan_device_has_feature (GSK_VULKAN_DEVICE (gsk_gpu_frame_get_device (frame)), GDK_VULKAN_FEATURE_DESCRIPTOR_INDEXING)) - { - GskVulkanRealDescriptors *parent; - - if (gsk_descriptors_get_size (&self->descriptors) > 0) - { - parent = gsk_descriptors_get (&self->descriptors, gsk_descriptors_get_size (&self->descriptors) - 1); - if (gsk_vulkan_real_descriptors_is_full (parent)) - parent = NULL; - } - else - parent = NULL; - - if (parent == NULL) - { - parent = gsk_vulkan_real_descriptors_new (self); - gsk_descriptors_append (&self->descriptors, parent); - } - - return GSK_GPU_DESCRIPTORS (gsk_vulkan_sub_descriptors_new (GSK_VULKAN_DESCRIPTORS (parent))); - } - else - { - GskVulkanRealDescriptors *desc; - - desc = gsk_vulkan_real_descriptors_new (self); - gsk_descriptors_append (&self->descriptors, desc); - - return GSK_GPU_DESCRIPTORS (g_object_ref (desc)); - } +#endif } static GskGpuBuffer * @@ -374,8 +325,10 @@ gsk_vulkan_frame_submit (GskGpuFrame *frame, GskVulkanSemaphores semaphores; GskVulkanCommandState state; +#if 0 if (gsk_descriptors_get_size (&self->descriptors) == 0) gsk_descriptors_append (&self->descriptors, gsk_vulkan_real_descriptors_new (self)); +#endif gsk_vulkan_frame_prepare_descriptors (self); @@ -409,13 +362,8 @@ gsk_vulkan_frame_submit (GskGpuFrame *frame, state.vk_render_pass = VK_NULL_HANDLE; state.vk_format = VK_FORMAT_UNDEFINED; state.blend = GSK_GPU_BLEND_OVER; /* should we have a BLEND_NONE? */ - state.desc = GSK_VULKAN_DESCRIPTORS (gsk_descriptors_get (&self->descriptors, 0)); state.semaphores = &semaphores; - gsk_vulkan_descriptors_bind (GSK_VULKAN_DESCRIPTORS (gsk_descriptors_get (&self->descriptors, 0)), - NULL, - state.vk_command_buffer); - while (op) { op = gsk_gpu_op_vk_command (op, frame, &state); @@ -460,7 +408,6 @@ gsk_vulkan_frame_finalize (GObject *object) self->vk_descriptor_pool, NULL); } - gsk_descriptors_clear (&self->descriptors); vkFreeCommandBuffers (vk_device, vk_command_pool, @@ -487,7 +434,6 @@ gsk_vulkan_frame_class_init (GskVulkanFrameClass *klass) gpu_frame_class->cleanup = gsk_vulkan_frame_cleanup; gpu_frame_class->begin = gsk_vulkan_frame_begin; gpu_frame_class->upload_texture = gsk_vulkan_frame_upload_texture; - gpu_frame_class->create_descriptors = gsk_vulkan_frame_create_descriptors; gpu_frame_class->create_vertex_buffer = gsk_vulkan_frame_create_vertex_buffer; gpu_frame_class->create_storage_buffer = gsk_vulkan_frame_create_storage_buffer; gpu_frame_class->write_texture_vertex_data = gsk_vulkan_frame_write_texture_vertex_data; @@ -499,8 +445,6 @@ gsk_vulkan_frame_class_init (GskVulkanFrameClass *klass) static void gsk_vulkan_frame_init (GskVulkanFrame *self) { - gsk_descriptors_init (&self->descriptors); - self->pool_n_sets = 4; self->pool_n_images = 8; self->pool_n_buffers = 8; diff --git a/gsk/gpu/gskvulkanrealdescriptors.c b/gsk/gpu/gskvulkanrealdescriptors.c deleted file mode 100644 index fa6657e884..0000000000 --- a/gsk/gpu/gskvulkanrealdescriptors.c +++ /dev/null @@ -1,308 +0,0 @@ -#include "config.h" - -#include "gskvulkanrealdescriptorsprivate.h" - -#include "gskgpucacheprivate.h" -#include "gskvulkanframeprivate.h" -#include "gskvulkanimageprivate.h" - -#define GDK_ARRAY_NAME gsk_descriptor_image_infos -#define GDK_ARRAY_TYPE_NAME GskDescriptorImageInfos -#define GDK_ARRAY_ELEMENT_TYPE VkDescriptorImageInfo -#define GDK_ARRAY_BY_VALUE 1 -#define GDK_ARRAY_PREALLOC 128 -#define GDK_ARRAY_NO_MEMSET 1 -#include "gdk/gdkarrayimpl.c" - -#define GDK_ARRAY_NAME gsk_samplers -#define GDK_ARRAY_TYPE_NAME GskSamplers -#define GDK_ARRAY_ELEMENT_TYPE VkSampler -#define GDK_ARRAY_PREALLOC 32 -#define GDK_ARRAY_NO_MEMSET 1 -#include "gdk/gdkarrayimpl.c" - -struct _GskVulkanRealDescriptors -{ - GskVulkanDescriptors parent_instance; - - GskVulkanFrame *frame; /* no reference, the frame owns us */ - - GskVulkanPipelineLayout *pipeline_layout; - - GskSamplers immutable_samplers; - GskDescriptorImageInfos descriptor_immutable_images; - GskDescriptorImageInfos descriptor_images; - - VkDescriptorSet descriptor_sets[GSK_VULKAN_N_DESCRIPTOR_SETS]; -}; - -G_DEFINE_TYPE (GskVulkanRealDescriptors, gsk_vulkan_real_descriptors, GSK_TYPE_VULKAN_DESCRIPTORS) - -static GskVulkanPipelineLayout * -gsk_vulkan_real_descriptors_get_pipeline_layout (GskVulkanDescriptors *desc) -{ - GskVulkanRealDescriptors *self = GSK_VULKAN_REAL_DESCRIPTORS (desc); - - return self->pipeline_layout; -} - -static void -gsk_vulkan_real_descriptors_bind (GskVulkanDescriptors *desc, - GskVulkanDescriptors *previous, - VkCommandBuffer vk_command_buffer) -{ - GskVulkanRealDescriptors *self = GSK_VULKAN_REAL_DESCRIPTORS (desc); - - if (desc == previous) - return; - - vkCmdBindDescriptorSets (vk_command_buffer, - VK_PIPELINE_BIND_POINT_GRAPHICS, - gsk_vulkan_device_get_vk_pipeline_layout (GSK_VULKAN_DEVICE (gsk_gpu_frame_get_device (GSK_GPU_FRAME (self->frame))), - self->pipeline_layout), - 0, - G_N_ELEMENTS (self->descriptor_sets), - self->descriptor_sets, - 0, - NULL); -} - -static gboolean -gsk_vulkan_real_descriptors_add_image (GskGpuDescriptors *desc, - GskGpuImage *image, - GskGpuSampler sampler, - guint32 *out_descriptor) -{ - GskVulkanRealDescriptors *self = GSK_VULKAN_REAL_DESCRIPTORS (desc); - GskVulkanImage *vulkan_image = GSK_VULKAN_IMAGE (image); - GskVulkanDevice *device = GSK_VULKAN_DEVICE (gsk_gpu_frame_get_device (GSK_GPU_FRAME (self->frame))); - VkSampler vk_sampler; - guint32 result; - - vk_sampler = gsk_vulkan_image_get_vk_sampler (vulkan_image); - - if (vk_sampler) - { - if (gsk_descriptor_image_infos_get_size (&self->descriptor_immutable_images) >= - gsk_vulkan_device_get_max_immutable_samplers (device)) - return FALSE; - if ((1 + gsk_descriptor_image_infos_get_size (&self->descriptor_immutable_images)) * 3 + - gsk_descriptor_image_infos_get_size (&self->descriptor_images) > - gsk_vulkan_device_get_max_samplers (device)) - return FALSE; - - result = gsk_descriptor_image_infos_get_size (&self->descriptor_immutable_images) << 1 | 1; - - gsk_samplers_append (&self->immutable_samplers, vk_sampler); - gsk_descriptor_image_infos_append (&self->descriptor_immutable_images, - &(VkDescriptorImageInfo) { - .imageView = gsk_vulkan_image_get_vk_image_view (vulkan_image), - .imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL - }); - } - else - { - if (MAX (1, gsk_descriptor_image_infos_get_size (&self->descriptor_immutable_images) * 3) + - gsk_descriptor_image_infos_get_size (&self->descriptor_images) >= - gsk_vulkan_device_get_max_samplers (device)) - return FALSE; - - result = gsk_descriptor_image_infos_get_size (&self->descriptor_images) << 1; - - gsk_descriptor_image_infos_append (&self->descriptor_images, - &(VkDescriptorImageInfo) { - .sampler = gsk_vulkan_device_get_vk_sampler (device, sampler), - .imageView = gsk_vulkan_image_get_vk_image_view (vulkan_image), - .imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL - }); - } - - *out_descriptor = result; - return TRUE; -} - -static void -gsk_vulkan_real_descriptors_finalize (GObject *object) -{ - GskVulkanRealDescriptors *self = GSK_VULKAN_REAL_DESCRIPTORS (object); - - gsk_samplers_clear (&self->immutable_samplers); - gsk_descriptor_image_infos_clear (&self->descriptor_immutable_images); - gsk_descriptor_image_infos_clear (&self->descriptor_images); - - gsk_vulkan_device_release_pipeline_layout (GSK_VULKAN_DEVICE (gsk_gpu_frame_get_device (GSK_GPU_FRAME (self->frame))), - self->pipeline_layout); - - G_OBJECT_CLASS (gsk_vulkan_real_descriptors_parent_class)->finalize (object); -} - -static void -gsk_vulkan_real_descriptors_class_init (GskVulkanRealDescriptorsClass *klass) -{ - GskVulkanDescriptorsClass *vulkan_descriptors_class = GSK_VULKAN_DESCRIPTORS_CLASS (klass); - GskGpuDescriptorsClass *descriptors_class = GSK_GPU_DESCRIPTORS_CLASS (klass); - GObjectClass *object_class = G_OBJECT_CLASS (klass); - - object_class->finalize = gsk_vulkan_real_descriptors_finalize; - - descriptors_class->add_image = gsk_vulkan_real_descriptors_add_image; - - vulkan_descriptors_class->get_pipeline_layout = gsk_vulkan_real_descriptors_get_pipeline_layout; - vulkan_descriptors_class->bind = gsk_vulkan_real_descriptors_bind; -} - -static void -gsk_vulkan_real_descriptors_init (GskVulkanRealDescriptors *self) -{ - gsk_samplers_init (&self->immutable_samplers); - gsk_descriptor_image_infos_init (&self->descriptor_immutable_images); - gsk_descriptor_image_infos_init (&self->descriptor_images); -} - -GskVulkanRealDescriptors * -gsk_vulkan_real_descriptors_new (GskVulkanFrame *frame) -{ - GskVulkanRealDescriptors *self; - - self = g_object_new (GSK_TYPE_VULKAN_REAL_DESCRIPTORS, NULL); - - self->frame = frame; - - return self; -} - -gboolean -gsk_vulkan_real_descriptors_is_full (GskVulkanRealDescriptors *self) -{ - GskVulkanDevice *device = GSK_VULKAN_DEVICE (gsk_gpu_frame_get_device (GSK_GPU_FRAME (self->frame))); - - return gsk_descriptor_image_infos_get_size (&self->descriptor_immutable_images) >= gsk_vulkan_device_get_max_immutable_samplers (device) || - gsk_descriptor_image_infos_get_size (&self->descriptor_images) + - MAX (1, gsk_descriptor_image_infos_get_size (&self->descriptor_immutable_images) * 3) >= - gsk_vulkan_device_get_max_samplers (device); -} - -static void -gsk_vulkan_real_descriptors_fill_sets (GskVulkanRealDescriptors *self) -{ - gsize n_immutable_samplers, n_samplers, n_buffers; - GskVulkanDevice *device; - - device = GSK_VULKAN_DEVICE (gsk_gpu_frame_get_device (GSK_GPU_FRAME (self->frame))); - - if (gsk_vulkan_device_has_feature (device, GDK_VULKAN_FEATURE_DESCRIPTOR_INDEXING)) - return; - - /* If descriptor indexing isn't supported, all descriptors in the shaders - * must be properly setup. And that means we need to have - * descriptors for all of them. - */ - gsk_vulkan_device_get_pipeline_sizes (device, - self->pipeline_layout, - &n_immutable_samplers, - &n_samplers, - &n_buffers); - - if (gsk_descriptor_image_infos_get_size (&self->descriptor_images) == 0) - { - /* We have no image, find any random image and attach it */ - guint32 ignored; - - if (!gsk_gpu_descriptors_add_image (GSK_GPU_DESCRIPTORS (self), - gsk_gpu_cache_get_atlas_image (gsk_gpu_device_get_cache (GSK_GPU_DEVICE (device))), - GSK_GPU_SAMPLER_DEFAULT, - &ignored)) - { - g_assert_not_reached (); - } - } - while (MAX (1, n_immutable_samplers) > gsk_descriptor_image_infos_get_size (&self->descriptor_immutable_images)) - { - gsk_descriptor_image_infos_append (&self->descriptor_immutable_images, gsk_descriptor_image_infos_get (&self->descriptor_images, 0)); - } - while (n_samplers - MAX (1, 3 * n_immutable_samplers) > gsk_descriptor_image_infos_get_size (&self->descriptor_images)) - { - gsk_descriptor_image_infos_append (&self->descriptor_images, gsk_descriptor_image_infos_get (&self->descriptor_images, 0)); - } -} - -void -gsk_vulkan_real_descriptors_prepare (GskVulkanRealDescriptors *self, - gsize *n_images) -{ - self->pipeline_layout = gsk_vulkan_device_acquire_pipeline_layout (GSK_VULKAN_DEVICE (gsk_gpu_frame_get_device (GSK_GPU_FRAME (self->frame))), - gsk_samplers_get_data (&self->immutable_samplers), - gsk_samplers_get_size (&self->immutable_samplers), - gsk_descriptor_image_infos_get_size (&self->descriptor_images), - 0); - gsk_vulkan_real_descriptors_fill_sets (self); - - *n_images = MAX (1, gsk_descriptor_image_infos_get_size (&self->descriptor_immutable_images)) + - gsk_descriptor_image_infos_get_size (&self->descriptor_images); -} - -void -gsk_vulkan_real_descriptors_update_sets (GskVulkanRealDescriptors *self, - VkDescriptorPool vk_descriptor_pool) -{ - VkWriteDescriptorSet write_descriptor_sets[GSK_VULKAN_N_DESCRIPTOR_SETS + 1]; - gsize n_descriptor_sets; - VkDevice vk_device; - gboolean descriptor_indexing; - GskVulkanDevice *device; - - device = GSK_VULKAN_DEVICE (gsk_gpu_frame_get_device (GSK_GPU_FRAME (self->frame))); - descriptor_indexing = gsk_vulkan_device_has_feature (device, GDK_VULKAN_FEATURE_DESCRIPTOR_INDEXING); - vk_device = gsk_vulkan_device_get_vk_device (device); - - GSK_VK_CHECK (vkAllocateDescriptorSets, vk_device, - &(VkDescriptorSetAllocateInfo) { - .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO, - .descriptorPool = vk_descriptor_pool, - .descriptorSetCount = GSK_VULKAN_N_DESCRIPTOR_SETS, - .pSetLayouts = (VkDescriptorSetLayout[GSK_VULKAN_N_DESCRIPTOR_SETS]) { - gsk_vulkan_device_get_vk_image_set_layout (device, self->pipeline_layout), - gsk_vulkan_device_get_vk_buffer_set_layout (device, self->pipeline_layout), - }, - .pNext = !descriptor_indexing ? NULL : &(VkDescriptorSetVariableDescriptorCountAllocateInfo) { - .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO, - .descriptorSetCount = GSK_VULKAN_N_DESCRIPTOR_SETS, - .pDescriptorCounts = (uint32_t[GSK_VULKAN_N_DESCRIPTOR_SETS]) { - gsk_descriptor_image_infos_get_size (&self->descriptor_images), - 0, - } - } - }, - self->descriptor_sets); - - n_descriptor_sets = 0; - if (gsk_descriptor_image_infos_get_size (&self->descriptor_immutable_images) > 0) - { - write_descriptor_sets[n_descriptor_sets++] = (VkWriteDescriptorSet) { - .sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, - .dstSet = self->descriptor_sets[GSK_VULKAN_IMAGE_SET_LAYOUT], - .dstBinding = 0, - .dstArrayElement = 0, - .descriptorCount = gsk_descriptor_image_infos_get_size (&self->descriptor_immutable_images), - .descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, - .pImageInfo = gsk_descriptor_image_infos_get_data (&self->descriptor_immutable_images) - }; - } - if (gsk_descriptor_image_infos_get_size (&self->descriptor_images) > 0) - { - write_descriptor_sets[n_descriptor_sets++] = (VkWriteDescriptorSet) { - .sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, - .dstSet = self->descriptor_sets[GSK_VULKAN_IMAGE_SET_LAYOUT], - .dstBinding = 1, - .dstArrayElement = 0, - .descriptorCount = gsk_descriptor_image_infos_get_size (&self->descriptor_images), - .descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, - .pImageInfo = gsk_descriptor_image_infos_get_data (&self->descriptor_images) - }; - } - - vkUpdateDescriptorSets (vk_device, - n_descriptor_sets, - write_descriptor_sets, - 0, NULL); -} diff --git a/gsk/gpu/gskvulkanrealdescriptorsprivate.h b/gsk/gpu/gskvulkanrealdescriptorsprivate.h deleted file mode 100644 index 7f0d6c16d1..0000000000 --- a/gsk/gpu/gskvulkanrealdescriptorsprivate.h +++ /dev/null @@ -1,22 +0,0 @@ -#pragma once - -#include "gskvulkandescriptorsprivate.h" -#include "gskvulkanframeprivate.h" - -G_BEGIN_DECLS - -#define GSK_TYPE_VULKAN_REAL_DESCRIPTORS (gsk_vulkan_real_descriptors_get_type ()) - -G_DECLARE_FINAL_TYPE (GskVulkanRealDescriptors, gsk_vulkan_real_descriptors, GSK, VULKAN_REAL_DESCRIPTORS, GskVulkanDescriptors) - -GskVulkanRealDescriptors * gsk_vulkan_real_descriptors_new (GskVulkanFrame *frame); - -gboolean gsk_vulkan_real_descriptors_is_full (GskVulkanRealDescriptors *self); - -void gsk_vulkan_real_descriptors_prepare (GskVulkanRealDescriptors *self, - gsize *n_images); -void gsk_vulkan_real_descriptors_update_sets (GskVulkanRealDescriptors *self, - VkDescriptorPool vk_descriptor_pool); - -G_END_DECLS - diff --git a/gsk/gpu/gskvulkansubdescriptors.c b/gsk/gpu/gskvulkansubdescriptors.c deleted file mode 100644 index b9e8420591..0000000000 --- a/gsk/gpu/gskvulkansubdescriptors.c +++ /dev/null @@ -1,93 +0,0 @@ -#include "config.h" - -#include "gskvulkansubdescriptorsprivate.h" - -struct _GskVulkanSubDescriptors -{ - GskVulkanDescriptors parent_instance; - - GskVulkanDescriptors *parent; -}; - -G_DEFINE_TYPE (GskVulkanSubDescriptors, gsk_vulkan_sub_descriptors, GSK_TYPE_VULKAN_DESCRIPTORS) - -static GskVulkanPipelineLayout * -gsk_vulkan_sub_descriptors_get_pipeline_layout (GskVulkanDescriptors *desc) -{ - GskVulkanSubDescriptors *self = GSK_VULKAN_SUB_DESCRIPTORS (desc); - - return gsk_vulkan_descriptors_get_pipeline_layout (self->parent); -} - -static void -gsk_vulkan_sub_descriptors_bind (GskVulkanDescriptors *desc, - GskVulkanDescriptors *previous, - VkCommandBuffer vk_command_buffer) -{ - GskVulkanSubDescriptors *self = GSK_VULKAN_SUB_DESCRIPTORS (desc); - - if (GSK_IS_VULKAN_SUB_DESCRIPTORS (previous)) - previous = GSK_VULKAN_SUB_DESCRIPTORS (previous)->parent; - - if (self->parent == previous) - return; - - gsk_vulkan_descriptors_bind (self->parent, previous, vk_command_buffer); -} - -static gboolean -gsk_vulkan_sub_descriptors_add_image (GskGpuDescriptors *desc, - GskGpuImage *image, - GskGpuSampler sampler, - guint32 *out_descriptor) -{ - GskVulkanSubDescriptors *self = GSK_VULKAN_SUB_DESCRIPTORS (desc); - - return gsk_gpu_descriptors_add_image (GSK_GPU_DESCRIPTORS (self->parent), - image, - sampler, - out_descriptor); -} - -static void -gsk_vulkan_sub_descriptors_finalize (GObject *object) -{ - GskVulkanSubDescriptors *self = GSK_VULKAN_SUB_DESCRIPTORS (object); - - g_object_unref (self->parent); - - G_OBJECT_CLASS (gsk_vulkan_sub_descriptors_parent_class)->finalize (object); -} - -static void -gsk_vulkan_sub_descriptors_class_init (GskVulkanSubDescriptorsClass *klass) -{ - GskVulkanDescriptorsClass *vulkan_descriptors_class = GSK_VULKAN_DESCRIPTORS_CLASS (klass); - GskGpuDescriptorsClass *descriptors_class = GSK_GPU_DESCRIPTORS_CLASS (klass); - GObjectClass *object_class = G_OBJECT_CLASS (klass); - - object_class->finalize = gsk_vulkan_sub_descriptors_finalize; - - descriptors_class->add_image = gsk_vulkan_sub_descriptors_add_image; - - vulkan_descriptors_class->get_pipeline_layout = gsk_vulkan_sub_descriptors_get_pipeline_layout; - vulkan_descriptors_class->bind = gsk_vulkan_sub_descriptors_bind; -} - -static void -gsk_vulkan_sub_descriptors_init (GskVulkanSubDescriptors *self) -{ -} - -GskVulkanSubDescriptors * -gsk_vulkan_sub_descriptors_new (GskVulkanDescriptors *parent) -{ - GskVulkanSubDescriptors *self; - - self = g_object_new (GSK_TYPE_VULKAN_SUB_DESCRIPTORS, NULL); - - self->parent = g_object_ref (parent); - - return self; -} - diff --git a/gsk/gpu/gskvulkansubdescriptorsprivate.h b/gsk/gpu/gskvulkansubdescriptorsprivate.h deleted file mode 100644 index 5b0cc3a643..0000000000 --- a/gsk/gpu/gskvulkansubdescriptorsprivate.h +++ /dev/null @@ -1,14 +0,0 @@ -#pragma once - -#include "gskvulkandescriptorsprivate.h" - -G_BEGIN_DECLS - -#define GSK_TYPE_VULKAN_SUB_DESCRIPTORS (gsk_vulkan_sub_descriptors_get_type ()) - -G_DECLARE_FINAL_TYPE (GskVulkanSubDescriptors, gsk_vulkan_sub_descriptors, GSK, VULKAN_SUB_DESCRIPTORS, GskVulkanDescriptors) - -GskVulkanSubDescriptors * gsk_vulkan_sub_descriptors_new (GskVulkanDescriptors *parent); - -G_END_DECLS - diff --git a/gsk/meson.build b/gsk/meson.build index a7768fbd2a..7f50a73d3a 100644 --- a/gsk/meson.build +++ b/gsk/meson.build @@ -71,7 +71,6 @@ gsk_private_sources = files([ 'gl/fp16.c', 'gpu/gskglbuffer.c', 'gpu/gskgldevice.c', - 'gpu/gskgldescriptors.c', 'gpu/gskglframe.c', 'gpu/gskglimage.c', 'gpu/gskgpublendop.c', @@ -90,7 +89,6 @@ gsk_private_sources = files([ 'gpu/gskgpuconicgradientop.c', 'gpu/gskgpuconvertop.c', 'gpu/gskgpucrossfadeop.c', - 'gpu/gskgpudescriptors.c', 'gpu/gskgpudownloadop.c', 'gpu/gskgpudevice.c', 'gpu/gskgpuframe.c', @@ -161,13 +159,10 @@ gsk_private_vulkan_shader_headers = [] if have_vulkan gsk_private_sources += files([ 'gpu/gskvulkanbuffer.c', - 'gpu/gskvulkandescriptors.c', 'gpu/gskvulkandevice.c', 'gpu/gskvulkanframe.c', 'gpu/gskvulkanimage.c', 'gpu/gskvulkanmemory.c', - 'gpu/gskvulkanrealdescriptors.c', - 'gpu/gskvulkansubdescriptors.c', ]) endif # have_vulkan From 03c34021af62ca2b6f677d11eae54db88bb7aa66 Mon Sep 17 00:00:00 2001 From: Benjamin Otte Date: Sun, 21 Jul 2024 13:56:11 +0200 Subject: [PATCH 18/28] gpu: Completely revamp descriptor set handling Instead of trying to cram all descriptors into one large array and only binding it at the start, we now keep 1 descriptor set per image+sampler combo and just rebind it every time we switch textures. This is the very dumb solution that essentially maps to what GL does, but the performance impact is negligible compared to the complicated dance we were attempting before. --- gsk/gpu/gskgpuglobalsop.c | 3 +- gsk/gpu/gskgpurenderpassop.c | 30 +- gsk/gpu/gskgpushaderop.c | 35 ++- gsk/gpu/gskvulkandevice.c | 463 ++++++++--------------------- gsk/gpu/gskvulkandeviceprivate.h | 37 +-- gsk/gpu/gskvulkanframe.c | 93 +----- gsk/gpu/gskvulkanimage.c | 54 ++++ gsk/gpu/gskvulkanimageprivate.h | 2 + gsk/gpu/shaders/common-vulkan.glsl | 14 +- 9 files changed, 228 insertions(+), 503 deletions(-) diff --git a/gsk/gpu/gskgpuglobalsop.c b/gsk/gpu/gskgpuglobalsop.c index 432f69cf43..e783d5ec02 100644 --- a/gsk/gpu/gskgpuglobalsop.c +++ b/gsk/gpu/gskgpuglobalsop.c @@ -50,8 +50,7 @@ gsk_gpu_globals_op_vk_command (GskGpuOp *op, GskGpuGlobalsOp *self = (GskGpuGlobalsOp *) op; vkCmdPushConstants (state->vk_command_buffer, - NULL, //gsk_vulkan_device_get_vk_pipeline_layout (GSK_VULKAN_DEVICE (gsk_gpu_frame_get_device (frame)), - // gsk_vulkan_descriptors_get_pipeline_layout (state->desc)), + gsk_vulkan_device_get_default_vk_pipeline_layout (GSK_VULKAN_DEVICE (gsk_gpu_frame_get_device (frame))), VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT, 0, sizeof (self->instance), diff --git a/gsk/gpu/gskgpurenderpassop.c b/gsk/gpu/gskgpurenderpassop.c index 8965ed3a83..758b78f7e5 100644 --- a/gsk/gpu/gskgpurenderpassop.c +++ b/gsk/gpu/gskgpurenderpassop.c @@ -71,10 +71,8 @@ static void gsk_gpu_render_pass_op_do_barriers (GskGpuRenderPassOp *self, GskVulkanCommandState *state) { -#if 0 GskGpuShaderOp *shader; GskGpuOp *op; - GskGpuDescriptors *desc = NULL; for (op = ((GskGpuOp *) self)->next; op->op_class->stage != GSK_GPU_STAGE_END_PASS; @@ -85,21 +83,21 @@ gsk_gpu_render_pass_op_do_barriers (GskGpuRenderPassOp *self, shader = (GskGpuShaderOp *) op; - if (shader->desc == NULL || shader->desc == desc) - continue; - - if (desc == NULL) - { - gsk_vulkan_descriptors_bind (GSK_VULKAN_DESCRIPTORS (shader->desc), state->desc, state->vk_command_buffer); - state->desc = GSK_VULKAN_DESCRIPTORS (shader->desc); - } - desc = shader->desc; - gsk_vulkan_descriptors_transition (GSK_VULKAN_DESCRIPTORS (desc), state->semaphores, state->vk_command_buffer); + if (shader->images[0]) + gsk_vulkan_image_transition (GSK_VULKAN_IMAGE (shader->images[0]), + state->semaphores, + state->vk_command_buffer, + VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, + VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, + VK_ACCESS_SHADER_READ_BIT); + if (shader->images[1]) + gsk_vulkan_image_transition (GSK_VULKAN_IMAGE (shader->images[1]), + state->semaphores, + state->vk_command_buffer, + VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, + VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, + VK_ACCESS_SHADER_READ_BIT); } - - if (desc == NULL) - gsk_vulkan_descriptors_transition (state->desc, state->semaphores, state->vk_command_buffer); -#endif } static GskGpuOp * diff --git a/gsk/gpu/gskgpushaderop.c b/gsk/gpu/gskgpushaderop.c index bbd2c373d3..58dbb11ca0 100644 --- a/gsk/gpu/gskgpushaderop.c +++ b/gsk/gpu/gskgpushaderop.c @@ -10,6 +10,7 @@ #include "gskglimageprivate.h" #ifdef GDK_RENDERING_VULKAN #include "gskvulkandeviceprivate.h" +#include "gskvulkanimageprivate.h" #endif #include "gdkglcontextprivate.h" @@ -67,10 +68,10 @@ gsk_gpu_shader_op_vk_command_n (GskGpuOp *op, GskVulkanCommandState *state, gsize instance_scale) { -#if 0 GskGpuShaderOp *self = (GskGpuShaderOp *) op; GskGpuShaderOpClass *shader_op_class = (GskGpuShaderOpClass *) op->op_class; GskGpuOp *next; + VkPipelineLayout vk_pipeline_layout; gsize i, n_ops, max_ops_per_draw; if (gsk_gpu_frame_should_optimize (frame, GSK_GPU_OPTIMIZE_MERGE) && @@ -80,33 +81,43 @@ gsk_gpu_shader_op_vk_command_n (GskGpuOp *op, else max_ops_per_draw = 1; - desc = GSK_VULKAN_DESCRIPTORS (self->desc); - if (desc && state->desc != desc) - { - gsk_vulkan_descriptors_bind (desc, state->desc, state->vk_command_buffer); - state->desc = desc; - } - n_ops = self->n_ops; for (next = op->next; next; next = next->next) { GskGpuShaderOp *next_shader = (GskGpuShaderOp *) next; if (next->op_class != op->op_class || - next_shader->desc != self->desc || next_shader->flags != self->flags || next_shader->color_states != self->color_states || next_shader->variation != self->variation || - next_shader->vertex_offset != self->vertex_offset + n_ops * shader_op_class->vertex_size) + next_shader->vertex_offset != self->vertex_offset + n_ops * shader_op_class->vertex_size || + (shader_op_class->n_textures > 0 && (next_shader->images[0] != self->images[0] || next_shader->samplers[0] != self->samplers[0])) || + (shader_op_class->n_textures > 1 && (next_shader->images[1] != self->images[1] || next_shader->samplers[1] != self->samplers[1]))) break; n_ops += next_shader->n_ops; } + vk_pipeline_layout = gsk_vulkan_device_get_default_vk_pipeline_layout (GSK_VULKAN_DEVICE (gsk_gpu_frame_get_device (frame))); + + for (i = 0; i < shader_op_class->n_textures; i++) + { + vkCmdBindDescriptorSets (state->vk_command_buffer, + VK_PIPELINE_BIND_POINT_GRAPHICS, + vk_pipeline_layout, + i, + 1, + (VkDescriptorSet[1]) { + gsk_vulkan_image_get_vk_descriptor_set (GSK_VULKAN_IMAGE (self->images[i]), self->samplers[i]), + }, + 0, + NULL); + } + vkCmdBindPipeline (state->vk_command_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, gsk_vulkan_device_get_vk_pipeline (GSK_VULKAN_DEVICE (gsk_gpu_frame_get_device (frame)), - gsk_vulkan_descriptors_get_pipeline_layout (state->desc), + vk_pipeline_layout, shader_op_class, self->flags, self->color_states, @@ -123,8 +134,6 @@ gsk_gpu_shader_op_vk_command_n (GskGpuOp *op, } return next; -#endif - return NULL; } GskGpuOp * diff --git a/gsk/gpu/gskvulkandevice.c b/gsk/gpu/gskvulkandevice.c index 9e3291d847..134b0bfa52 100644 --- a/gsk/gpu/gskvulkandevice.c +++ b/gsk/gpu/gskvulkandevice.c @@ -25,11 +25,13 @@ struct _GskVulkanDevice GHashTable *conversion_cache; GHashTable *render_pass_cache; - GHashTable *pipeline_layouts; - GskVulkanPipelineLayout *pipeline_layout_cache; + GHashTable *pipeline_cache; VkCommandPool vk_command_pool; + VkDescriptorPool vk_descriptor_pool; VkSampler vk_samplers[GSK_GPU_SAMPLER_N_SAMPLERS]; + VkDescriptorSetLayout vk_image_set_layout; + VkPipelineLayout default_vk_pipeline_layout; }; struct _GskVulkanDeviceClass @@ -42,28 +44,6 @@ G_DEFINE_TYPE (GskVulkanDevice, gsk_vulkan_device, GSK_TYPE_GPU_DEVICE) typedef struct _ConversionCacheEntry ConversionCacheEntry; typedef struct _PipelineCacheKey PipelineCacheKey; typedef struct _RenderPassCacheKey RenderPassCacheKey; -typedef struct _GskVulkanPipelineLayoutSetup GskVulkanPipelineLayoutSetup; - -struct _GskVulkanPipelineLayoutSetup -{ - gsize n_buffers; - gsize n_samplers; - gsize n_immutable_samplers; - VkSampler *immutable_samplers; -}; - -struct _GskVulkanPipelineLayout -{ - gint ref_count; - - VkDescriptorSetLayout vk_buffer_set_layout; - VkDescriptorSetLayout vk_image_set_layout; - VkPipelineLayout vk_pipeline_layout; - GHashTable *pipeline_cache; - - GskVulkanPipelineLayoutSetup setup; - VkSampler samplers[]; -}; struct _ConversionCacheEntry { @@ -81,8 +61,9 @@ struct _PipelineCacheKey GskGpuColorStates color_states; guint32 variation; GskGpuBlend blend; - VkFormat format; - VkPipeline pipeline; + VkFormat vk_format; + VkPipelineLayout vk_layout; + VkPipeline vk_pipeline; }; struct _RenderPassCacheKey @@ -121,7 +102,8 @@ pipeline_cache_key_hash (gconstpointer data) (key->color_states << 8) ^ (key->variation << 16) ^ (key->blend << 24) ^ - (key->format << 21) ^ (key->format >> 11); + GPOINTER_TO_UINT (key->vk_layout) ^ + (key->vk_format << 21) ^ (key->vk_format >> 11); } static gboolean @@ -136,7 +118,8 @@ pipeline_cache_key_equal (gconstpointer a, keya->color_states == keyb->color_states && keya->variation == keyb->variation && keya->blend == keyb->blend && - keya->format == keyb->format; + keya->vk_layout == keyb->vk_layout && + keya->vk_format == keyb->vk_format; } static guint @@ -161,65 +144,16 @@ render_pass_cache_key_equal (gconstpointer a, keya->format == keyb->format; } -static GskVulkanPipelineLayout * -gsk_vulkan_pipeline_layout_new (GskVulkanDevice *self, - const GskVulkanPipelineLayoutSetup *setup) +static VkDescriptorSetLayout +gsk_vulkan_device_create_vk_image_set_layout (GskVulkanDevice *self, + VkSampler immutable_sampler) { - GskVulkanPipelineLayout *layout; - GdkDisplay *display; - gboolean descriptor_indexing; - - descriptor_indexing = gsk_vulkan_device_has_feature (self, GDK_VULKAN_FEATURE_DESCRIPTOR_INDEXING); + VkDevice vk_device; + VkDescriptorSetLayout result; - layout = g_malloc (sizeof (GskVulkanPipelineLayout) + setup->n_immutable_samplers * sizeof (VkSampler)); - layout->ref_count = 1; + vk_device = gsk_vulkan_device_get_vk_device (self); - layout->setup = *setup; - if (setup->n_immutable_samplers) - memcpy (layout->samplers, setup->immutable_samplers, setup->n_immutable_samplers * sizeof (VkSampler)); - layout->setup.immutable_samplers = layout->samplers; - layout->pipeline_cache = g_hash_table_new (pipeline_cache_key_hash, pipeline_cache_key_equal); - - display = gsk_gpu_device_get_display (GSK_GPU_DEVICE (self)); - - GSK_VK_CHECK (vkCreateDescriptorSetLayout, display->vk_device, - &(VkDescriptorSetLayoutCreateInfo) { - .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO, - .bindingCount = 2, - .flags = 0, - .pBindings = (VkDescriptorSetLayoutBinding[2]) { - { - .binding = 0, - .descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, - .descriptorCount = MAX (1, layout->setup.n_immutable_samplers), - .stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT, - .pImmutableSamplers = layout->setup.n_immutable_samplers - ? layout->setup.immutable_samplers - : (VkSampler[1]) { - gsk_vulkan_device_get_vk_sampler (self, GSK_GPU_SAMPLER_DEFAULT) - }, - }, - { - .binding = 1, - .descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, - .descriptorCount = layout->setup.n_samplers, - .stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT - } - }, - .pNext = !descriptor_indexing ? NULL : &(VkDescriptorSetLayoutBindingFlagsCreateInfo) { - .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO, - .bindingCount = 2, - .pBindingFlags = (VkDescriptorBindingFlags[2]) { - VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT, - VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT - | VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT, - }, - } - }, - NULL, - &layout->vk_image_set_layout); - - GSK_VK_CHECK (vkCreateDescriptorSetLayout, display->vk_device, + GSK_VK_CHECK (vkCreateDescriptorSetLayout, vk_device, &(VkDescriptorSetLayoutCreateInfo) { .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO, .bindingCount = 1, @@ -227,30 +161,38 @@ gsk_vulkan_pipeline_layout_new (GskVulkanDevice *self, .pBindings = (VkDescriptorSetLayoutBinding[1]) { { .binding = 0, - .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, - .descriptorCount = layout->setup.n_buffers, - .stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT - }, + .descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, + .descriptorCount = 1, + .stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT, + .pImmutableSamplers = immutable_sampler == VK_NULL_HANDLE ? NULL : (VkSampler[1]) { + immutable_sampler, + }, + } }, - .pNext = !descriptor_indexing ? NULL : &(VkDescriptorSetLayoutBindingFlagsCreateInfo) { - .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO, - .bindingCount = 1, - .pBindingFlags = (VkDescriptorBindingFlags[1]) { - VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT - | VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT, - }, - } }, NULL, - &layout->vk_buffer_set_layout); + &result); - GSK_VK_CHECK (vkCreatePipelineLayout, display->vk_device, + return result; +} + +static VkPipelineLayout +gsk_vulkan_device_create_vk_pipeline_layout (GskVulkanDevice *self, + VkDescriptorSetLayout image1_layout, + VkDescriptorSetLayout image2_layout) +{ + VkDevice vk_device; + VkPipelineLayout result; + + vk_device = gsk_vulkan_device_get_vk_device (self); + + GSK_VK_CHECK (vkCreatePipelineLayout, vk_device, &(VkPipelineLayoutCreateInfo) { .sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, .setLayoutCount = 2, .pSetLayouts = (VkDescriptorSetLayout[2]) { - layout->vk_image_set_layout, - layout->vk_buffer_set_layout, + image1_layout, + image2_layout, }, .pushConstantRangeCount = 1, .pPushConstantRanges = (VkPushConstantRange[1]) { @@ -262,106 +204,11 @@ gsk_vulkan_pipeline_layout_new (GskVulkanDevice *self, } }, NULL, - &layout->vk_pipeline_layout); - - g_hash_table_insert (self->pipeline_layouts, &layout->setup, layout); - - return layout; -} - -static void -gsk_vulkan_pipeline_layout_unref (GskVulkanDevice *self, - GskVulkanPipelineLayout *layout) -{ - GdkDisplay *display; - GHashTableIter iter; - gpointer key, value; - - layout->ref_count--; - if (layout->ref_count) - return; - - if (!g_hash_table_remove (self->pipeline_layouts, &layout->setup)) - { - g_assert_not_reached (); - } - - display = gsk_gpu_device_get_display (GSK_GPU_DEVICE (self)); - - vkDestroyDescriptorSetLayout (display->vk_device, - layout->vk_image_set_layout, - NULL); - vkDestroyDescriptorSetLayout (display->vk_device, - layout->vk_buffer_set_layout, - NULL); - - vkDestroyPipelineLayout (display->vk_device, - layout->vk_pipeline_layout, - NULL); - - g_hash_table_iter_init (&iter, layout->pipeline_cache); - while (g_hash_table_iter_next (&iter, &key, &value)) - { - vkDestroyPipeline (display->vk_device, - ((PipelineCacheKey *)key)->pipeline, - NULL); - g_free (key); - } - g_hash_table_unref (layout->pipeline_cache); - - g_free (layout); -} - -static void -gsk_vulkan_pipeline_layout_ref (GskVulkanDevice *self, - GskVulkanPipelineLayout *layout) -{ - layout->ref_count++; -} - -static guint -gsk_vulkan_pipeline_layout_setup_hash (gconstpointer data) -{ - const GskVulkanPipelineLayoutSetup *setup = data; - guint result; - gsize i; - - result = (setup->n_buffers << 23) | - (setup->n_samplers << 7) | - setup->n_immutable_samplers; - - for (i = 0; i < setup->n_immutable_samplers; i++) - { - result = (result << 13) ^ - GPOINTER_TO_SIZE (setup->immutable_samplers[i]) ^ - (GPOINTER_TO_SIZE (setup->immutable_samplers[i]) >> 32); - } + &result); return result; } -static gboolean -gsk_vulkan_pipeline_layout_setup_equal (gconstpointer a, - gconstpointer b) -{ - const GskVulkanPipelineLayoutSetup *setupa = a; - const GskVulkanPipelineLayoutSetup *setupb = b; - gsize i; - - if (setupa->n_buffers != setupb->n_buffers || - setupa->n_samplers != setupb->n_samplers || - setupa->n_immutable_samplers != setupb->n_immutable_samplers) - return FALSE; - - for (i = 0; i < setupa->n_immutable_samplers; i++) - { - if (setupa->immutable_samplers[i] != setupb->immutable_samplers[i]) - return FALSE; - } - - return TRUE; -} - static GskGpuImage * gsk_vulkan_device_create_offscreen_image (GskGpuDevice *device, gboolean with_mipmap, @@ -448,26 +295,33 @@ gsk_vulkan_device_finalize (GObject *object) { GskVulkanDevice *self = GSK_VULKAN_DEVICE (object); GskGpuDevice *device = GSK_GPU_DEVICE (self); + VkDevice vk_device; GdkDisplay *display; GHashTableIter iter; gpointer key, value; gsize i; - g_object_steal_data (G_OBJECT (gsk_gpu_device_get_display (device)), "-gsk-vulkan-device"); - display = gsk_gpu_device_get_display (device); + vk_device = gsk_vulkan_device_get_vk_device (self); - if (self->pipeline_layout_cache) - gsk_vulkan_pipeline_layout_unref (self, self->pipeline_layout_cache); - g_assert (g_hash_table_size (self->pipeline_layouts) == 0); - g_hash_table_unref (self->pipeline_layouts); + g_object_steal_data (G_OBJECT (display), "-gsk-vulkan-device"); + + g_hash_table_iter_init (&iter, self->pipeline_cache); + while (g_hash_table_iter_next (&iter, &key, &value)) + { + vkDestroyPipeline (vk_device, + ((PipelineCacheKey *)key)->vk_pipeline, + NULL); + g_free (key); + } + g_hash_table_unref (self->pipeline_cache); g_hash_table_iter_init (&iter, self->conversion_cache); while (g_hash_table_iter_next (&iter, &key, &value)) { ConversionCacheEntry *entry = key; - vkDestroySamplerYcbcrConversion (display->vk_device, entry->vk_conversion, NULL); - vkDestroySampler (display->vk_device, entry->vk_sampler, NULL); + vkDestroySamplerYcbcrConversion (vk_device, entry->vk_conversion, NULL); + vkDestroySampler (vk_device, entry->vk_sampler, NULL); g_free (key); } g_hash_table_unref (self->conversion_cache); @@ -475,7 +329,7 @@ gsk_vulkan_device_finalize (GObject *object) g_hash_table_iter_init (&iter, self->render_pass_cache); while (g_hash_table_iter_next (&iter, &key, &value)) { - vkDestroyRenderPass (display->vk_device, + vkDestroyRenderPass (vk_device, ((RenderPassCacheKey *)key)->render_pass, NULL); g_free (key); @@ -485,12 +339,21 @@ gsk_vulkan_device_finalize (GObject *object) for (i = 0; i < G_N_ELEMENTS (self->vk_samplers); i++) { if (self->vk_samplers[i] != VK_NULL_HANDLE) - vkDestroySampler (display->vk_device, + vkDestroySampler (vk_device, self->vk_samplers[i], NULL); } - vkDestroyCommandPool (display->vk_device, + vkDestroyPipelineLayout (vk_device, + self->default_vk_pipeline_layout, + NULL); + vkDestroyDescriptorSetLayout (vk_device, + self->vk_image_set_layout, + NULL); + vkDestroyDescriptorPool (vk_device, + self->vk_descriptor_pool, + NULL); + vkDestroyCommandPool (vk_device, self->vk_command_pool, NULL); @@ -523,24 +386,45 @@ gsk_vulkan_device_init (GskVulkanDevice *self) { self->conversion_cache = g_hash_table_new (conversion_cache_entry_hash, conversion_cache_entry_equal); self->render_pass_cache = g_hash_table_new (render_pass_cache_key_hash, render_pass_cache_key_equal); - self->pipeline_layouts = g_hash_table_new (gsk_vulkan_pipeline_layout_setup_hash, gsk_vulkan_pipeline_layout_setup_equal); + self->pipeline_cache = g_hash_table_new (pipeline_cache_key_hash, pipeline_cache_key_equal); } static void gsk_vulkan_device_create_vk_objects (GskVulkanDevice *self) { - GdkDisplay *display; + VkDevice vk_device; - display = gsk_gpu_device_get_display (GSK_GPU_DEVICE (self)); + vk_device = gsk_vulkan_device_get_vk_device (self); - GSK_VK_CHECK (vkCreateCommandPool, display->vk_device, + GSK_VK_CHECK (vkCreateCommandPool, vk_device, &(const VkCommandPoolCreateInfo) { .sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO, - .queueFamilyIndex = display->vk_queue_family_index, + .queueFamilyIndex = gsk_vulkan_device_get_vk_queue_family_index (self), .flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT, }, NULL, &self->vk_command_pool); + GSK_VK_CHECK (vkCreateDescriptorPool, vk_device, + &(VkDescriptorPoolCreateInfo) { + .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO, + .flags = VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, + .maxSets = 10000, + .poolSizeCount = 1, + .pPoolSizes = (VkDescriptorPoolSize[1]) { + { + .type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, + .descriptorCount = 10000, + }, + } + }, + NULL, + &self->vk_descriptor_pool); + + self->vk_image_set_layout = gsk_vulkan_device_create_vk_image_set_layout (self, NULL); + + self->default_vk_pipeline_layout = gsk_vulkan_device_create_vk_pipeline_layout (self, + self->vk_image_set_layout, + self->vk_image_set_layout); } static void @@ -656,24 +540,15 @@ gsk_vulkan_device_get_vk_queue_family_index (GskVulkanDevice *self) } VkDescriptorSetLayout -gsk_vulkan_device_get_vk_image_set_layout (GskVulkanDevice *self, - GskVulkanPipelineLayout *layout) +gsk_vulkan_device_get_vk_image_set_layout (GskVulkanDevice *self) { - return layout->vk_image_set_layout; -} - -VkDescriptorSetLayout -gsk_vulkan_device_get_vk_buffer_set_layout (GskVulkanDevice *self, - GskVulkanPipelineLayout *layout) -{ - return layout->vk_buffer_set_layout; + return self->vk_image_set_layout; } VkPipelineLayout -gsk_vulkan_device_get_vk_pipeline_layout (GskVulkanDevice *self, - GskVulkanPipelineLayout *layout) +gsk_vulkan_device_get_default_vk_pipeline_layout (GskVulkanDevice *self) { - return layout->vk_pipeline_layout; + return self->default_vk_pipeline_layout; } VkCommandPool @@ -682,6 +557,12 @@ gsk_vulkan_device_get_vk_command_pool (GskVulkanDevice *self) return self->vk_command_pool; } +VkDescriptorPool +gsk_vulkan_device_get_vk_descriptor_pool (GskVulkanDevice *self) +{ + return self->vk_descriptor_pool; +} + static VkSampler gsk_vulkan_device_create_sampler (GskVulkanDevice *self, VkSamplerYcbcrConversion vk_conversion, @@ -906,9 +787,6 @@ typedef struct _GskVulkanShaderSpecialization GskVulkanShaderSpecialization; struct _GskVulkanShaderSpecialization { guint32 flags; - guint32 n_immutable_samplers; - guint32 n_samplers; - guint32 n_buffers; guint32 color_states; guint32 variation; }; @@ -964,18 +842,18 @@ static VkPipelineColorBlendAttachmentState blend_attachment_states[4] = { VkPipeline gsk_vulkan_device_get_vk_pipeline (GskVulkanDevice *self, - GskVulkanPipelineLayout *layout, + VkPipelineLayout vk_layout, const GskGpuShaderOpClass *op_class, GskGpuShaderFlags flags, GskGpuColorStates color_states, guint32 variation, GskGpuBlend blend, - VkFormat format, + VkFormat vk_format, VkRenderPass render_pass) { PipelineCacheKey cache_key; PipelineCacheKey *cached_result; - VkPipeline pipeline; + VkPipeline vk_pipeline; GdkDisplay *display; const char *version_string; char *vertex_shader_name, *fragment_shader_name; @@ -983,16 +861,17 @@ gsk_vulkan_device_get_vk_pipeline (GskVulkanDevice *self, const char *blend_name[] = { "NONE", "OVER", "ADD", "CLEAR" }; cache_key = (PipelineCacheKey) { + .vk_layout = vk_layout, .op_class = op_class, .color_states = color_states, .variation = variation, .flags = flags, .blend = blend, - .format = format, + .vk_format = vk_format, }; - cached_result = g_hash_table_lookup (layout->pipeline_cache, &cache_key); + cached_result = g_hash_table_lookup (self->pipeline_cache, &cache_key); if (cached_result) - return cached_result->pipeline; + return cached_result->vk_pipeline; display = gsk_gpu_device_get_display (GSK_GPU_DEVICE (self)); if (gsk_vulkan_device_has_feature (self, GDK_VULKAN_FEATURE_DYNAMIC_INDEXING) && @@ -1024,7 +903,7 @@ gsk_vulkan_device_get_vk_pipeline (GskVulkanDevice *self, .module = gdk_display_get_vk_shader_module (display, vertex_shader_name), .pName = "main", .pSpecializationInfo = &(VkSpecializationInfo) { - .mapEntryCount = 6, + .mapEntryCount = 3, .pMapEntries = (VkSpecializationMapEntry[6]) { { .constantID = 0, @@ -1033,26 +912,11 @@ gsk_vulkan_device_get_vk_pipeline (GskVulkanDevice *self, }, { .constantID = 1, - .offset = G_STRUCT_OFFSET (GskVulkanShaderSpecialization, n_immutable_samplers), - .size = sizeof (guint32), - }, - { - .constantID = 2, - .offset = G_STRUCT_OFFSET (GskVulkanShaderSpecialization, n_samplers), - .size = sizeof (guint32), - }, - { - .constantID = 3, - .offset = G_STRUCT_OFFSET (GskVulkanShaderSpecialization, n_buffers), - .size = sizeof (guint32), - }, - { - .constantID = 4, .offset = G_STRUCT_OFFSET (GskVulkanShaderSpecialization, color_states), .size = sizeof (guint32), }, { - .constantID = 5, + .constantID = 2, .offset = G_STRUCT_OFFSET (GskVulkanShaderSpecialization, variation), .size = sizeof (guint32), }, @@ -1060,9 +924,6 @@ gsk_vulkan_device_get_vk_pipeline (GskVulkanDevice *self, .dataSize = sizeof (GskVulkanShaderSpecialization), .pData = &(GskVulkanShaderSpecialization) { .flags = flags, - .n_immutable_samplers = MAX (1, layout->setup.n_immutable_samplers), - .n_samplers = layout->setup.n_samplers - MAX (3 * layout->setup.n_immutable_samplers, 1), - .n_buffers = layout->setup.n_buffers, .color_states = color_states, .variation = variation, }, @@ -1074,7 +935,7 @@ gsk_vulkan_device_get_vk_pipeline (GskVulkanDevice *self, .module = gdk_display_get_vk_shader_module (display, fragment_shader_name), .pName = "main", .pSpecializationInfo = &(VkSpecializationInfo) { - .mapEntryCount = 6, + .mapEntryCount = 3, .pMapEntries = (VkSpecializationMapEntry[6]) { { .constantID = 0, @@ -1083,26 +944,11 @@ gsk_vulkan_device_get_vk_pipeline (GskVulkanDevice *self, }, { .constantID = 1, - .offset = G_STRUCT_OFFSET (GskVulkanShaderSpecialization, n_immutable_samplers), - .size = sizeof (guint32), - }, - { - .constantID = 2, - .offset = G_STRUCT_OFFSET (GskVulkanShaderSpecialization, n_samplers), - .size = sizeof (guint32), - }, - { - .constantID = 3, - .offset = G_STRUCT_OFFSET (GskVulkanShaderSpecialization, n_buffers), - .size = sizeof (guint32), - }, - { - .constantID = 4, .offset = G_STRUCT_OFFSET (GskVulkanShaderSpecialization, color_states), .size = sizeof (guint32), }, { - .constantID = 5, + .constantID = 2, .offset = G_STRUCT_OFFSET (GskVulkanShaderSpecialization, variation), .size = sizeof (guint32), }, @@ -1110,9 +956,6 @@ gsk_vulkan_device_get_vk_pipeline (GskVulkanDevice *self, .dataSize = sizeof (GskVulkanShaderSpecialization), .pData = &(GskVulkanShaderSpecialization) { .flags = flags, - .n_immutable_samplers = MAX (1, layout->setup.n_immutable_samplers), - .n_samplers = layout->setup.n_samplers - MAX (3 * layout->setup.n_immutable_samplers, 1), - .n_buffers = layout->setup.n_buffers, .color_states = color_states, .variation = variation, }, @@ -1161,14 +1004,14 @@ gsk_vulkan_device_get_vk_pipeline (GskVulkanDevice *self, VK_DYNAMIC_STATE_SCISSOR }, }, - .layout = layout->vk_pipeline_layout, + .layout = vk_layout, .renderPass = render_pass, .subpass = 0, .basePipelineHandle = VK_NULL_HANDLE, .basePipelineIndex = -1, }, NULL, - &pipeline); + &vk_pipeline); gdk_profiler_end_markf (begin_time, "Create Vulkan pipeline", "%s version=%s color states=%u variation=%u clip=%u blend=%s format=%u", @@ -1178,83 +1021,27 @@ gsk_vulkan_device_get_vk_pipeline (GskVulkanDevice *self, color_states, variation, blend_name[blend], - format); + vk_format); GSK_DEBUG (SHADERS, - "Create Vulkan pipeline (%s %s, %u/%u/%u/%s/%u) for layout (%" G_GSIZE_FORMAT "/%" G_GSIZE_FORMAT "/%" G_GSIZE_FORMAT ")", + "Create Vulkan pipeline (%s %s, %u/%u/%u/%s/%u)", op_class->shader_name, version_string + 1, flags, color_states, variation, blend_name[blend], - format, - layout->setup.n_buffers, - layout->setup.n_samplers, - layout->setup.n_immutable_samplers); + vk_format); g_free (fragment_shader_name); g_free (vertex_shader_name); cached_result = g_memdup (&cache_key, sizeof (PipelineCacheKey)); - cached_result->pipeline = pipeline; - g_hash_table_insert (layout->pipeline_cache, cached_result, cached_result); + cached_result->vk_pipeline = vk_pipeline; + g_hash_table_add (self->pipeline_cache, cached_result); gdk_display_vulkan_pipeline_cache_updated (display); - return pipeline; -} - -GskVulkanPipelineLayout * -gsk_vulkan_device_acquire_pipeline_layout (GskVulkanDevice *self, - VkSampler *immutable_samplers, - gsize n_immutable_samplers, - gsize n_samplers, - gsize n_buffers) -{ - GskVulkanPipelineLayoutSetup setup; - GskVulkanPipelineLayout *layout; - - /* round the number of samplers/buffer up a bit, so we don't (re)create - * excessive amounts of layouts */ - n_samplers = MAX (n_samplers, 8); - g_assert (n_samplers <= self->max_samplers); - n_buffers = MAX (n_buffers, 8); - g_assert (n_buffers <= self->max_buffers); - setup.n_samplers = MIN (2 << g_bit_nth_msf (n_samplers - 1, -1), self->max_samplers); - setup.n_buffers = MIN (2 << g_bit_nth_msf (n_buffers - 1, -1), self->max_buffers); - setup.n_immutable_samplers = n_immutable_samplers; - setup.immutable_samplers = immutable_samplers; - - layout = g_hash_table_lookup (self->pipeline_layouts, &setup); - if (layout) - { - gsk_vulkan_pipeline_layout_ref (self, layout); - return layout; - } - - return gsk_vulkan_pipeline_layout_new (self, &setup); -} - -void -gsk_vulkan_device_release_pipeline_layout (GskVulkanDevice *self, - GskVulkanPipelineLayout *layout) -{ - if (self->pipeline_layout_cache) - gsk_vulkan_pipeline_layout_unref (self, self->pipeline_layout_cache); - - self->pipeline_layout_cache = layout; -} - -void -gsk_vulkan_device_get_pipeline_sizes (GskVulkanDevice *self, - GskVulkanPipelineLayout*layout, - gsize *n_immutable_samplers, - gsize *n_samplers, - gsize *n_buffers) -{ - *n_immutable_samplers = layout->setup.n_immutable_samplers; - *n_samplers = layout->setup.n_samplers; - *n_buffers = layout->setup.n_buffers; + return vk_pipeline; } static GskVulkanAllocator * diff --git a/gsk/gpu/gskvulkandeviceprivate.h b/gsk/gpu/gskvulkandeviceprivate.h index 888eb71dd2..8132663bf0 100644 --- a/gsk/gpu/gskvulkandeviceprivate.h +++ b/gsk/gpu/gskvulkandeviceprivate.h @@ -11,20 +11,10 @@ G_BEGIN_DECLS -/* also used by gskvulkanframe.c */ -enum { - GSK_VULKAN_IMAGE_SET_LAYOUT, - GSK_VULKAN_BUFFER_SET_LAYOUT, - - GSK_VULKAN_N_DESCRIPTOR_SETS -}; - #define GSK_TYPE_VULKAN_DEVICE (gsk_vulkan_device_get_type ()) G_DECLARE_FINAL_TYPE(GskVulkanDevice, gsk_vulkan_device, GSK, VULKAN_DEVICE, GskGpuDevice) -typedef struct _GskVulkanPipelineLayout GskVulkanPipelineLayout; - GskGpuDevice * gsk_vulkan_device_get_for_display (GdkDisplay *display, GError **error); @@ -39,29 +29,12 @@ VkPhysicalDevice gsk_vulkan_device_get_vk_physical_device (GskVulk VkQueue gsk_vulkan_device_get_vk_queue (GskVulkanDevice *self) G_GNUC_PURE; uint32_t gsk_vulkan_device_get_vk_queue_family_index (GskVulkanDevice *self) G_GNUC_PURE; VkCommandPool gsk_vulkan_device_get_vk_command_pool (GskVulkanDevice *self) G_GNUC_PURE; +VkDescriptorPool gsk_vulkan_device_get_vk_descriptor_pool (GskVulkanDevice *self) G_GNUC_PURE; +VkDescriptorSetLayout gsk_vulkan_device_get_vk_image_set_layout (GskVulkanDevice *self) G_GNUC_PURE; +VkPipelineLayout gsk_vulkan_device_get_default_vk_pipeline_layout (GskVulkanDevice *self) G_GNUC_PURE; VkSampler gsk_vulkan_device_get_vk_sampler (GskVulkanDevice *self, GskGpuSampler sampler) G_GNUC_PURE; -GskVulkanPipelineLayout * - gsk_vulkan_device_acquire_pipeline_layout (GskVulkanDevice *self, - VkSampler *immutable_samplers, - gsize n_immutable_samplers, - gsize n_samplers, - gsize n_buffers); -void gsk_vulkan_device_release_pipeline_layout (GskVulkanDevice *self, - GskVulkanPipelineLayout*layout); -void gsk_vulkan_device_get_pipeline_sizes (GskVulkanDevice *self, - GskVulkanPipelineLayout*layout, - gsize *n_immutable_samplers, - gsize *n_samplers, - gsize *n_buffers); -VkDescriptorSetLayout gsk_vulkan_device_get_vk_image_set_layout (GskVulkanDevice *self, - GskVulkanPipelineLayout*layout) G_GNUC_PURE; -VkDescriptorSetLayout gsk_vulkan_device_get_vk_buffer_set_layout (GskVulkanDevice *self, - GskVulkanPipelineLayout*layout) G_GNUC_PURE; -VkPipelineLayout gsk_vulkan_device_get_vk_pipeline_layout (GskVulkanDevice *self, - GskVulkanPipelineLayout*layout) G_GNUC_PURE; - VkSamplerYcbcrConversion gsk_vulkan_device_get_vk_conversion (GskVulkanDevice *self, VkFormat vk_format, @@ -71,13 +44,13 @@ VkRenderPass gsk_vulkan_device_get_vk_render_pass (GskVulk VkImageLayout from_layout, VkImageLayout to_layout); VkPipeline gsk_vulkan_device_get_vk_pipeline (GskVulkanDevice *self, - GskVulkanPipelineLayout*layout, + VkPipelineLayout layout, const GskGpuShaderOpClass *op_class, GskGpuShaderFlags flags, GskGpuColorStates color_states, guint32 variation, GskGpuBlend blend, - VkFormat format, + VkFormat vk_format, VkRenderPass render_pass); GskVulkanAllocator * gsk_vulkan_device_get_external_allocator (GskVulkanDevice *self); diff --git a/gsk/gpu/gskvulkanframe.c b/gsk/gpu/gskvulkanframe.c index 3b5f138703..7ab0712f4d 100644 --- a/gsk/gpu/gskvulkanframe.c +++ b/gsk/gpu/gskvulkanframe.c @@ -39,7 +39,6 @@ struct _GskVulkanFrame VkSemaphore vk_acquire_semaphore; VkFence vk_fence; VkCommandBuffer vk_command_buffer; - VkDescriptorPool vk_descriptor_pool; gsize pool_n_sets; gsize pool_n_images; @@ -139,13 +138,6 @@ gsk_vulkan_frame_cleanup (GskGpuFrame *frame) GSK_VK_CHECK (vkResetCommandBuffer, self->vk_command_buffer, 0); - if (self->vk_descriptor_pool != VK_NULL_HANDLE) - { - GSK_VK_CHECK (vkResetDescriptorPool, vk_device, - self->vk_descriptor_pool, - 0); - } - GSK_GPU_FRAME_CLASS (gsk_vulkan_frame_parent_class)->cleanup (frame); } @@ -223,75 +215,6 @@ gsk_vulkan_frame_upload_texture (GskGpuFrame *frame, return GSK_GPU_FRAME_CLASS (gsk_vulkan_frame_parent_class)->upload_texture (frame, with_mipmap, texture); } -static void -gsk_vulkan_frame_prepare_descriptors (GskVulkanFrame *self) -{ -#if 0 - GskVulkanDevice *device; - VkDevice vk_device; - gsize i, n_images, n_sets; - - device = GSK_VULKAN_DEVICE (gsk_gpu_frame_get_device (GSK_GPU_FRAME (self))); - vk_device = gsk_vulkan_device_get_vk_device (device); - - n_images = 0; - n_sets = 2 * gsk_descriptors_get_size (&self->descriptors); - for (i = 0; i < gsk_descriptors_get_size (&self->descriptors); i++) - { - gsize n_desc_images; - GskVulkanRealDescriptors *desc = gsk_descriptors_get (&self->descriptors, i); - gsk_vulkan_real_descriptors_prepare (desc, &n_desc_images); - n_images += n_desc_images; - } - - if (n_sets > self->pool_n_sets || - n_images > self->pool_n_images) - { - if (self->vk_descriptor_pool != VK_NULL_HANDLE) - { - vkDestroyDescriptorPool (vk_device, - self->vk_descriptor_pool, - NULL); - self->vk_descriptor_pool = VK_NULL_HANDLE; - } - if (n_sets > self->pool_n_sets) - self->pool_n_sets = 4 << g_bit_nth_msf (n_sets - 1, -1); - if (n_images > self->pool_n_images) - self->pool_n_images = 2 << g_bit_nth_msf (n_images - 1, -1); - } - - if (self->vk_descriptor_pool == VK_NULL_HANDLE) - { - GSK_VK_CHECK (vkCreateDescriptorPool, vk_device, - &(VkDescriptorPoolCreateInfo) { - .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO, - .flags = 0, - .maxSets = self->pool_n_sets, - .poolSizeCount = 2, - .pPoolSizes = (VkDescriptorPoolSize[2]) { - { - .type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, - .descriptorCount = self->pool_n_images, - }, - { - .type = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, - .descriptorCount = self->pool_n_buffers, - } - } - }, - NULL, - &self->vk_descriptor_pool); - } - - for (i = 0; i < gsk_descriptors_get_size (&self->descriptors); i++) - { - GskVulkanRealDescriptors *desc = gsk_descriptors_get (&self->descriptors, i); - - gsk_vulkan_real_descriptors_update_sets (desc, self->vk_descriptor_pool); - } -#endif -} - static GskGpuBuffer * gsk_vulkan_frame_create_vertex_buffer (GskGpuFrame *frame, gsize size) @@ -323,14 +246,7 @@ gsk_vulkan_frame_submit (GskGpuFrame *frame, { GskVulkanFrame *self = GSK_VULKAN_FRAME (frame); GskVulkanSemaphores semaphores; - GskVulkanCommandState state; - -#if 0 - if (gsk_descriptors_get_size (&self->descriptors) == 0) - gsk_descriptors_append (&self->descriptors, gsk_vulkan_real_descriptors_new (self)); -#endif - - gsk_vulkan_frame_prepare_descriptors (self); + GskVulkanCommandState state = { 0, }; GSK_VK_CHECK (vkBeginCommandBuffer, self->vk_command_buffer, &(VkCommandBufferBeginInfo) { @@ -402,13 +318,6 @@ gsk_vulkan_frame_finalize (GObject *object) vk_device = gsk_vulkan_device_get_vk_device (device); vk_command_pool = gsk_vulkan_device_get_vk_command_pool (device); - if (self->vk_descriptor_pool != VK_NULL_HANDLE) - { - vkDestroyDescriptorPool (vk_device, - self->vk_descriptor_pool, - NULL); - } - vkFreeCommandBuffers (vk_device, vk_command_pool, 1, &self->vk_command_buffer); diff --git a/gsk/gpu/gskvulkanimage.c b/gsk/gpu/gskvulkanimage.c index 172256cd11..0502f76319 100644 --- a/gsk/gpu/gskvulkanimage.c +++ b/gsk/gpu/gskvulkanimage.c @@ -33,6 +33,7 @@ struct _GskVulkanImage VkImageView vk_framebuffer_image_view; VkSampler vk_sampler; VkSemaphore vk_semaphore; + VkDescriptorSet vk_descriptor_sets[GSK_GPU_SAMPLER_N_SAMPLERS]; VkPipelineStageFlags vk_pipeline_stage; VkImageLayout vk_image_layout; @@ -1282,9 +1283,21 @@ static void gsk_vulkan_image_finalize (GObject *object) { GskVulkanImage *self = GSK_VULKAN_IMAGE (object); + VkDescriptorPool vk_descriptor_pool; VkDevice vk_device; + gsize i; vk_device = gsk_vulkan_device_get_vk_device (self->device); + vk_descriptor_pool = gsk_vulkan_device_get_vk_descriptor_pool (self->device); + + for (i = 0; i < GSK_GPU_SAMPLER_N_SAMPLERS; i++) + { + if (self->vk_descriptor_sets[i]) + vkFreeDescriptorSets (vk_device, + vk_descriptor_pool, + 1, + &self->vk_descriptor_sets[i]); + } if (self->vk_framebuffer != VK_NULL_HANDLE) vkDestroyFramebuffer (vk_device, self->vk_framebuffer, NULL); @@ -1388,6 +1401,47 @@ gsk_vulkan_image_get_vk_sampler (GskVulkanImage *self) return self->vk_sampler; } +VkDescriptorSet +gsk_vulkan_image_get_vk_descriptor_set (GskVulkanImage *self, + GskGpuSampler sampler) +{ + if (self->vk_descriptor_sets[sampler] == NULL) + { + VkDevice vk_device = gsk_vulkan_device_get_vk_device (self->device); + + GSK_VK_CHECK (vkAllocateDescriptorSets, vk_device, + &(VkDescriptorSetAllocateInfo) { + .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO, + .descriptorPool = gsk_vulkan_device_get_vk_descriptor_pool (self->device), + .descriptorSetCount = 1, + .pSetLayouts = (VkDescriptorSetLayout[1]) { + gsk_vulkan_device_get_vk_image_set_layout (self->device), + }, + }, + &self->vk_descriptor_sets[sampler]); + g_assert (self->vk_descriptor_sets[sampler]); + vkUpdateDescriptorSets (vk_device, + 1, + &(VkWriteDescriptorSet) { + .sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, + .dstSet = self->vk_descriptor_sets[sampler], + .dstBinding = 0, + .dstArrayElement = 0, + .descriptorCount = 1, + .descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, + .pImageInfo = &(VkDescriptorImageInfo) { + .sampler = gsk_vulkan_device_get_vk_sampler (self->device, sampler), + .imageView = self->vk_image_view, + .imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL + }, + }, + 0, + NULL); + } + + return self->vk_descriptor_sets[sampler]; +} + VkImage gsk_vulkan_image_get_vk_image (GskVulkanImage *self) { diff --git a/gsk/gpu/gskvulkanimageprivate.h b/gsk/gpu/gskvulkanimageprivate.h index 7229c082b9..8346d23144 100644 --- a/gsk/gpu/gskvulkanimageprivate.h +++ b/gsk/gpu/gskvulkanimageprivate.h @@ -51,6 +51,8 @@ guchar * gsk_vulkan_image_get_data (GskVulk gsize *out_stride); VkSampler gsk_vulkan_image_get_vk_sampler (GskVulkanImage *self); +VkDescriptorSet gsk_vulkan_image_get_vk_descriptor_set (GskVulkanImage *self, + GskGpuSampler sampler); VkPipelineStageFlags gsk_vulkan_image_get_vk_pipeline_stage (GskVulkanImage *self); VkImageLayout gsk_vulkan_image_get_vk_image_layout (GskVulkanImage *self); VkAccessFlags gsk_vulkan_image_get_vk_access (GskVulkanImage *self); diff --git a/gsk/gpu/shaders/common-vulkan.glsl b/gsk/gpu/shaders/common-vulkan.glsl index 6380c4cdb8..933f806171 100644 --- a/gsk/gpu/shaders/common-vulkan.glsl +++ b/gsk/gpu/shaders/common-vulkan.glsl @@ -11,11 +11,8 @@ layout(push_constant) uniform PushConstants { } push; layout(constant_id=0) const uint GSK_FLAGS = 0; -layout(constant_id=1) const uint GSK_N_IMMUTABLE_SAMPLERS = 32; -layout(constant_id=2) const uint GSK_N_SAMPLERS = 32; -layout(constant_id=3) const uint GSK_N_BUFFERS = 32; -layout(constant_id=4) const uint GSK_COLOR_STATES = 0; -layout(constant_id=5) const uint GSK_VARIATION = 0; +layout(constant_id=1) const uint GSK_COLOR_STATES = 0; +layout(constant_id=2) const uint GSK_VARIATION = 0; #define GSK_GLOBAL_MVP push.mvp #define GSK_GLOBAL_CLIP push.clip @@ -35,14 +32,11 @@ layout(constant_id=5) const uint GSK_VARIATION = 0; #define PASS(_loc) layout(location = _loc) in #define PASS_FLAT(_loc) layout(location = _loc) flat in -layout(set = 0, binding = 0) uniform sampler2D immutable_textures[GSK_N_IMMUTABLE_SAMPLERS]; -layout(set = 0, binding = 1) uniform sampler2D textures[GSK_N_SAMPLERS]; +layout(set = 0, binding = 0) uniform sampler2D GSK_TEXTURE0; +layout(set = 1, binding = 0) uniform sampler2D GSK_TEXTURE1; layout(location = 0) out vec4 out_color; -#define GSK_TEXTURE0 textures[0] -#define GSK_TEXTURE1 textures[1] - void gsk_set_output_color (vec4 color) { From ecc33d6e62fe35860100f5529608d17211e82b54 Mon Sep 17 00:00:00 2001 From: Benjamin Otte Date: Sun, 21 Jul 2024 14:29:50 +0200 Subject: [PATCH 19/28] gpu: Add the same cache as the GL shader uses This avoids unnecessary rebinds of textures. I can't really measure a performance change with it though. --- gsk/gpu/gskgpuopprivate.h | 2 ++ gsk/gpu/gskgpushaderop.c | 26 ++++++++++++++++---------- 2 files changed, 18 insertions(+), 10 deletions(-) diff --git a/gsk/gpu/gskgpuopprivate.h b/gsk/gpu/gskgpuopprivate.h index 395ad596d1..ac88840027 100644 --- a/gsk/gpu/gskgpuopprivate.h +++ b/gsk/gpu/gskgpuopprivate.h @@ -42,6 +42,8 @@ struct _GskVulkanCommandState GskGpuBlend blend; GskVulkanSemaphores *semaphores; + GskGpuImage *current_images[2]; + GskGpuSampler current_samplers[2]; }; #endif diff --git a/gsk/gpu/gskgpushaderop.c b/gsk/gpu/gskgpushaderop.c index 58dbb11ca0..a211cf7d24 100644 --- a/gsk/gpu/gskgpushaderop.c +++ b/gsk/gpu/gskgpushaderop.c @@ -102,16 +102,22 @@ gsk_gpu_shader_op_vk_command_n (GskGpuOp *op, for (i = 0; i < shader_op_class->n_textures; i++) { - vkCmdBindDescriptorSets (state->vk_command_buffer, - VK_PIPELINE_BIND_POINT_GRAPHICS, - vk_pipeline_layout, - i, - 1, - (VkDescriptorSet[1]) { - gsk_vulkan_image_get_vk_descriptor_set (GSK_VULKAN_IMAGE (self->images[i]), self->samplers[i]), - }, - 0, - NULL); + if (state->current_images[i] != self->images[i] || + state->current_samplers[i] != self->samplers[i]) + { + vkCmdBindDescriptorSets (state->vk_command_buffer, + VK_PIPELINE_BIND_POINT_GRAPHICS, + vk_pipeline_layout, + i, + 1, + (VkDescriptorSet[1]) { + gsk_vulkan_image_get_vk_descriptor_set (GSK_VULKAN_IMAGE (self->images[i]), self->samplers[i]), + }, + 0, + NULL); + state->current_images[i] = self->images[i]; + state->current_samplers[i] = self->samplers[i]; + } } vkCmdBindPipeline (state->vk_command_buffer, From 9c5ac13301e7a2b8d79d47c948518fab0ea1ea38 Mon Sep 17 00:00:00 2001 From: Benjamin Otte Date: Sun, 21 Jul 2024 14:41:04 +0200 Subject: [PATCH 20/28] gpu: Remove now unused variables No need to track them anymore. --- gsk/gpu/gskvulkandevice.c | 46 +------------------------------- gsk/gpu/gskvulkandeviceprivate.h | 3 --- 2 files changed, 1 insertion(+), 48 deletions(-) diff --git a/gsk/gpu/gskvulkandevice.c b/gsk/gpu/gskvulkandevice.c index 134b0bfa52..853929eb54 100644 --- a/gsk/gpu/gskvulkandevice.c +++ b/gsk/gpu/gskvulkandevice.c @@ -19,10 +19,6 @@ struct _GskVulkanDevice GskVulkanAllocator *external_allocator; GdkVulkanFeatures features; - guint max_immutable_samplers; - guint max_samplers; - guint max_buffers; - GHashTable *conversion_cache; GHashTable *render_pass_cache; GHashTable *pipeline_cache; @@ -431,34 +427,12 @@ static void gsk_vulkan_device_setup (GskVulkanDevice *self, GdkDisplay *display) { - VkPhysicalDeviceVulkan12Properties vk12_props = { - .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES, - }; VkPhysicalDeviceProperties2 vk_props = { .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2, - .pNext = &vk12_props + .pNext = NULL }; vkGetPhysicalDeviceProperties2 (display->vk_physical_device, &vk_props); - if (gsk_vulkan_device_has_feature (self, GDK_VULKAN_FEATURE_DESCRIPTOR_INDEXING)) - { - self->max_buffers = vk12_props.maxPerStageDescriptorUpdateAfterBindUniformBuffers; - self->max_samplers = vk12_props.maxPerStageDescriptorUpdateAfterBindSampledImages; - } - else - { - self->max_buffers = vk_props.properties.limits.maxPerStageDescriptorUniformBuffers; - self->max_samplers = vk_props.properties.limits.maxPerStageDescriptorSampledImages; - } - if (!gsk_vulkan_device_has_feature (self, GDK_VULKAN_FEATURE_DYNAMIC_INDEXING) || - !gsk_vulkan_device_has_feature (self, GDK_VULKAN_FEATURE_NONUNIFORM_INDEXING)) - { - /* These numbers can be improved in the shader sources by adding more - * entries to the big if() ladders */ - self->max_buffers = MIN (self->max_buffers, 32); - self->max_samplers = MIN (self->max_samplers, 32); - } - self->max_immutable_samplers = MIN (self->max_samplers / 3, 32); gsk_gpu_device_setup (GSK_GPU_DEVICE (self), display, vk_props.properties.limits.maxImageDimension2D, @@ -490,24 +464,6 @@ gsk_vulkan_device_get_for_display (GdkDisplay *display, return GSK_GPU_DEVICE (self); } -gsize -gsk_vulkan_device_get_max_immutable_samplers (GskVulkanDevice *self) -{ - return self->max_immutable_samplers; -} - -gsize -gsk_vulkan_device_get_max_samplers (GskVulkanDevice *self) -{ - return self->max_samplers; -} - -gsize -gsk_vulkan_device_get_max_buffers (GskVulkanDevice *self) -{ - return self->max_buffers; -} - gboolean gsk_vulkan_device_has_feature (GskVulkanDevice *self, GdkVulkanFeatures feature) diff --git a/gsk/gpu/gskvulkandeviceprivate.h b/gsk/gpu/gskvulkandeviceprivate.h index 8132663bf0..e623dd2b8f 100644 --- a/gsk/gpu/gskvulkandeviceprivate.h +++ b/gsk/gpu/gskvulkandeviceprivate.h @@ -18,9 +18,6 @@ G_DECLARE_FINAL_TYPE(GskVulkanDevice, gsk_vulkan_device, GSK, VULKAN_DEVICE, Gsk GskGpuDevice * gsk_vulkan_device_get_for_display (GdkDisplay *display, GError **error); -gsize gsk_vulkan_device_get_max_immutable_samplers (GskVulkanDevice *self); -gsize gsk_vulkan_device_get_max_samplers (GskVulkanDevice *self); -gsize gsk_vulkan_device_get_max_buffers (GskVulkanDevice *self); gboolean gsk_vulkan_device_has_feature (GskVulkanDevice *self, GdkVulkanFeatures feature) G_GNUC_PURE; From f5096fd11a3623d08cb3f47e24bbb20792a2f93a Mon Sep 17 00:00:00 2001 From: Benjamin Otte Date: Sun, 21 Jul 2024 14:45:33 +0200 Subject: [PATCH 21/28] vulkan: No need for different shaders anymore Now that we don't do fancy texture stuff anymore, we don't need fancy shaders either, so we can just compile against Vulkan 1.0 again. And that means we need no fallback shaders for Vulkan 1.0 anymore. --- gsk/gpu/gskvulkandevice.c | 15 +++------------ gsk/gpu/shaders/common-vulkan.glsl | 4 ---- gsk/gpu/shaders/meson.build | 18 ++---------------- 3 files changed, 5 insertions(+), 32 deletions(-) diff --git a/gsk/gpu/gskvulkandevice.c b/gsk/gpu/gskvulkandevice.c index 853929eb54..8b0db38e6a 100644 --- a/gsk/gpu/gskvulkandevice.c +++ b/gsk/gpu/gskvulkandevice.c @@ -811,7 +811,6 @@ gsk_vulkan_device_get_vk_pipeline (GskVulkanDevice *self, PipelineCacheKey *cached_result; VkPipeline vk_pipeline; GdkDisplay *display; - const char *version_string; char *vertex_shader_name, *fragment_shader_name; G_GNUC_UNUSED gint64 begin_time = GDK_PROFILER_CURRENT_TIME; const char *blend_name[] = { "NONE", "OVER", "ADD", "CLEAR" }; @@ -830,19 +829,13 @@ gsk_vulkan_device_get_vk_pipeline (GskVulkanDevice *self, return cached_result->vk_pipeline; display = gsk_gpu_device_get_display (GSK_GPU_DEVICE (self)); - if (gsk_vulkan_device_has_feature (self, GDK_VULKAN_FEATURE_DYNAMIC_INDEXING) && - gsk_vulkan_device_has_feature (self, GDK_VULKAN_FEATURE_NONUNIFORM_INDEXING)) - version_string = ".1.2"; - else - version_string = ".1.0"; + vertex_shader_name = g_strconcat ("/org/gtk/libgsk/shaders/vulkan/", op_class->shader_name, - version_string, ".vert.spv", NULL); fragment_shader_name = g_strconcat ("/org/gtk/libgsk/shaders/vulkan/", op_class->shader_name, - version_string, ".frag.spv", NULL); @@ -970,9 +963,8 @@ gsk_vulkan_device_get_vk_pipeline (GskVulkanDevice *self, &vk_pipeline); gdk_profiler_end_markf (begin_time, - "Create Vulkan pipeline", "%s version=%s color states=%u variation=%u clip=%u blend=%s format=%u", + "Create Vulkan pipeline", "%s color states=%u variation=%u clip=%u blend=%s format=%u", op_class->shader_name, - version_string + 1, flags, color_states, variation, @@ -980,9 +972,8 @@ gsk_vulkan_device_get_vk_pipeline (GskVulkanDevice *self, vk_format); GSK_DEBUG (SHADERS, - "Create Vulkan pipeline (%s %s, %u/%u/%u/%s/%u)", + "Create Vulkan pipeline (%s, %u/%u/%u/%s/%u)", op_class->shader_name, - version_string + 1, flags, color_states, variation, diff --git a/gsk/gpu/shaders/common-vulkan.glsl b/gsk/gpu/shaders/common-vulkan.glsl index 933f806171..627e64ba20 100644 --- a/gsk/gpu/shaders/common-vulkan.glsl +++ b/gsk/gpu/shaders/common-vulkan.glsl @@ -1,7 +1,3 @@ -#ifdef HAVE_VULKAN_1_2 -#extension GL_EXT_nonuniform_qualifier : enable -#endif - #include "enums.glsl" layout(push_constant) uniform PushConstants { diff --git a/gsk/gpu/shaders/meson.build b/gsk/gpu/shaders/meson.build index 59d4288a2a..e58bf9ab60 100644 --- a/gsk/gpu/shaders/meson.build +++ b/gsk/gpu/shaders/meson.build @@ -61,27 +61,13 @@ foreach shader: gsk_private_gpu_shaders if (have_vulkan) glslc_options = [ - [ fs.name (fs.replace_suffix (shader, '')) + '.1.2.vert.spv', - [ '--target-env=vulkan1.2', - '-fshader-stage=vertex', - '-DGSK_VERTEX_SHADER=1', - '-DHAVE_VULKAN_1_2=1' - ] - ], - [ fs.name (fs.replace_suffix (shader, '')) + '.1.2.frag.spv', - [ '--target-env=vulkan1.2', - '-fshader-stage=fragment', - '-DGSK_FRAGMENT_SHADER=1', - '-DHAVE_VULKAN_1_2=1' - ] - ], - [ fs.name (fs.replace_suffix (shader, '')) + '.1.0.vert.spv', + [ fs.name (fs.replace_suffix (shader, '')) + '.vert.spv', [ '--target-env=vulkan1.0', '-fshader-stage=vertex', '-DGSK_VERTEX_SHADER=1', ] ], - [ fs.name (fs.replace_suffix (shader, '')) + '.1.0.frag.spv', + [ fs.name (fs.replace_suffix (shader, '')) + '.frag.spv', [ '--target-env=vulkan1.0', '-fshader-stage=fragment', '-DGSK_FRAGMENT_SHADER=1', From 14a7b4b4b485f70702bea8fe9294233ad60a3624 Mon Sep 17 00:00:00 2001 From: Benjamin Otte Date: Sun, 21 Jul 2024 14:50:02 +0200 Subject: [PATCH 22/28] vulkan: Remove unused features Now that we don't use the fancy features anymore, we don't need to enable them. And that also means we don't need an env var to disable it for testing. --- gdk/gdkdisplayprivate.h | 9 +++------ gdk/gdkvulkancontext.c | 32 -------------------------------- gsk/gpu/gskgpushaderop.c | 4 +--- 3 files changed, 4 insertions(+), 41 deletions(-) diff --git a/gdk/gdkdisplayprivate.h b/gdk/gdkdisplayprivate.h index d0f02f2cba..2bb3c759e5 100644 --- a/gdk/gdkdisplayprivate.h +++ b/gdk/gdkdisplayprivate.h @@ -45,12 +45,9 @@ typedef struct _GdkDisplayClass GdkDisplayClass; typedef enum { GDK_VULKAN_FEATURE_DMABUF = 1 << 0, GDK_VULKAN_FEATURE_YCBCR = 1 << 1, - GDK_VULKAN_FEATURE_DESCRIPTOR_INDEXING = 1 << 2, - GDK_VULKAN_FEATURE_DYNAMIC_INDEXING = 1 << 3, - GDK_VULKAN_FEATURE_NONUNIFORM_INDEXING = 1 << 4, - GDK_VULKAN_FEATURE_SEMAPHORE_EXPORT = 1 << 5, - GDK_VULKAN_FEATURE_SEMAPHORE_IMPORT = 1 << 6, - GDK_VULKAN_FEATURE_INCREMENTAL_PRESENT = 1 << 7, + GDK_VULKAN_FEATURE_SEMAPHORE_EXPORT = 1 << 2, + GDK_VULKAN_FEATURE_SEMAPHORE_IMPORT = 1 << 3, + GDK_VULKAN_FEATURE_INCREMENTAL_PRESENT = 1 << 4, } GdkVulkanFeatures; /* Tracks information about the device grab on this display */ diff --git a/gdk/gdkvulkancontext.c b/gdk/gdkvulkancontext.c index 2d667238b5..0c320a9dc8 100644 --- a/gdk/gdkvulkancontext.c +++ b/gdk/gdkvulkancontext.c @@ -38,9 +38,6 @@ static const GdkDebugKey gsk_vulkan_feature_keys[] = { { "dmabuf", GDK_VULKAN_FEATURE_DMABUF, "Never import Dmabufs" }, { "ycbcr", GDK_VULKAN_FEATURE_YCBCR, "Do not support Ycbcr textures (also disables dmabufs)" }, - { "descriptor-indexing", GDK_VULKAN_FEATURE_DESCRIPTOR_INDEXING, "Force slow descriptor set layout codepath" }, - { "dynamic-indexing", GDK_VULKAN_FEATURE_DYNAMIC_INDEXING, "Hardcode small number of buffer and texture arrays" }, - { "nonuniform-indexing", GDK_VULKAN_FEATURE_NONUNIFORM_INDEXING, "Split draw calls to ensure uniform texture accesses" }, { "semaphore-export", GDK_VULKAN_FEATURE_SEMAPHORE_EXPORT, "Disable sync of exported dmabufs" }, { "semaphore-import", GDK_VULKAN_FEATURE_SEMAPHORE_IMPORT, "Disable sync of imported dmabufs" }, { "incremental-present", GDK_VULKAN_FEATURE_INCREMENTAL_PRESENT, "Do not send damage regions" }, @@ -585,23 +582,6 @@ physical_device_check_features (VkPhysicalDevice device) features = 0; - if (v10_features.features.shaderUniformBufferArrayDynamicIndexing && - v10_features.features.shaderSampledImageArrayDynamicIndexing) - features |= GDK_VULKAN_FEATURE_DYNAMIC_INDEXING; - - if (v12_features.descriptorIndexing && - v12_features.descriptorBindingPartiallyBound && - v12_features.descriptorBindingVariableDescriptorCount && - v12_features.descriptorBindingSampledImageUpdateAfterBind && - v12_features.descriptorBindingStorageBufferUpdateAfterBind) - features |= GDK_VULKAN_FEATURE_DESCRIPTOR_INDEXING; - else if (physical_device_supports_extension (device, VK_EXT_DESCRIPTOR_INDEXING_EXTENSION_NAME)) - features |= GDK_VULKAN_FEATURE_DESCRIPTOR_INDEXING; - - if (v12_features.shaderSampledImageArrayNonUniformIndexing && - v12_features.shaderStorageBufferArrayNonUniformIndexing) - features |= GDK_VULKAN_FEATURE_NONUNIFORM_INDEXING; - if (ycbcr_features.samplerYcbcrConversion || physical_device_supports_extension (device, VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME)) features |= GDK_VULKAN_FEATURE_YCBCR; @@ -1532,8 +1512,6 @@ gdk_display_create_vulkan_device (GdkDisplay *display, device_extensions = g_ptr_array_new (); g_ptr_array_add (device_extensions, (gpointer) VK_KHR_SWAPCHAIN_EXTENSION_NAME); - if (features & GDK_VULKAN_FEATURE_DESCRIPTOR_INDEXING) - g_ptr_array_add (device_extensions, (gpointer) VK_EXT_DESCRIPTOR_INDEXING_EXTENSION_NAME); if (features & GDK_VULKAN_FEATURE_YCBCR) { g_ptr_array_add (device_extensions, (gpointer) VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME); @@ -1576,16 +1554,6 @@ gdk_display_create_vulkan_device (GdkDisplay *display, .pNext = &(VkPhysicalDeviceVulkan11Features) { .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES, .samplerYcbcrConversion = ENABLE_IF (GDK_VULKAN_FEATURE_YCBCR), - .pNext = &(VkPhysicalDeviceVulkan12Features) { - .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES, - .shaderSampledImageArrayNonUniformIndexing = ENABLE_IF (GDK_VULKAN_FEATURE_NONUNIFORM_INDEXING), - .shaderStorageBufferArrayNonUniformIndexing = ENABLE_IF (GDK_VULKAN_FEATURE_NONUNIFORM_INDEXING), - .descriptorIndexing = ENABLE_IF (GDK_VULKAN_FEATURE_DESCRIPTOR_INDEXING), - .descriptorBindingPartiallyBound = ENABLE_IF (GDK_VULKAN_FEATURE_DESCRIPTOR_INDEXING), - .descriptorBindingVariableDescriptorCount = ENABLE_IF (GDK_VULKAN_FEATURE_DESCRIPTOR_INDEXING), - .descriptorBindingSampledImageUpdateAfterBind = ENABLE_IF (GDK_VULKAN_FEATURE_DESCRIPTOR_INDEXING), - .descriptorBindingStorageBufferUpdateAfterBind = ENABLE_IF (GDK_VULKAN_FEATURE_DESCRIPTOR_INDEXING), - } } }, NULL, diff --git a/gsk/gpu/gskgpushaderop.c b/gsk/gpu/gskgpushaderop.c index a211cf7d24..9cf91e1953 100644 --- a/gsk/gpu/gskgpushaderop.c +++ b/gsk/gpu/gskgpushaderop.c @@ -74,9 +74,7 @@ gsk_gpu_shader_op_vk_command_n (GskGpuOp *op, VkPipelineLayout vk_pipeline_layout; gsize i, n_ops, max_ops_per_draw; - if (gsk_gpu_frame_should_optimize (frame, GSK_GPU_OPTIMIZE_MERGE) && - gsk_vulkan_device_has_feature (GSK_VULKAN_DEVICE (gsk_gpu_frame_get_device (frame)), - GDK_VULKAN_FEATURE_NONUNIFORM_INDEXING)) + if (gsk_gpu_frame_should_optimize (frame, GSK_GPU_OPTIMIZE_MERGE)) max_ops_per_draw = MAX_MERGE_OPS; else max_ops_per_draw = 1; From 7dd3680d7d8d63c5dbe649f9e681cdd5bec8073f Mon Sep 17 00:00:00 2001 From: Benjamin Otte Date: Mon, 22 Jul 2024 01:15:01 +0200 Subject: [PATCH 23/28] gpu: Refactor code a bit Turn the 2 ways to construct cached items into 2 constructors. Useful for next commit. --- gsk/gpu/gskgpucache.c | 23 +++++++++++++++-------- 1 file changed, 15 insertions(+), 8 deletions(-) diff --git a/gsk/gpu/gskgpucache.c b/gsk/gpu/gskgpucache.c index 49823e0f17..7d571d0f08 100644 --- a/gsk/gpu/gskgpucache.c +++ b/gsk/gpu/gskgpucache.c @@ -130,9 +130,9 @@ gsk_gpu_cached_should_collect (GskGpuCache *cache, } static gpointer -gsk_gpu_cached_new (GskGpuCache *cache, - const GskGpuCachedClass *class, - GskGpuCachedAtlas *atlas) +gsk_gpu_cached_new_from_atlas (GskGpuCache *cache, + const GskGpuCachedClass *class, + GskGpuCachedAtlas *atlas) { GskGpuCached *cached; @@ -151,6 +151,13 @@ gsk_gpu_cached_new (GskGpuCache *cache, return cached; } +static gpointer +gsk_gpu_cached_new (GskGpuCache *cache, + const GskGpuCachedClass *class) +{ + return gsk_gpu_cached_new_from_atlas (cache, class, NULL); +} + static void gsk_gpu_cached_use (GskGpuCache *self, GskGpuCached *cached) @@ -240,7 +247,7 @@ gsk_gpu_cached_atlas_new (GskGpuCache *cache) { GskGpuCachedAtlas *self; - self = gsk_gpu_cached_new (cache, &GSK_GPU_CACHED_ATLAS_CLASS, NULL); + self = gsk_gpu_cached_new (cache, &GSK_GPU_CACHED_ATLAS_CLASS); self->image = gsk_gpu_device_create_atlas_image (cache->device, ATLAS_SIZE, ATLAS_SIZE); self->remaining_pixels = gsk_gpu_image_get_width (self->image) * gsk_gpu_image_get_height (self->image); @@ -525,7 +532,7 @@ gsk_gpu_cached_texture_new (GskGpuCache *cache, } } - self = gsk_gpu_cached_new (cache, &GSK_GPU_CACHED_TEXTURE_CLASS, NULL); + self = gsk_gpu_cached_new (cache, &GSK_GPU_CACHED_TEXTURE_CLASS); self->texture = texture; self->image = g_object_ref (image); self->color_state = color_state; @@ -665,7 +672,7 @@ gsk_gpu_cached_tile_new (GskGpuCache *cache, { GskGpuCachedTile *self; - self = gsk_gpu_cached_new (cache, &GSK_GPU_CACHED_TILE_CLASS, NULL); + self = gsk_gpu_cached_new (cache, &GSK_GPU_CACHED_TILE_CLASS); self->texture = texture; self->tile_id = tile_id; self->image = g_object_ref (image); @@ -1092,7 +1099,7 @@ gsk_gpu_cache_lookup_glyph_image (GskGpuCache *self, g_object_ref (image); rect.origin.x = atlas_x + padding; rect.origin.y = atlas_y + padding; - cache = gsk_gpu_cached_new (self, &GSK_GPU_CACHED_GLYPH_CLASS, self->current_atlas); + cache = gsk_gpu_cached_new_from_atlas (self, &GSK_GPU_CACHED_GLYPH_CLASS, self->current_atlas); } else { @@ -1100,7 +1107,7 @@ gsk_gpu_cache_lookup_glyph_image (GskGpuCache *self, rect.origin.x = 0; rect.origin.y = 0; padding = 0; - cache = gsk_gpu_cached_new (self, &GSK_GPU_CACHED_GLYPH_CLASS, NULL); + cache = gsk_gpu_cached_new (self, &GSK_GPU_CACHED_GLYPH_CLASS); } cache->font = g_object_ref (font); From 5e027ae5d98cb4b1b18cc6d3460d60e4d4b1a384 Mon Sep 17 00:00:00 2001 From: Benjamin Otte Date: Mon, 22 Jul 2024 01:17:19 +0200 Subject: [PATCH 24/28] gpu: Allow creating GskGpuCached objects externally Export the GskGpuCached and GskGpuCachedClass objects in the header, and make gsk_gpu_cached_new() available. --- gsk/gpu/gskgpucache.c | 31 +------------------------------ gsk/gpu/gskgpucacheprivate.h | 34 ++++++++++++++++++++++++++++++++++ 2 files changed, 35 insertions(+), 30 deletions(-) diff --git a/gsk/gpu/gskgpucache.c b/gsk/gpu/gskgpucache.c index 7d571d0f08..1c02d3a50a 100644 --- a/gsk/gpu/gskgpucache.c +++ b/gsk/gpu/gskgpucache.c @@ -27,9 +27,6 @@ G_STATIC_ASSERT (MAX_ATLAS_ITEM_SIZE < ATLAS_SIZE); G_STATIC_ASSERT (MIN_ALIVE_PIXELS < ATLAS_SIZE * ATLAS_SIZE); -typedef struct _GskGpuCached GskGpuCached; -typedef struct _GskGpuCachedClass GskGpuCachedClass; -typedef struct _GskGpuCachedAtlas GskGpuCachedAtlas; typedef struct _GskGpuCachedGlyph GskGpuCachedGlyph; typedef struct _GskGpuCachedTexture GskGpuCachedTexture; typedef struct _GskGpuCachedTile GskGpuCachedTile; @@ -58,32 +55,6 @@ G_DEFINE_TYPE (GskGpuCache, gsk_gpu_cache, G_TYPE_OBJECT) /* {{{ Cached base class */ -struct _GskGpuCachedClass -{ - gsize size; - const char *name; - - void (* free) (GskGpuCache *cache, - GskGpuCached *cached); - gboolean (* should_collect) (GskGpuCache *cache, - GskGpuCached *cached, - gint64 cache_timeout, - gint64 timestamp); -}; - -struct _GskGpuCached -{ - const GskGpuCachedClass *class; - - GskGpuCachedAtlas *atlas; - GskGpuCached *next; - GskGpuCached *prev; - - gint64 timestamp; - gboolean stale; - guint pixels; /* For glyphs and textures, pixels. For atlases, alive pixels */ -}; - static inline void mark_as_stale (GskGpuCached *cached, gboolean stale) @@ -151,7 +122,7 @@ gsk_gpu_cached_new_from_atlas (GskGpuCache *cache, return cached; } -static gpointer +gpointer gsk_gpu_cached_new (GskGpuCache *cache, const GskGpuCachedClass *class) { diff --git a/gsk/gpu/gskgpucacheprivate.h b/gsk/gpu/gskgpucacheprivate.h index 002756b5b7..e4e23e51b5 100644 --- a/gsk/gpu/gskgpucacheprivate.h +++ b/gsk/gpu/gskgpucacheprivate.h @@ -6,6 +6,36 @@ G_BEGIN_DECLS +typedef struct _GskGpuCached GskGpuCached; +typedef struct _GskGpuCachedClass GskGpuCachedClass; +typedef struct _GskGpuCachedAtlas GskGpuCachedAtlas; + +struct _GskGpuCachedClass +{ + gsize size; + const char *name; + + void (* free) (GskGpuCache *cache, + GskGpuCached *cached); + gboolean (* should_collect) (GskGpuCache *cache, + GskGpuCached *cached, + gint64 cache_timeout, + gint64 timestamp); +}; + +struct _GskGpuCached +{ + const GskGpuCachedClass *class; + + GskGpuCachedAtlas *atlas; + GskGpuCached *next; + GskGpuCached *prev; + + gint64 timestamp; + gboolean stale; + guint pixels; /* For glyphs and textures, pixels. For atlases, alive pixels */ +}; + #define GSK_TYPE_GPU_CACHE (gsk_gpu_cache_get_type ()) #define GSK_GPU_CACHE(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), GSK_TYPE_GPU_CACHE, GskGpuCache)) #define GSK_GPU_CACHE_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), GSK_TYPE_GPU_CACHE, GskGpuCacheClass)) @@ -24,8 +54,12 @@ GType gsk_gpu_cache_get_type (void) G GskGpuCache * gsk_gpu_cache_new (GskGpuDevice *device); +gpointer gsk_gpu_cached_new (GskGpuCache *cache, + const GskGpuCachedClass *class); + void gsk_gpu_cache_set_time (GskGpuCache *self, gint64 timestamp); + gboolean gsk_gpu_cache_gc (GskGpuCache *self, gint64 cache_timeout, gint64 timestamp); From 762b981dfe1fff8d1edb548276522a07d8b72200 Mon Sep 17 00:00:00 2001 From: Benjamin Otte Date: Mon, 22 Jul 2024 01:18:44 +0200 Subject: [PATCH 25/28] gpu: Make the device queryable from the cache That's needed in cached subclasses during destruction, when they want to destroy system resources. --- gsk/gpu/gskgpucache.c | 6 ++++++ gsk/gpu/gskgpucacheprivate.h | 1 + 2 files changed, 7 insertions(+) diff --git a/gsk/gpu/gskgpucache.c b/gsk/gpu/gskgpucache.c index 1c02d3a50a..590b464192 100644 --- a/gsk/gpu/gskgpucache.c +++ b/gsk/gpu/gskgpucache.c @@ -785,6 +785,12 @@ static const GskGpuCachedClass GSK_GPU_CACHED_GLYPH_CLASS = /* }}} */ /* {{{ GskGpuCache */ +GskGpuDevice * +gsk_gpu_cache_get_device (GskGpuCache *self) +{ + return self->device; +} + /* * gsk_gpu_cache_set_time: * @self: a `GskGpuCache` diff --git a/gsk/gpu/gskgpucacheprivate.h b/gsk/gpu/gskgpucacheprivate.h index e4e23e51b5..aa7ce2764c 100644 --- a/gsk/gpu/gskgpucacheprivate.h +++ b/gsk/gpu/gskgpucacheprivate.h @@ -57,6 +57,7 @@ GskGpuCache * gsk_gpu_cache_new (GskGpuD gpointer gsk_gpu_cached_new (GskGpuCache *cache, const GskGpuCachedClass *class); +GskGpuDevice * gsk_gpu_cache_get_device (GskGpuCache *self); void gsk_gpu_cache_set_time (GskGpuCache *self, gint64 timestamp); From 67b9fb43d04b39dbf0a665a7a1378553081cdefe Mon Sep 17 00:00:00 2001 From: Benjamin Otte Date: Mon, 22 Jul 2024 01:24:52 +0200 Subject: [PATCH 26/28] gpu: Completely revamp YCbCr handling There is now a GskGpuYcbcr struct that maintains all the Vulkan machinery related to YCbCrConversions. It's a GskGpuCached, so it will make itself go away when it is no longer used, ie a video stopped playing. --- gsk/gpu/gskgpushaderop.c | 4 +- gsk/gpu/gskvulkandevice.c | 140 ++++++++------------- gsk/gpu/gskvulkandeviceprivate.h | 18 ++- gsk/gpu/gskvulkanimage.c | 29 +++-- gsk/gpu/gskvulkanimageprivate.h | 2 +- gsk/gpu/gskvulkanycbcr.c | 203 +++++++++++++++++++++++++++++++ gsk/gpu/gskvulkanycbcrprivate.h | 23 ++++ gsk/meson.build | 1 + 8 files changed, 313 insertions(+), 107 deletions(-) create mode 100644 gsk/gpu/gskvulkanycbcr.c create mode 100644 gsk/gpu/gskvulkanycbcrprivate.h diff --git a/gsk/gpu/gskgpushaderop.c b/gsk/gpu/gskgpushaderop.c index 9cf91e1953..874f533e10 100644 --- a/gsk/gpu/gskgpushaderop.c +++ b/gsk/gpu/gskgpushaderop.c @@ -96,7 +96,9 @@ gsk_gpu_shader_op_vk_command_n (GskGpuOp *op, n_ops += next_shader->n_ops; } - vk_pipeline_layout = gsk_vulkan_device_get_default_vk_pipeline_layout (GSK_VULKAN_DEVICE (gsk_gpu_frame_get_device (frame))); + vk_pipeline_layout = gsk_vulkan_device_get_vk_pipeline_layout (GSK_VULKAN_DEVICE (gsk_gpu_frame_get_device (frame)), + shader_op_class->n_textures > 0 ? gsk_vulkan_image_get_ycbcr (GSK_VULKAN_IMAGE (self->images[0])) : NULL, + shader_op_class->n_textures > 1 ? gsk_vulkan_image_get_ycbcr (GSK_VULKAN_IMAGE (self->images[1])) : NULL); for (i = 0; i < shader_op_class->n_textures; i++) { diff --git a/gsk/gpu/gskvulkandevice.c b/gsk/gpu/gskvulkandevice.c index 8b0db38e6a..c39a04ca2e 100644 --- a/gsk/gpu/gskvulkandevice.c +++ b/gsk/gpu/gskvulkandevice.c @@ -6,6 +6,7 @@ #include "gskgpushaderopprivate.h" #include "gskvulkanbufferprivate.h" #include "gskvulkanimageprivate.h" +#include "gskvulkanycbcrprivate.h" #include "gdk/gdkdisplayprivate.h" #include "gdk/gdkvulkancontextprivate.h" @@ -19,7 +20,7 @@ struct _GskVulkanDevice GskVulkanAllocator *external_allocator; GdkVulkanFeatures features; - GHashTable *conversion_cache; + GHashTable *ycbcr_cache; GHashTable *render_pass_cache; GHashTable *pipeline_cache; @@ -70,24 +71,6 @@ struct _RenderPassCacheKey VkRenderPass render_pass; }; -static guint -conversion_cache_entry_hash (gconstpointer data) -{ - const ConversionCacheEntry *key = data; - - return key->vk_format; -} - -static gboolean -conversion_cache_entry_equal (gconstpointer a, - gconstpointer b) -{ - const ConversionCacheEntry *keya = a; - const ConversionCacheEntry *keyb = b; - - return keya->vk_format == keyb->vk_format; -} - static guint pipeline_cache_key_hash (gconstpointer data) { @@ -141,8 +124,7 @@ render_pass_cache_key_equal (gconstpointer a, } static VkDescriptorSetLayout -gsk_vulkan_device_create_vk_image_set_layout (GskVulkanDevice *self, - VkSampler immutable_sampler) +gsk_vulkan_device_create_vk_image_set_layout (GskVulkanDevice *self) { VkDevice vk_device; VkDescriptorSetLayout result; @@ -160,9 +142,6 @@ gsk_vulkan_device_create_vk_image_set_layout (GskVulkanDevice *self, .descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, .descriptorCount = 1, .stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT, - .pImmutableSamplers = immutable_sampler == VK_NULL_HANDLE ? NULL : (VkSampler[1]) { - immutable_sampler, - }, } }, }, @@ -172,7 +151,7 @@ gsk_vulkan_device_create_vk_image_set_layout (GskVulkanDevice *self, return result; } -static VkPipelineLayout +VkPipelineLayout gsk_vulkan_device_create_vk_pipeline_layout (GskVulkanDevice *self, VkDescriptorSetLayout image1_layout, VkDescriptorSetLayout image2_layout) @@ -302,6 +281,9 @@ gsk_vulkan_device_finalize (GObject *object) g_object_steal_data (G_OBJECT (display), "-gsk-vulkan-device"); + g_assert (g_hash_table_size (self->ycbcr_cache) == 0); + g_hash_table_unref (self->ycbcr_cache); + g_hash_table_iter_init (&iter, self->pipeline_cache); while (g_hash_table_iter_next (&iter, &key, &value)) { @@ -312,16 +294,6 @@ gsk_vulkan_device_finalize (GObject *object) } g_hash_table_unref (self->pipeline_cache); - g_hash_table_iter_init (&iter, self->conversion_cache); - while (g_hash_table_iter_next (&iter, &key, &value)) - { - ConversionCacheEntry *entry = key; - vkDestroySamplerYcbcrConversion (vk_device, entry->vk_conversion, NULL); - vkDestroySampler (vk_device, entry->vk_sampler, NULL); - g_free (key); - } - g_hash_table_unref (self->conversion_cache); - g_hash_table_iter_init (&iter, self->render_pass_cache); while (g_hash_table_iter_next (&iter, &key, &value)) { @@ -380,7 +352,7 @@ gsk_vulkan_device_class_init (GskVulkanDeviceClass *klass) static void gsk_vulkan_device_init (GskVulkanDevice *self) { - self->conversion_cache = g_hash_table_new (conversion_cache_entry_hash, conversion_cache_entry_equal); + self->ycbcr_cache = g_hash_table_new (g_direct_hash, g_direct_equal); self->render_pass_cache = g_hash_table_new (render_pass_cache_key_hash, render_pass_cache_key_equal); self->pipeline_cache = g_hash_table_new (pipeline_cache_key_hash, pipeline_cache_key_equal); } @@ -416,7 +388,7 @@ gsk_vulkan_device_create_vk_objects (GskVulkanDevice *self) NULL, &self->vk_descriptor_pool); - self->vk_image_set_layout = gsk_vulkan_device_create_vk_image_set_layout (self, NULL); + self->vk_image_set_layout = gsk_vulkan_device_create_vk_image_set_layout (self); self->default_vk_pipeline_layout = gsk_vulkan_device_create_vk_pipeline_layout (self, self->vk_image_set_layout, @@ -507,6 +479,30 @@ gsk_vulkan_device_get_default_vk_pipeline_layout (GskVulkanDevice *self) return self->default_vk_pipeline_layout; } +VkPipelineLayout +gsk_vulkan_device_get_vk_pipeline_layout (GskVulkanDevice *self, + GskVulkanYcbcr *ycbcr0, + GskVulkanYcbcr *ycbcr1) +{ + if (ycbcr0 == VK_NULL_HANDLE) + { + if (ycbcr1 == VK_NULL_HANDLE) + return self->default_vk_pipeline_layout; + else + return gsk_vulkan_ycbcr_get_vk_pipeline_layout (ycbcr1, 1); + } + else + { + if (ycbcr1 == VK_NULL_HANDLE) + return gsk_vulkan_ycbcr_get_vk_pipeline_layout (ycbcr0, 0); + else + { + /* FIXME: someone write a test plz */ + g_assert_not_reached (); + } + } +} + VkCommandPool gsk_vulkan_device_get_vk_command_pool (GskVulkanDevice *self) { @@ -609,64 +605,26 @@ gsk_vulkan_device_get_vk_sampler (GskVulkanDevice *self, return self->vk_samplers[sampler]; } -VkSamplerYcbcrConversion -gsk_vulkan_device_get_vk_conversion (GskVulkanDevice *self, - VkFormat vk_format, - VkSampler *out_sampler) +GskVulkanYcbcr * +gsk_vulkan_device_get_ycbcr (GskVulkanDevice *self, + VkFormat vk_format) { - ConversionCacheEntry lookup; - ConversionCacheEntry *entry; - GdkDisplay *display; + GskVulkanYcbcr *ycbcr; - lookup = (ConversionCacheEntry) { - .vk_format = vk_format, - }; - entry = g_hash_table_lookup (self->conversion_cache, &lookup); - if (entry) - { - if (out_sampler) - *out_sampler = entry->vk_sampler; + ycbcr = g_hash_table_lookup (self->ycbcr_cache, GSIZE_TO_POINTER(vk_format)); + if (ycbcr) + return ycbcr; - return entry->vk_conversion; - } + ycbcr = gsk_vulkan_ycbcr_new (self, vk_format); + g_hash_table_insert (self->ycbcr_cache, GSIZE_TO_POINTER(vk_format), ycbcr); + return ycbcr; +} - display = gsk_gpu_device_get_display (GSK_GPU_DEVICE (self)); - - entry = g_memdup (&lookup, sizeof (ConversionCacheEntry)); - - GSK_VK_CHECK (vkCreateSamplerYcbcrConversion, display->vk_device, - &(VkSamplerYcbcrConversionCreateInfo) { - .sType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO, - .format = vk_format, - .ycbcrModel = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601, - .ycbcrRange = VK_SAMPLER_YCBCR_RANGE_ITU_NARROW, - .components = (VkComponentMapping) { - VK_COMPONENT_SWIZZLE_IDENTITY, - VK_COMPONENT_SWIZZLE_IDENTITY, - VK_COMPONENT_SWIZZLE_IDENTITY, - VK_COMPONENT_SWIZZLE_IDENTITY - }, - .xChromaOffset = VK_CHROMA_LOCATION_COSITED_EVEN, - .yChromaOffset = VK_CHROMA_LOCATION_COSITED_EVEN, - .chromaFilter = VK_FILTER_LINEAR, - .forceExplicitReconstruction = VK_FALSE - }, - NULL, - &entry->vk_conversion); - - entry->vk_sampler = gsk_vulkan_device_create_sampler (self, - entry->vk_conversion, - VK_FILTER_LINEAR, - VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, - VK_SAMPLER_MIPMAP_MODE_NEAREST, - 0.0f); - - g_hash_table_insert (self->conversion_cache, entry, entry); - - if (out_sampler) - *out_sampler = entry->vk_sampler; - - return entry->vk_conversion; +void +gsk_vulkan_device_remove_ycbcr (GskVulkanDevice *self, + VkFormat vk_format) +{ + g_hash_table_remove (self->ycbcr_cache, GSIZE_TO_POINTER(vk_format)); } VkRenderPass diff --git a/gsk/gpu/gskvulkandeviceprivate.h b/gsk/gpu/gskvulkandeviceprivate.h index e623dd2b8f..2b171084b0 100644 --- a/gsk/gpu/gskvulkandeviceprivate.h +++ b/gsk/gpu/gskvulkandeviceprivate.h @@ -11,6 +11,9 @@ G_BEGIN_DECLS +/* forward declaration */ +typedef struct _GskVulkanYcbcr GskVulkanYcbcr; + #define GSK_TYPE_VULKAN_DEVICE (gsk_vulkan_device_get_type ()) G_DECLARE_FINAL_TYPE(GskVulkanDevice, gsk_vulkan_device, GSK, VULKAN_DEVICE, GskGpuDevice) @@ -28,14 +31,21 @@ uint32_t gsk_vulkan_device_get_vk_queue_family_index (GskVulk VkCommandPool gsk_vulkan_device_get_vk_command_pool (GskVulkanDevice *self) G_GNUC_PURE; VkDescriptorPool gsk_vulkan_device_get_vk_descriptor_pool (GskVulkanDevice *self) G_GNUC_PURE; VkDescriptorSetLayout gsk_vulkan_device_get_vk_image_set_layout (GskVulkanDevice *self) G_GNUC_PURE; +VkPipelineLayout gsk_vulkan_device_create_vk_pipeline_layout (GskVulkanDevice *self, + VkDescriptorSetLayout image1_layout, + VkDescriptorSetLayout image2_layout); VkPipelineLayout gsk_vulkan_device_get_default_vk_pipeline_layout (GskVulkanDevice *self) G_GNUC_PURE; +VkPipelineLayout gsk_vulkan_device_get_vk_pipeline_layout (GskVulkanDevice *self, + GskVulkanYcbcr *ycbcr0, + GskVulkanYcbcr *ycbcr1); VkSampler gsk_vulkan_device_get_vk_sampler (GskVulkanDevice *self, GskGpuSampler sampler) G_GNUC_PURE; -VkSamplerYcbcrConversion - gsk_vulkan_device_get_vk_conversion (GskVulkanDevice *self, - VkFormat vk_format, - VkSampler *out_sampler); +GskVulkanYcbcr * gsk_vulkan_device_get_ycbcr (GskVulkanDevice *self, + VkFormat vk_format); +void gsk_vulkan_device_remove_ycbcr (GskVulkanDevice *self, + VkFormat vk_format); + VkRenderPass gsk_vulkan_device_get_vk_render_pass (GskVulkanDevice *self, VkFormat format, VkImageLayout from_layout, diff --git a/gsk/gpu/gskvulkanimage.c b/gsk/gpu/gskvulkanimage.c index 0502f76319..47feebb183 100644 --- a/gsk/gpu/gskvulkanimage.c +++ b/gsk/gpu/gskvulkanimage.c @@ -5,6 +5,7 @@ #include "gskvulkanbufferprivate.h" #include "gskvulkanframeprivate.h" #include "gskvulkanmemoryprivate.h" +#include "gskvulkanycbcrprivate.h" #include "gdk/gdkdisplayprivate.h" #include "gdk/gdkdmabuftextureprivate.h" @@ -31,7 +32,7 @@ struct _GskVulkanImage VkImageView vk_image_view; VkFramebuffer vk_framebuffer; VkImageView vk_framebuffer_image_view; - VkSampler vk_sampler; + GskVulkanYcbcr *ycbcr; VkSemaphore vk_semaphore; VkDescriptorSet vk_descriptor_sets[GSK_GPU_SAMPLER_N_SAMPLERS]; @@ -1115,7 +1116,11 @@ gsk_vulkan_image_new_for_dmabuf (GskVulkanDevice *device, #endif if (is_yuv) - vk_conversion = gsk_vulkan_device_get_vk_conversion (device, vk_format, &self->vk_sampler); + { + self->ycbcr = gsk_vulkan_device_get_ycbcr (device, vk_format); + gsk_vulkan_ycbcr_ref (self->ycbcr); + vk_conversion = gsk_vulkan_ycbcr_get_vk_conversion (self->ycbcr); + } else vk_conversion = VK_NULL_HANDLE; @@ -1290,6 +1295,8 @@ gsk_vulkan_image_finalize (GObject *object) vk_device = gsk_vulkan_device_get_vk_device (self->device); vk_descriptor_pool = gsk_vulkan_device_get_vk_descriptor_pool (self->device); + g_clear_pointer (&self->ycbcr, gsk_vulkan_ycbcr_unref); + for (i = 0; i < GSK_GPU_SAMPLER_N_SAMPLERS; i++) { if (self->vk_descriptor_sets[i]) @@ -1395,12 +1402,6 @@ gsk_vulkan_image_get_vk_framebuffer (GskVulkanImage *self, return self->vk_framebuffer; } -VkSampler -gsk_vulkan_image_get_vk_sampler (GskVulkanImage *self) -{ - return self->vk_sampler; -} - VkDescriptorSet gsk_vulkan_image_get_vk_descriptor_set (GskVulkanImage *self, GskGpuSampler sampler) @@ -1415,7 +1416,8 @@ gsk_vulkan_image_get_vk_descriptor_set (GskVulkanImage *self, .descriptorPool = gsk_vulkan_device_get_vk_descriptor_pool (self->device), .descriptorSetCount = 1, .pSetLayouts = (VkDescriptorSetLayout[1]) { - gsk_vulkan_device_get_vk_image_set_layout (self->device), + self->ycbcr ? gsk_vulkan_ycbcr_get_vk_descriptor_set_layout (self->ycbcr) + : gsk_vulkan_device_get_vk_image_set_layout (self->device), }, }, &self->vk_descriptor_sets[sampler]); @@ -1430,7 +1432,8 @@ gsk_vulkan_image_get_vk_descriptor_set (GskVulkanImage *self, .descriptorCount = 1, .descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, .pImageInfo = &(VkDescriptorImageInfo) { - .sampler = gsk_vulkan_device_get_vk_sampler (self->device, sampler), + .sampler = self->ycbcr ? gsk_vulkan_ycbcr_get_vk_sampler (self->ycbcr) + : gsk_vulkan_device_get_vk_sampler (self->device, sampler), .imageView = self->vk_image_view, .imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL }, @@ -1442,6 +1445,12 @@ gsk_vulkan_image_get_vk_descriptor_set (GskVulkanImage *self, return self->vk_descriptor_sets[sampler]; } +GskVulkanYcbcr * +gsk_vulkan_image_get_ycbcr (GskVulkanImage *self) +{ + return self->ycbcr; +} + VkImage gsk_vulkan_image_get_vk_image (GskVulkanImage *self) { diff --git a/gsk/gpu/gskvulkanimageprivate.h b/gsk/gpu/gskvulkanimageprivate.h index 8346d23144..1db0e9fe2b 100644 --- a/gsk/gpu/gskvulkanimageprivate.h +++ b/gsk/gpu/gskvulkanimageprivate.h @@ -50,7 +50,7 @@ GdkTexture * gsk_vulkan_image_to_dmabuf_texture (GskVulk guchar * gsk_vulkan_image_get_data (GskVulkanImage *self, gsize *out_stride); -VkSampler gsk_vulkan_image_get_vk_sampler (GskVulkanImage *self); +GskVulkanYcbcr * gsk_vulkan_image_get_ycbcr (GskVulkanImage *self); VkDescriptorSet gsk_vulkan_image_get_vk_descriptor_set (GskVulkanImage *self, GskGpuSampler sampler); VkPipelineStageFlags gsk_vulkan_image_get_vk_pipeline_stage (GskVulkanImage *self); diff --git a/gsk/gpu/gskvulkanycbcr.c b/gsk/gpu/gskvulkanycbcr.c new file mode 100644 index 0000000000..4d6076dc24 --- /dev/null +++ b/gsk/gpu/gskvulkanycbcr.c @@ -0,0 +1,203 @@ +#include "config.h" + +#include "gskvulkanycbcrprivate.h" + +#include "gskgpucacheprivate.h" + +struct _GskVulkanYcbcr +{ + GskGpuCached parent; + + int ref_count; + + VkFormat vk_format; + VkSamplerYcbcrConversion vk_conversion; + VkSampler vk_sampler; + VkDescriptorSetLayout vk_descriptor_set_layout; + VkPipelineLayout vk_pipeline_layouts[2]; +}; + +static void +gsk_vulkan_ycbcr_free (GskGpuCache *cache, + GskGpuCached *cached) +{ + GskVulkanYcbcr *self = (GskVulkanYcbcr *) cached; + GskVulkanDevice *device; + VkDevice vk_device; + + device = GSK_VULKAN_DEVICE (gsk_gpu_cache_get_device (cache)); + vk_device = gsk_vulkan_device_get_vk_device (device); + + g_assert (self->ref_count == 0); + + gsk_vulkan_device_remove_ycbcr (device, self->vk_format); + + vkDestroySampler (vk_device, self->vk_sampler, NULL); + vkDestroySamplerYcbcrConversion (vk_device, self->vk_conversion, NULL); + vkDestroyDescriptorSetLayout (vk_device, self->vk_descriptor_set_layout, NULL); + vkDestroyPipelineLayout (vk_device, self->vk_pipeline_layouts[0], NULL); + vkDestroyPipelineLayout (vk_device, self->vk_pipeline_layouts[1], NULL); + + g_free (self); +} + +static inline gboolean +gsk_gpu_cached_is_old (GskGpuCache *self, + GskGpuCached *cached, + gint64 cache_timeout, + gint64 timestamp) +{ + if (cache_timeout < 0) + return -1; + else + return timestamp - cached->timestamp > cache_timeout; +} + +static gboolean +gsk_vulkan_ycbcr_should_collect (GskGpuCache *cache, + GskGpuCached *cached, + gint64 cache_timeout, + gint64 timestamp) +{ + GskVulkanYcbcr *self = (GskVulkanYcbcr *) cached; + + if (self->ref_count > 0) + return FALSE; + + return gsk_gpu_cached_is_old (cache, cached, cache_timeout, timestamp); +} + +static const GskGpuCachedClass GSK_VULKAN_YCBCR_CLASS = +{ + sizeof (GskVulkanYcbcr), + "Vulkan Ycbcr", + gsk_vulkan_ycbcr_free, + gsk_vulkan_ycbcr_should_collect +}; + +GskVulkanYcbcr * +gsk_vulkan_ycbcr_new (GskVulkanDevice *device, + VkFormat vk_format) +{ + GskGpuCache *cache = gsk_gpu_device_get_cache (GSK_GPU_DEVICE (device)); + VkDevice vk_device = gsk_vulkan_device_get_vk_device (device); + VkDescriptorSetLayout vk_image_set_layout; + GskVulkanYcbcr *self; + + self = gsk_gpu_cached_new (cache, &GSK_VULKAN_YCBCR_CLASS); + + self->vk_format = vk_format; + + GSK_VK_CHECK (vkCreateSamplerYcbcrConversion, vk_device, + &(VkSamplerYcbcrConversionCreateInfo) { + .sType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO, + .format = vk_format, + .ycbcrModel = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601, + .ycbcrRange = VK_SAMPLER_YCBCR_RANGE_ITU_NARROW, + .components = (VkComponentMapping) { + VK_COMPONENT_SWIZZLE_IDENTITY, + VK_COMPONENT_SWIZZLE_IDENTITY, + VK_COMPONENT_SWIZZLE_IDENTITY, + VK_COMPONENT_SWIZZLE_IDENTITY + }, + .xChromaOffset = VK_CHROMA_LOCATION_COSITED_EVEN, + .yChromaOffset = VK_CHROMA_LOCATION_COSITED_EVEN, + .chromaFilter = VK_FILTER_LINEAR, + .forceExplicitReconstruction = VK_FALSE + }, + NULL, + &self->vk_conversion); + + GSK_VK_CHECK (vkCreateSampler, vk_device, + &(VkSamplerCreateInfo) { + .sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO, + .magFilter = VK_FILTER_LINEAR, + .minFilter = VK_FILTER_LINEAR, + .mipmapMode = VK_SAMPLER_MIPMAP_MODE_NEAREST, + .addressModeU = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, + .addressModeV = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, + .addressModeW = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, + .borderColor = VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK, + .unnormalizedCoordinates = VK_FALSE, + .maxAnisotropy = 1.0, + .minLod = 0.0, + .maxLod = 0.0f, + .pNext = &(VkSamplerYcbcrConversionInfo) { + .sType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO, + .conversion = self->vk_conversion + } + }, + NULL, + &self->vk_sampler); + + GSK_VK_CHECK (vkCreateDescriptorSetLayout, vk_device, + &(VkDescriptorSetLayoutCreateInfo) { + .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO, + .bindingCount = 1, + .flags = 0, + .pBindings = (VkDescriptorSetLayoutBinding[1]) { + { + .binding = 0, + .descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, + .descriptorCount = 1, + .stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT, + .pImmutableSamplers = (VkSampler[1]) { + self->vk_sampler, + }, + } + }, + }, + NULL, + &self->vk_descriptor_set_layout); + + vk_image_set_layout = gsk_vulkan_device_get_vk_image_set_layout (device); + self->vk_pipeline_layouts[0] = gsk_vulkan_device_create_vk_pipeline_layout (device, + self->vk_descriptor_set_layout, + vk_image_set_layout); + self->vk_pipeline_layouts[1] = gsk_vulkan_device_create_vk_pipeline_layout (device, + vk_image_set_layout, + self->vk_descriptor_set_layout); + + return self; +} + +GskVulkanYcbcr * +gsk_vulkan_ycbcr_ref (GskVulkanYcbcr *self) +{ + self->ref_count++; + + return self; +} + +void +gsk_vulkan_ycbcr_unref (GskVulkanYcbcr *self) +{ + self->ref_count--; +} + +VkSamplerYcbcrConversion +gsk_vulkan_ycbcr_get_vk_conversion (GskVulkanYcbcr *self) +{ + return self->vk_conversion; +} + +VkSampler +gsk_vulkan_ycbcr_get_vk_sampler (GskVulkanYcbcr *self) +{ + return self->vk_sampler; +} + +VkDescriptorSetLayout +gsk_vulkan_ycbcr_get_vk_descriptor_set_layout (GskVulkanYcbcr *self) +{ + return self->vk_descriptor_set_layout; +} + +VkPipelineLayout +gsk_vulkan_ycbcr_get_vk_pipeline_layout (GskVulkanYcbcr *self, + gsize id) +{ + g_assert (id < 2); + + return self->vk_pipeline_layouts[id]; +} diff --git a/gsk/gpu/gskvulkanycbcrprivate.h b/gsk/gpu/gskvulkanycbcrprivate.h new file mode 100644 index 0000000000..203540a6bd --- /dev/null +++ b/gsk/gpu/gskvulkanycbcrprivate.h @@ -0,0 +1,23 @@ +#pragma once + +#include "gskvulkandeviceprivate.h" + +#include "gdk/gdkvulkancontextprivate.h" + +G_BEGIN_DECLS + +GskVulkanYcbcr * gsk_vulkan_ycbcr_new (GskVulkanDevice *self, + VkFormat vk_format); + +GskVulkanYcbcr * gsk_vulkan_ycbcr_ref (GskVulkanYcbcr *self); +void gsk_vulkan_ycbcr_unref (GskVulkanYcbcr *self); + +VkSamplerYcbcrConversion + gsk_vulkan_ycbcr_get_vk_conversion (GskVulkanYcbcr *self); +VkSampler gsk_vulkan_ycbcr_get_vk_sampler (GskVulkanYcbcr *self); +VkDescriptorSetLayout gsk_vulkan_ycbcr_get_vk_descriptor_set_layout (GskVulkanYcbcr *self); +VkPipelineLayout gsk_vulkan_ycbcr_get_vk_pipeline_layout (GskVulkanYcbcr *self, + gsize id); + + +G_END_DECLS diff --git a/gsk/meson.build b/gsk/meson.build index 7f50a73d3a..6cc45edc9d 100644 --- a/gsk/meson.build +++ b/gsk/meson.build @@ -163,6 +163,7 @@ if have_vulkan 'gpu/gskvulkanframe.c', 'gpu/gskvulkanimage.c', 'gpu/gskvulkanmemory.c', + 'gpu/gskvulkanycbcr.c', ]) endif # have_vulkan From 9e27acb0a6d62410f451570c151fe8e669698139 Mon Sep 17 00:00:00 2001 From: Benjamin Otte Date: Mon, 22 Jul 2024 12:55:47 +0200 Subject: [PATCH 27/28] gpu: Allocate Vulkan descriptor pools dynamically Instead of allocating one large descriptor pool and hoping we never run out of descriptors, allocate small ones dynamically, so we know we never run out. Test incldued, though the test doesn't fail in CI, because llvmpipe doesn't care about pool size limits. It does fail on my AMD though. A fun side note about that test is that the GL renderer handles it best in normal operationbecause it caches offscreens per node and we draw the same node repeatedly. But, the replay test expands them to duplicated unique nodes, and then the GL renderer runs out of command queue length, so I had to disable the test on it. --- gsk/gpu/gskvulkandevice.c | 122 ++++++++++++++---- gsk/gpu/gskvulkandeviceprivate.h | 7 +- gsk/gpu/gskvulkanimage.c | 42 +++--- .../gsk/compare/lots-of-offscreens-nogl.node | 64 +++++++++ .../gsk/compare/lots-of-offscreens-nogl.png | Bin 0 -> 110 bytes testsuite/gsk/meson.build | 1 + 6 files changed, 188 insertions(+), 48 deletions(-) create mode 100644 testsuite/gsk/compare/lots-of-offscreens-nogl.node create mode 100644 testsuite/gsk/compare/lots-of-offscreens-nogl.png diff --git a/gsk/gpu/gskvulkandevice.c b/gsk/gpu/gskvulkandevice.c index c39a04ca2e..6323af3d70 100644 --- a/gsk/gpu/gskvulkandevice.c +++ b/gsk/gpu/gskvulkandevice.c @@ -12,6 +12,13 @@ #include "gdk/gdkvulkancontextprivate.h" #include "gdk/gdkprofilerprivate.h" +#define GDK_ARRAY_NAME descriptor_pools +#define GDK_ARRAY_TYPE_NAME DescriptorPools +#define GDK_ARRAY_ELEMENT_TYPE VkDescriptorPool +#define GDK_ARRAY_PREALLOC 4 +#define GDK_ARRAY_NO_MEMSET 1 +#include "gdk/gdkarrayimpl.c" + struct _GskVulkanDevice { GskGpuDevice parent_instance; @@ -25,7 +32,8 @@ struct _GskVulkanDevice GHashTable *pipeline_cache; VkCommandPool vk_command_pool; - VkDescriptorPool vk_descriptor_pool; + DescriptorPools descriptor_pools; + gsize last_pool; VkSampler vk_samplers[GSK_GPU_SAMPLER_N_SAMPLERS]; VkDescriptorSetLayout vk_image_set_layout; VkPipelineLayout default_vk_pipeline_layout; @@ -318,9 +326,11 @@ gsk_vulkan_device_finalize (GObject *object) vkDestroyDescriptorSetLayout (vk_device, self->vk_image_set_layout, NULL); - vkDestroyDescriptorPool (vk_device, - self->vk_descriptor_pool, - NULL); + for (i = 0; i < descriptor_pools_get_size (&self->descriptor_pools); i++) + vkDestroyDescriptorPool (vk_device, + descriptor_pools_get (&self->descriptor_pools, i), + NULL); + descriptor_pools_clear (&self->descriptor_pools); vkDestroyCommandPool (vk_device, self->vk_command_pool, NULL); @@ -355,6 +365,8 @@ gsk_vulkan_device_init (GskVulkanDevice *self) self->ycbcr_cache = g_hash_table_new (g_direct_hash, g_direct_equal); self->render_pass_cache = g_hash_table_new (render_pass_cache_key_hash, render_pass_cache_key_equal); self->pipeline_cache = g_hash_table_new (pipeline_cache_key_hash, pipeline_cache_key_equal); + + descriptor_pools_init (&self->descriptor_pools); } static void @@ -372,21 +384,6 @@ gsk_vulkan_device_create_vk_objects (GskVulkanDevice *self) }, NULL, &self->vk_command_pool); - GSK_VK_CHECK (vkCreateDescriptorPool, vk_device, - &(VkDescriptorPoolCreateInfo) { - .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO, - .flags = VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, - .maxSets = 10000, - .poolSizeCount = 1, - .pPoolSizes = (VkDescriptorPoolSize[1]) { - { - .type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, - .descriptorCount = 10000, - }, - } - }, - NULL, - &self->vk_descriptor_pool); self->vk_image_set_layout = gsk_vulkan_device_create_vk_image_set_layout (self); @@ -509,10 +506,91 @@ gsk_vulkan_device_get_vk_command_pool (GskVulkanDevice *self) return self->vk_command_pool; } -VkDescriptorPool -gsk_vulkan_device_get_vk_descriptor_pool (GskVulkanDevice *self) +VkDescriptorSet +gsk_vulkan_device_allocate_descriptor (GskVulkanDevice *self, + const VkDescriptorSetLayout layout, + gsize *out_pool_id) { - return self->vk_descriptor_pool; + VkDescriptorSet result; + VkDevice vk_device; + VkDescriptorPool new_pool; + gsize i, n; + + vk_device = gsk_vulkan_device_get_vk_device (self); + n = descriptor_pools_get_size (&self->descriptor_pools); + + for (i = 0; i < n; i++) + { + gsize pool_id = (i + self->last_pool) % n; + VkResult res = vkAllocateDescriptorSets (vk_device, + &(VkDescriptorSetAllocateInfo) { + .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO, + .descriptorPool = descriptor_pools_get (&self->descriptor_pools, pool_id), + .descriptorSetCount = 1, + .pSetLayouts = (VkDescriptorSetLayout[1]) { + layout, + }, + }, + &result); + if (res == VK_SUCCESS) + { + self->last_pool = pool_id; + *out_pool_id = self->last_pool; + return result; + } + else if (res == VK_ERROR_OUT_OF_POOL_MEMORY || + res == VK_ERROR_FRAGMENTED_POOL) + { + continue; + } + else + { + gsk_vulkan_handle_result (res, "vkAllocateDescriptorSets"); + } + } + + GSK_VK_CHECK (vkCreateDescriptorPool, vk_device, + &(VkDescriptorPoolCreateInfo) { + .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO, + .flags = VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, + .maxSets = 100, + .poolSizeCount = 1, + .pPoolSizes = (VkDescriptorPoolSize[1]) { + { + .type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, + .descriptorCount = 100, + }, + } + }, + NULL, + &new_pool); + descriptor_pools_append (&self->descriptor_pools, new_pool); + GSK_VK_CHECK (vkAllocateDescriptorSets, vk_device, + &(VkDescriptorSetAllocateInfo) { + .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO, + .descriptorPool = new_pool, + .descriptorSetCount = 1, + .pSetLayouts = (VkDescriptorSetLayout[1]) { + layout, + }, + }, + &result); + + self->last_pool = descriptor_pools_get_size (&self->descriptor_pools) - 1; + *out_pool_id = self->last_pool; + + return result; +} + +void +gsk_vulkan_device_free_descriptor (GskVulkanDevice *self, + gsize pool_id, + VkDescriptorSet set) +{ + vkFreeDescriptorSets (gsk_vulkan_device_get_vk_device (self), + descriptor_pools_get (&self->descriptor_pools, pool_id), + 1, + &set); } static VkSampler diff --git a/gsk/gpu/gskvulkandeviceprivate.h b/gsk/gpu/gskvulkandeviceprivate.h index 2b171084b0..94310812f0 100644 --- a/gsk/gpu/gskvulkandeviceprivate.h +++ b/gsk/gpu/gskvulkandeviceprivate.h @@ -29,7 +29,12 @@ VkPhysicalDevice gsk_vulkan_device_get_vk_physical_device (GskVulk VkQueue gsk_vulkan_device_get_vk_queue (GskVulkanDevice *self) G_GNUC_PURE; uint32_t gsk_vulkan_device_get_vk_queue_family_index (GskVulkanDevice *self) G_GNUC_PURE; VkCommandPool gsk_vulkan_device_get_vk_command_pool (GskVulkanDevice *self) G_GNUC_PURE; -VkDescriptorPool gsk_vulkan_device_get_vk_descriptor_pool (GskVulkanDevice *self) G_GNUC_PURE; +VkDescriptorSet gsk_vulkan_device_allocate_descriptor (GskVulkanDevice *self, + const VkDescriptorSetLayout layout, + gsize *out_pool_id); +void gsk_vulkan_device_free_descriptor (GskVulkanDevice *self, + gsize pool_id, + VkDescriptorSet set); VkDescriptorSetLayout gsk_vulkan_device_get_vk_image_set_layout (GskVulkanDevice *self) G_GNUC_PURE; VkPipelineLayout gsk_vulkan_device_create_vk_pipeline_layout (GskVulkanDevice *self, VkDescriptorSetLayout image1_layout, diff --git a/gsk/gpu/gskvulkanimage.c b/gsk/gpu/gskvulkanimage.c index 47feebb183..dc34cee9bb 100644 --- a/gsk/gpu/gskvulkanimage.c +++ b/gsk/gpu/gskvulkanimage.c @@ -34,7 +34,10 @@ struct _GskVulkanImage VkImageView vk_framebuffer_image_view; GskVulkanYcbcr *ycbcr; VkSemaphore vk_semaphore; - VkDescriptorSet vk_descriptor_sets[GSK_GPU_SAMPLER_N_SAMPLERS]; + struct { + VkDescriptorSet vk_descriptor_set; + gsize pool_id; + } descriptor_sets[GSK_GPU_SAMPLER_N_SAMPLERS]; VkPipelineStageFlags vk_pipeline_stage; VkImageLayout vk_image_layout; @@ -1288,22 +1291,19 @@ static void gsk_vulkan_image_finalize (GObject *object) { GskVulkanImage *self = GSK_VULKAN_IMAGE (object); - VkDescriptorPool vk_descriptor_pool; VkDevice vk_device; gsize i; vk_device = gsk_vulkan_device_get_vk_device (self->device); - vk_descriptor_pool = gsk_vulkan_device_get_vk_descriptor_pool (self->device); g_clear_pointer (&self->ycbcr, gsk_vulkan_ycbcr_unref); for (i = 0; i < GSK_GPU_SAMPLER_N_SAMPLERS; i++) { - if (self->vk_descriptor_sets[i]) - vkFreeDescriptorSets (vk_device, - vk_descriptor_pool, - 1, - &self->vk_descriptor_sets[i]); + if (self->descriptor_sets[i].vk_descriptor_set) + gsk_vulkan_device_free_descriptor (self->device, + self->descriptor_sets[i].pool_id, + self->descriptor_sets[i].vk_descriptor_set); } if (self->vk_framebuffer != VK_NULL_HANDLE) @@ -1406,27 +1406,19 @@ VkDescriptorSet gsk_vulkan_image_get_vk_descriptor_set (GskVulkanImage *self, GskGpuSampler sampler) { - if (self->vk_descriptor_sets[sampler] == NULL) + if (!self->descriptor_sets[sampler].vk_descriptor_set) { - VkDevice vk_device = gsk_vulkan_device_get_vk_device (self->device); + self->descriptor_sets[sampler].vk_descriptor_set = + gsk_vulkan_device_allocate_descriptor (self->device, + self->ycbcr ? gsk_vulkan_ycbcr_get_vk_descriptor_set_layout (self->ycbcr) + : gsk_vulkan_device_get_vk_image_set_layout (self->device), + &self->descriptor_sets[sampler].pool_id); - GSK_VK_CHECK (vkAllocateDescriptorSets, vk_device, - &(VkDescriptorSetAllocateInfo) { - .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO, - .descriptorPool = gsk_vulkan_device_get_vk_descriptor_pool (self->device), - .descriptorSetCount = 1, - .pSetLayouts = (VkDescriptorSetLayout[1]) { - self->ycbcr ? gsk_vulkan_ycbcr_get_vk_descriptor_set_layout (self->ycbcr) - : gsk_vulkan_device_get_vk_image_set_layout (self->device), - }, - }, - &self->vk_descriptor_sets[sampler]); - g_assert (self->vk_descriptor_sets[sampler]); - vkUpdateDescriptorSets (vk_device, + vkUpdateDescriptorSets (gsk_vulkan_device_get_vk_device (self->device), 1, &(VkWriteDescriptorSet) { .sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, - .dstSet = self->vk_descriptor_sets[sampler], + .dstSet = self->descriptor_sets[sampler].vk_descriptor_set, .dstBinding = 0, .dstArrayElement = 0, .descriptorCount = 1, @@ -1442,7 +1434,7 @@ gsk_vulkan_image_get_vk_descriptor_set (GskVulkanImage *self, NULL); } - return self->vk_descriptor_sets[sampler]; + return self->descriptor_sets[sampler].vk_descriptor_set; } GskVulkanYcbcr * diff --git a/testsuite/gsk/compare/lots-of-offscreens-nogl.node b/testsuite/gsk/compare/lots-of-offscreens-nogl.node new file mode 100644 index 0000000000..013f84050b --- /dev/null +++ b/testsuite/gsk/compare/lots-of-offscreens-nogl.node @@ -0,0 +1,64 @@ +cross-fade { + start: cross-fade "foo15" { + start: cross-fade "foo14" { + start: cross-fade "foo13" { + start: cross-fade "foo12" { + start: cross-fade "foo11" { + start: cross-fade "foo10" { + start: cross-fade "foo9" { + start: cross-fade "foo8" { + start: cross-fade "foo7" { + start: cross-fade "foo6" { + start: cross-fade "foo5" { + start: cross-fade "foo4" { + start: cross-fade "foo3" { + start: cross-fade "foo2" { + start: color "foo1" { + bounds: 0 0 10 10; + color: red; + } + end: "foo1"; + progress: 0.4; + } + end: "foo2"; + progress: 0.4; + } + end: "foo3"; + progress: 0.8; + } + end: "foo4"; + progress: 0.6; + } + end: "foo5"; + progress: 0.4; + } + end: "foo6"; + progress: 0.2; + } + end: "foo7"; + progress: 0.6; + } + end: "foo8"; + progress: 0.6; + } + end: "foo9"; + progress: 0.8; + } + end: "foo10"; + progress: 0.6; + } + end: "foo11"; + progress: 0.4; + } + end: "foo12"; + progress: 0.6; + } + end: "foo13"; + progress: 0.2; + } + end: "foo14"; + progress: 0.4; + } + end: "foo15"; + progress: 0.2; +} diff --git a/testsuite/gsk/compare/lots-of-offscreens-nogl.png b/testsuite/gsk/compare/lots-of-offscreens-nogl.png new file mode 100644 index 0000000000000000000000000000000000000000..d22d2caed9dad3da241ce5b14e10078d5f86a038 GIT binary patch literal 110 zcmeAS@N?(olHy`uVBq!ia0vp^AT}2V8<6ZZI=>f4F%}28J29*~C-V}>VM+FM4q)VE zV4Ra_Z3N^?c)B=-NK8%sbN;}G`HdV0TzVD-wq6P5V6dITB=q%g-wU7`22WQ%mvv4F FO#nZx9uNQk literal 0 HcmV?d00001 diff --git a/testsuite/gsk/meson.build b/testsuite/gsk/meson.build index ee7fa5e4b1..dfdf585790 100644 --- a/testsuite/gsk/meson.build +++ b/testsuite/gsk/meson.build @@ -99,6 +99,7 @@ compare_render_tests = [ 'linear-gradient-3d-nocairo', 'linear-gradient-nonorthogonal-scale-nogl', 'linear-gradient-with-64-colorstops', + 'lots-of-offscreens-nogl', 'mask', 'mask-clipped-inverted-alpha', 'mask-empty-mask', From 40e25218e27108506e67219198942e48e3e6ffbb Mon Sep 17 00:00:00 2001 From: Benjamin Otte Date: Mon, 22 Jul 2024 19:23:46 +0200 Subject: [PATCH 28/28] gpu: Compile with AMD's compiler, too Apparently AMD's GLSL compiler doesn't like our #if statements. Turn them into simple #ifdefs and compute them in the preamble instead. --- gsk/gpu/gskgldevice.c | 6 ++++++ gsk/gpu/gskgpushaderflagsprivate.h | 12 ++++++++++++ gsk/gpu/shaders/common-gl.glsl | 7 ++----- 3 files changed, 20 insertions(+), 5 deletions(-) diff --git a/gsk/gpu/gskgldevice.c b/gsk/gpu/gskgldevice.c index de773ac135..a143d794cf 100644 --- a/gsk/gpu/gskgldevice.c +++ b/gsk/gpu/gskgldevice.c @@ -406,6 +406,12 @@ gsk_gl_device_load_shader (GskGLDevice *self, g_assert (!gsk_gpu_shader_flags_has_external_textures (flags)); } + /* work with AMD's compiler, too */ + if (gsk_gpu_shader_flags_has_external_texture0 (flags)) + g_string_append (preamble, "#define GSK_TEXTURE0_IS_EXTERNAL 1\n"); + if (gsk_gpu_shader_flags_has_external_texture1 (flags)) + g_string_append (preamble, "#define GSK_TEXTURE1_IS_EXTERNAL 1\n"); + switch (shader_type) { case GL_VERTEX_SHADER: diff --git a/gsk/gpu/gskgpushaderflagsprivate.h b/gsk/gpu/gskgpushaderflagsprivate.h index eb2a5b06ba..645a26580a 100644 --- a/gsk/gpu/gskgpushaderflagsprivate.h +++ b/gsk/gpu/gskgpushaderflagsprivate.h @@ -18,6 +18,18 @@ gsk_gpu_shader_flags_has_external_textures (GskGpuShaderFlags flags) return flags & (3 << GSK_GPU_SHADER_CLIP_SHIFT) ? TRUE : FALSE; } +static inline gboolean +gsk_gpu_shader_flags_has_external_texture0 (GskGpuShaderFlags flags) +{ + return flags & (1 << GSK_GPU_SHADER_CLIP_SHIFT) ? TRUE : FALSE; +} + +static inline gboolean +gsk_gpu_shader_flags_has_external_texture1 (GskGpuShaderFlags flags) +{ + return flags & (2 << GSK_GPU_SHADER_CLIP_SHIFT) ? TRUE : FALSE; +} + static inline GskGpuShaderClip gsk_gpu_shader_flags_get_clip (GskGpuShaderFlags flags) { diff --git a/gsk/gpu/shaders/common-gl.glsl b/gsk/gpu/shaders/common-gl.glsl index c4b2555fa2..2b0b503886 100644 --- a/gsk/gpu/shaders/common-gl.glsl +++ b/gsk/gpu/shaders/common-gl.glsl @@ -1,8 +1,5 @@ precision highp float; -#define GSK_TEXTURE0_IS_EXTERNAL GSK_FLAGS & 4u -#define GSK_TEXTURE1_IS_EXTERNAL GSK_FLAGS & 8u - #if __VERSION__ < 420 || (defined(GSK_GLES) && __VERSION__ < 310) layout(std140) #else @@ -36,7 +33,7 @@ uniform PushConstants #if GSK_N_TEXTURES > 0 -#if GSK_TEXTURE0_IS_EXTERNAL +#ifdef GSK_TEXTURE0_IS_EXTERNAL uniform samplerExternalOES GSK_TEXTURE0; #else uniform sampler2D GSK_TEXTURE0; @@ -44,7 +41,7 @@ uniform sampler2D GSK_TEXTURE0; #if GSK_N_TEXTURES > 1 -#if GSK_TEXTURE1_IS_EXTERNAL +#ifdef GSK_TEXTURE1_IS_EXTERNAL uniform samplerExternalOES GSK_TEXTURE1; #else uniform sampler2D GSK_TEXTURE1;