AuroraMiddleware/gtk
1
0
Fork 1
mirror of https://gitlab.gnome.org/GNOME/gtk.git synced 2024-11-10 02:40:11 +00:00
Code Issues Projects Releases Wiki Activity
ee001feb91
gtk/gsk/gpu/gskgpulineargradientop.c

102 lines
3.9 KiB
C
Raw Normal View History

gpu: Add a linear-gradient shader The shader can only deal with up to 7 color stops - but that's good enough for the real world. Plus, we have the uber shader. And if that fails, we can still fall back to Cairo. The code also doesn't handle repeating linear gradients yet.
2023-12-25 04:02:51 +00:00
#include "config.h"
#include "gskgpulineargradientopprivate.h"
#include "gskgpuframeprivate.h"
#include "gskgpuprintprivate.h"
#include "gskrectprivate.h"
#include "gpu/shaders/gskgpulineargradientinstance.h"
gpu: Add supersampling for gradients Unless GSK_GPU_SKIP=gradients is given, we sample every point 4x instead of 1x. That makes the shader run slower (by roughly a factor of 2.5x) but it improves quality quite a bit.
2023-12-31 17:38:43 +00:00
#define VARIATION_SUPERSAMPLING (1 << 0)
#define VARIATION_REPEATING (1 << 1)
gpu: Make linear gradients use variations
2023-12-31 05:08:37 +00:00
gpu: Add a linear-gradient shader The shader can only deal with up to 7 color stops - but that's good enough for the real world. Plus, we have the uber shader. And if that fails, we can still fall back to Cairo. The code also doesn't handle repeating linear gradients yet.
2023-12-25 04:02:51 +00:00
typedef struct _GskGpuLinearGradientOp GskGpuLinearGradientOp;
struct _GskGpuLinearGradientOp
{
GskGpuShaderOp op;
};
static void
gpu: Add a ShaderOp.print_instance vfunc ... and add gsk_shader_op_print() to do the generic stuff.
2024-03-15 12:37:31 +00:00
gsk_gpu_linear_gradient_op_print_instance (GskGpuShaderOp *shader,
gpointer instance_,
GString *string)
gpu: Add a linear-gradient shader The shader can only deal with up to 7 color stops - but that's good enough for the real world. Plus, we have the uber shader. And if that fails, we can still fall back to Cairo. The code also doesn't handle repeating linear gradients yet.
2023-12-25 04:02:51 +00:00
{
gpu: Add a ShaderOp.print_instance vfunc ... and add gsk_shader_op_print() to do the generic stuff.
2024-03-15 12:37:31 +00:00
GskGpuLineargradientInstance *instance = (GskGpuLineargradientInstance *) instance_;
gpu: Add a linear-gradient shader The shader can only deal with up to 7 color stops - but that's good enough for the real world. Plus, we have the uber shader. And if that fails, we can still fall back to Cairo. The code also doesn't handle repeating linear gradients yet.
2023-12-25 04:02:51 +00:00
gpu: Make linear gradients use variations
2023-12-31 05:08:37 +00:00
if (shader->variation & VARIATION_REPEATING)
gpu: Add a ShaderOp.print_instance vfunc ... and add gsk_shader_op_print() to do the generic stuff.
2024-03-15 12:37:31 +00:00
gsk_gpu_print_string (string, "repeating");
gpu: Add a linear-gradient shader The shader can only deal with up to 7 color stops - but that's good enough for the real world. Plus, we have the uber shader. And if that fails, we can still fall back to Cairo. The code also doesn't handle repeating linear gradients yet.
2023-12-25 04:02:51 +00:00
gsk_gpu_print_rect (string, instance->rect);
}
static const GskGpuShaderOpClass GSK_GPU_LINEAR_GRADIENT_OP_CLASS = {
{
GSK_GPU_OP_SIZE (GskGpuLinearGradientOp),
GSK_GPU_STAGE_SHADER,
gsk_gpu_shader_op_finish,
gpu: Add a ShaderOp.print_instance vfunc ... and add gsk_shader_op_print() to do the generic stuff.
2024-03-15 12:37:31 +00:00
gsk_gpu_shader_op_print,
gpu: Add a linear-gradient shader The shader can only deal with up to 7 color stops - but that's good enough for the real world. Plus, we have the uber shader. And if that fails, we can still fall back to Cairo. The code also doesn't handle repeating linear gradients yet.
2023-12-25 04:02:51 +00:00
#ifdef GDK_RENDERING_VULKAN
gsk_gpu_shader_op_vk_command,
#endif
gsk_gpu_shader_op_gl_command
},
"gskgpulineargradient",
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.
2024-07-19 15:25:03 +00:00
gsk_gpu_lineargradient_n_textures,
gpu: Add a linear-gradient shader The shader can only deal with up to 7 color stops - but that's good enough for the real world. Plus, we have the uber shader. And if that fails, we can still fall back to Cairo. The code also doesn't handle repeating linear gradients yet.
2023-12-25 04:02:51 +00:00
sizeof (GskGpuLineargradientInstance),
#ifdef GDK_RENDERING_VULKAN
&gsk_gpu_lineargradient_info,
#endif
gpu: Add a ShaderOp.print_instance vfunc ... and add gsk_shader_op_print() to do the generic stuff.
2024-03-15 12:37:31 +00:00
gsk_gpu_linear_gradient_op_print_instance,
gpu: Setup attribute locations Make the generator generate calls for the correct glBindAttribLocation() calls. Usually this was done correctly, but we can't rely on it. So do it explicitly.
2024-01-04 13:52:03 +00:00
gsk_gpu_lineargradient_setup_attrib_locations,
gpu: Add a linear-gradient shader The shader can only deal with up to 7 color stops - but that's good enough for the real world. Plus, we have the uber shader. And if that fails, we can still fall back to Cairo. The code also doesn't handle repeating linear gradients yet.
2023-12-25 04:02:51 +00:00
gsk_gpu_lineargradient_setup_vao
};
void
gsk_gpu_linear_gradient_op (GskGpuFrame *frame,
GskGpuShaderClip clip,
gpu: Make linear gradient op obey ccs The alternative color state is used as the interpolation color state. Colors are transformed into that space on the CPU. For now we set the interpolation color state to SRGB, because ultimately we want to let callers specify it, so having something that's easy to map to that behavior is desirable. Otherwise we might have chosen to interpolate in the compositing colorstate. It also means that we need to premultiply colors on the CPU now because of the limitations of the shader colorstates APIs.
2024-07-03 23:26:01 +00:00
GskGpuColorStates color_states,
gpu: Handle >7 color stops If there are more than 7 color stops, we can split the gradient into multiple gradients with color stops like so: 0, 1, 2, 3, 4, 5, transparent transparent, 6, 7, 8, 9, 10, transparent ... transparent, n-2, n-1, n and use the new BLEND_ADD to draw them on top of each other. Adapt the testcae that tests this to use colors that work with the fancy algorithm we use now, so that BLEND_ADD and transitions to transparent do not cause issues.
2023-12-25 22:58:47 +00:00
gboolean repeating,
gpu: Add a linear-gradient shader The shader can only deal with up to 7 color stops - but that's good enough for the real world. Plus, we have the uber shader. And if that fails, we can still fall back to Cairo. The code also doesn't handle repeating linear gradients yet.
2023-12-25 04:02:51 +00:00
const graphene_rect_t *rect,
const graphene_point_t *start,
const graphene_point_t *end,
const graphene_point_t *offset,
const GskColorStop *stops,
gsize n_stops)
{
GskGpuLineargradientInstance *instance;
gpu: Make linear gradient op obey ccs The alternative color state is used as the interpolation color state. Colors are transformed into that space on the CPU. For now we set the interpolation color state to SRGB, because ultimately we want to let callers specify it, so having something that's easy to map to that behavior is desirable. Otherwise we might have chosen to interpolate in the compositing colorstate. It also means that we need to premultiply colors on the CPU now because of the limitations of the shader colorstates APIs.
2024-07-03 23:26:01 +00:00
GdkColorState *color_state = gsk_gpu_color_states_get_alt (color_states);
gpu: Add a linear-gradient shader The shader can only deal with up to 7 color stops - but that's good enough for the real world. Plus, we have the uber shader. And if that fails, we can still fall back to Cairo. The code also doesn't handle repeating linear gradients yet.
2023-12-25 04:02:51 +00:00
g_assert (n_stops > 1);
g_assert (n_stops <= 7);
gpu: Make linear gradient op obey ccs The alternative color state is used as the interpolation color state. Colors are transformed into that space on the CPU. For now we set the interpolation color state to SRGB, because ultimately we want to let callers specify it, so having something that's easy to map to that behavior is desirable. Otherwise we might have chosen to interpolate in the compositing colorstate. It also means that we need to premultiply colors on the CPU now because of the limitations of the shader colorstates APIs.
2024-07-03 23:26:01 +00:00
g_assert (gsk_gpu_color_states_is_alt_premultiplied (color_states));
gpu: Add a linear-gradient shader The shader can only deal with up to 7 color stops - but that's good enough for the real world. Plus, we have the uber shader. And if that fails, we can still fall back to Cairo. The code also doesn't handle repeating linear gradients yet.
2023-12-25 04:02:51 +00:00
gsk_gpu_shader_op_alloc (frame,
&GSK_GPU_LINEAR_GRADIENT_OP_CLASS,
gpu: Make linear gradient op obey ccs The alternative color state is used as the interpolation color state. Colors are transformed into that space on the CPU. For now we set the interpolation color state to SRGB, because ultimately we want to let callers specify it, so having something that's easy to map to that behavior is desirable. Otherwise we might have chosen to interpolate in the compositing colorstate. It also means that we need to premultiply colors on the CPU now because of the limitations of the shader colorstates APIs.
2024-07-03 23:26:01 +00:00
color_states,
gpu: Add supersampling for gradients Unless GSK_GPU_SKIP=gradients is given, we sample every point 4x instead of 1x. That makes the shader run slower (by roughly a factor of 2.5x) but it improves quality quite a bit.
2023-12-31 17:38:43 +00:00
(repeating ? VARIATION_REPEATING : 0) |
(gsk_gpu_frame_should_optimize (frame, GSK_GPU_OPTIMIZE_GRADIENTS) ? VARIATION_SUPERSAMPLING : 0),
gpu: Add a linear-gradient shader The shader can only deal with up to 7 color stops - but that's good enough for the real world. Plus, we have the uber shader. And if that fails, we can still fall back to Cairo. The code also doesn't handle repeating linear gradients yet.
2023-12-25 04:02:51 +00:00
clip,
NULL,
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).
2024-07-19 16:02:06 +00:00
NULL,
gpu: Add a linear-gradient shader The shader can only deal with up to 7 color stops - but that's good enough for the real world. Plus, we have the uber shader. And if that fails, we can still fall back to Cairo. The code also doesn't handle repeating linear gradients yet.
2023-12-25 04:02:51 +00:00
&instance);
gsk_gpu_rect_to_float (rect, offset, instance->rect);
gsk_gpu_point_to_float (start, offset, instance->startend);
gsk_gpu_point_to_float (end, offset, &instance->startend[2]);
gpu: Make linear gradient op obey ccs The alternative color state is used as the interpolation color state. Colors are transformed into that space on the CPU. For now we set the interpolation color state to SRGB, because ultimately we want to let callers specify it, so having something that's easy to map to that behavior is desirable. Otherwise we might have chosen to interpolate in the compositing colorstate. It also means that we need to premultiply colors on the CPU now because of the limitations of the shader colorstates APIs.
2024-07-03 23:26:01 +00:00
gdk_color_state_from_rgba (color_state, &stops[MIN (n_stops - 1, 6)].color, instance->color6);
gpu: Add a linear-gradient shader The shader can only deal with up to 7 color stops - but that's good enough for the real world. Plus, we have the uber shader. And if that fails, we can still fall back to Cairo. The code also doesn't handle repeating linear gradients yet.
2023-12-25 04:02:51 +00:00
instance->offsets1[2] = stops[MIN (n_stops - 1, 6)].offset;
gpu: Make linear gradient op obey ccs The alternative color state is used as the interpolation color state. Colors are transformed into that space on the CPU. For now we set the interpolation color state to SRGB, because ultimately we want to let callers specify it, so having something that's easy to map to that behavior is desirable. Otherwise we might have chosen to interpolate in the compositing colorstate. It also means that we need to premultiply colors on the CPU now because of the limitations of the shader colorstates APIs.
2024-07-03 23:26:01 +00:00
gdk_color_state_from_rgba (color_state, &stops[MIN (n_stops - 1, 5)].color, instance->color5);
gpu: Add a linear-gradient shader The shader can only deal with up to 7 color stops - but that's good enough for the real world. Plus, we have the uber shader. And if that fails, we can still fall back to Cairo. The code also doesn't handle repeating linear gradients yet.
2023-12-25 04:02:51 +00:00
instance->offsets1[1] = stops[MIN (n_stops - 1, 5)].offset;
gpu: Make linear gradient op obey ccs The alternative color state is used as the interpolation color state. Colors are transformed into that space on the CPU. For now we set the interpolation color state to SRGB, because ultimately we want to let callers specify it, so having something that's easy to map to that behavior is desirable. Otherwise we might have chosen to interpolate in the compositing colorstate. It also means that we need to premultiply colors on the CPU now because of the limitations of the shader colorstates APIs.
2024-07-03 23:26:01 +00:00
gdk_color_state_from_rgba (color_state, &stops[MIN (n_stops - 1, 4)].color, instance->color4);
gpu: Add a linear-gradient shader The shader can only deal with up to 7 color stops - but that's good enough for the real world. Plus, we have the uber shader. And if that fails, we can still fall back to Cairo. The code also doesn't handle repeating linear gradients yet.
2023-12-25 04:02:51 +00:00
instance->offsets1[0] = stops[MIN (n_stops - 1, 4)].offset;
gpu: Make linear gradient op obey ccs The alternative color state is used as the interpolation color state. Colors are transformed into that space on the CPU. For now we set the interpolation color state to SRGB, because ultimately we want to let callers specify it, so having something that's easy to map to that behavior is desirable. Otherwise we might have chosen to interpolate in the compositing colorstate. It also means that we need to premultiply colors on the CPU now because of the limitations of the shader colorstates APIs.
2024-07-03 23:26:01 +00:00
gdk_color_state_from_rgba (color_state, &stops[MIN (n_stops - 1, 3)].color, instance->color3);
gpu: Add a linear-gradient shader The shader can only deal with up to 7 color stops - but that's good enough for the real world. Plus, we have the uber shader. And if that fails, we can still fall back to Cairo. The code also doesn't handle repeating linear gradients yet.
2023-12-25 04:02:51 +00:00
instance->offsets0[3] = stops[MIN (n_stops - 1, 3)].offset;
gpu: Make linear gradient op obey ccs The alternative color state is used as the interpolation color state. Colors are transformed into that space on the CPU. For now we set the interpolation color state to SRGB, because ultimately we want to let callers specify it, so having something that's easy to map to that behavior is desirable. Otherwise we might have chosen to interpolate in the compositing colorstate. It also means that we need to premultiply colors on the CPU now because of the limitations of the shader colorstates APIs.
2024-07-03 23:26:01 +00:00
gdk_color_state_from_rgba (color_state, &stops[MIN (n_stops - 1, 2)].color, instance->color2);
gpu: Add a linear-gradient shader The shader can only deal with up to 7 color stops - but that's good enough for the real world. Plus, we have the uber shader. And if that fails, we can still fall back to Cairo. The code also doesn't handle repeating linear gradients yet.
2023-12-25 04:02:51 +00:00
instance->offsets0[2] = stops[MIN (n_stops - 1, 2)].offset;
gpu: Make linear gradient op obey ccs The alternative color state is used as the interpolation color state. Colors are transformed into that space on the CPU. For now we set the interpolation color state to SRGB, because ultimately we want to let callers specify it, so having something that's easy to map to that behavior is desirable. Otherwise we might have chosen to interpolate in the compositing colorstate. It also means that we need to premultiply colors on the CPU now because of the limitations of the shader colorstates APIs.
2024-07-03 23:26:01 +00:00
gdk_color_state_from_rgba (color_state, &stops[1].color, instance->color1);
gpu: Add a linear-gradient shader The shader can only deal with up to 7 color stops - but that's good enough for the real world. Plus, we have the uber shader. And if that fails, we can still fall back to Cairo. The code also doesn't handle repeating linear gradients yet.
2023-12-25 04:02:51 +00:00
instance->offsets0[1] = stops[1].offset;
gpu: Make linear gradient op obey ccs The alternative color state is used as the interpolation color state. Colors are transformed into that space on the CPU. For now we set the interpolation color state to SRGB, because ultimately we want to let callers specify it, so having something that's easy to map to that behavior is desirable. Otherwise we might have chosen to interpolate in the compositing colorstate. It also means that we need to premultiply colors on the CPU now because of the limitations of the shader colorstates APIs.
2024-07-03 23:26:01 +00:00
gdk_color_state_from_rgba (color_state, &stops[0].color, instance->color0);
gpu: Add a linear-gradient shader The shader can only deal with up to 7 color stops - but that's good enough for the real world. Plus, we have the uber shader. And if that fails, we can still fall back to Cairo. The code also doesn't handle repeating linear gradients yet.
2023-12-25 04:02:51 +00:00
instance->offsets0[0] = stops[0].offset;
}
Reference in New Issue Copy Permalink