AuroraMiddleware/gtk
1
0
Fork 1
mirror of https://gitlab.gnome.org/GNOME/gtk.git synced 2025-01-13 05:50:10 +00:00
Code Issues Projects Releases Wiki Activity
b481fd854f
gtk/gsk/gpu/gskgpushaderopprivate.h

106 lines
5.0 KiB
C
Raw Normal View History

gpu: Add ability to run shaders This heaves over an inital chunk of code from the Vulkan renderer to execute shaders. The only shader that exists for now is a shader that draws a single texture. We use that to replace the blit op we were doing before.
2023-08-21 00:18:37 +00:00
#pragma once
#include "gskgpuopprivate.h"
#include "gskgputypesprivate.h"
gpu: Pass color states as specialization constant This adds a GdkColorStates that encodes 2 of the default GdkColorStates and wether their values are premultiplied or not. Neither do the shaders do anything with this information yet, nor do the shaders do anything with it yet, this is just the plumbing.
2024-07-03 05:41:26 +00:00
#include "gskgpucolorstatesprivate.h"
gpu: Add ability to run shaders This heaves over an inital chunk of code from the Vulkan renderer to execute shaders. The only shader that exists for now is a shader that draws a single texture. We use that to replace the blit op we were doing before.
2023-08-21 00:18:37 +00:00
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.
2024-07-18 20:42:15 +00:00
#include <graphene.h>
gpu: Add ability to run shaders This heaves over an inital chunk of code from the Vulkan renderer to execute shaders. The only shader that exists for now is a shader that draws a single texture. We use that to replace the blit op we were doing before.
2023-08-21 00:18:37 +00:00
G_BEGIN_DECLS
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.
2024-07-18 20:42:15 +00:00
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 */
};
gpu: Add ability to run shaders This heaves over an inital chunk of code from the Vulkan renderer to execute shaders. The only shader that exists for now is a shader that draws a single texture. We use that to replace the blit op we were doing before.
2023-08-21 00:18:37 +00:00
struct _GskGpuShaderOp
{
GskGpuOp parent_op;
gpu: Refactor image handling Introduce a new GskGpuImageDescriptors object that tracks descriptors for a set of images that can be managed by the GPU. Then have each GskGpuShaderOp just reference the descriptors object they are using, so that the coe can set things up properly. To reference an image, the ops now just reference their descriptor - which is the uint32 we've been sending to the shaders since forever.
2023-10-03 19:04:21 +00:00
GskGpuDescriptors *desc;
gpu: Pass color states as specialization constant This adds a GdkColorStates that encodes 2 of the default GdkColorStates and wether their values are premultiplied or not. Neither do the shaders do anything with this information yet, nor do the shaders do anything with it yet, this is just the plumbing.
2024-07-03 05:41:26 +00:00
GskGpuColorStates color_states;
gpu: Introduce the concept of "variation" A variation is a #define/specialization constant that every shader can use to specialize itself as it sees fit. This commit adds the infrastrcture, future commits will add implementations.
2023-12-31 04:38:56 +00:00
guint32 variation;
gpu: Add ability to run shaders This heaves over an inital chunk of code from the Vulkan renderer to execute shaders. The only shader that exists for now is a shader that draws a single texture. We use that to replace the blit op we were doing before.
2023-08-21 00:18:37 +00:00
GskGpuShaderClip clip;
gsize vertex_offset;
gpu: Add GskGpuShaderOp.n_ops This just introduces the variable and sets it to 1 everywhere. The ultimate goal is to allow one ShaderOp to collect multiple ops into one, thereby saving memory in the ops array and leading to faster performance.
2024-03-15 17:55:48 +00:00
gsize n_ops;
gpu: Add ability to run shaders This heaves over an inital chunk of code from the Vulkan renderer to execute shaders. The only shader that exists for now is a shader that draws a single texture. We use that to replace the blit op we were doing before.
2023-08-21 00:18:37 +00:00
};
struct _GskGpuShaderOpClass
{
GskGpuOpClass parent_class;
const char * shader_name;
gsize vertex_size;
#ifdef GDK_RENDERING_VULKAN
const VkPipelineVertexInputStateCreateInfo *vertex_input_state;
#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
void (* print_instance) (GskGpuShaderOp *shader,
gpointer instance,
GString *string);
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
void (* setup_attrib_locations) (GLuint program);
gpu: Add ability to run shaders This heaves over an inital chunk of code from the Vulkan renderer to execute shaders. The only shader that exists for now is a shader that draws a single texture. We use that to replace the blit op we were doing before.
2023-08-21 00:18:37 +00:00
void (* setup_vao) (gsize offset);
};
gpu: Remove unused return value from function Technically, an alloc() function should return what it allocated. But the return value is never used. Maybe we should rename the function?
2024-03-15 12:42:40 +00:00
void gsk_gpu_shader_op_alloc (GskGpuFrame *frame,
gpu: Add ability to run shaders This heaves over an inital chunk of code from the Vulkan renderer to execute shaders. The only shader that exists for now is a shader that draws a single texture. We use that to replace the blit op we were doing before.
2023-08-21 00:18:37 +00:00
const GskGpuShaderOpClass *op_class,
gpu: Pass color states as specialization constant This adds a GdkColorStates that encodes 2 of the default GdkColorStates and wether their values are premultiplied or not. Neither do the shaders do anything with this information yet, nor do the shaders do anything with it yet, this is just the plumbing.
2024-07-03 05:41:26 +00:00
GskGpuColorStates color_states,
gpu: Introduce the concept of "variation" A variation is a #define/specialization constant that every shader can use to specialize itself as it sees fit. This commit adds the infrastrcture, future commits will add implementations.
2023-12-31 04:38:56 +00:00
guint32 variation,
gpu: Add ability to run shaders This heaves over an inital chunk of code from the Vulkan renderer to execute shaders. The only shader that exists for now is a shader that draws a single texture. We use that to replace the blit op we were doing before.
2023-08-21 00:18:37 +00:00
GskGpuShaderClip clip,
gpu: Refactor image handling Introduce a new GskGpuImageDescriptors object that tracks descriptors for a set of images that can be managed by the GPU. Then have each GskGpuShaderOp just reference the descriptors object they are using, so that the coe can set things up properly. To reference an image, the ops now just reference their descriptor - which is the uint32 we've been sending to the shaders since forever.
2023-10-03 19:04:21 +00:00
GskGpuDescriptors *desc,
gpu: Add ability to run shaders This heaves over an inital chunk of code from the Vulkan renderer to execute shaders. The only shader that exists for now is a shader that draws a single texture. We use that to replace the blit op we were doing before.
2023-08-21 00:18:37 +00:00
gpointer out_vertex_data);
gpu: Refactor image handling Introduce a new GskGpuImageDescriptors object that tracks descriptors for a set of images that can be managed by the GPU. Then have each GskGpuShaderOp just reference the descriptors object they are using, so that the coe can set things up properly. To reference an image, the ops now just reference their descriptor - which is the uint32 we've been sending to the shaders since forever.
2023-10-03 19:04:21 +00:00
void gsk_gpu_shader_op_finish (GskGpuOp *op);
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
void gsk_gpu_shader_op_print (GskGpuOp *op,
GskGpuFrame *frame,
GString *string,
guint indent);
gpu: Add ability to run shaders This heaves over an inital chunk of code from the Vulkan renderer to execute shaders. The only shader that exists for now is a shader that draws a single texture. We use that to replace the blit op we were doing before.
2023-08-21 00:18:37 +00:00
#ifdef GDK_RENDERING_VULKAN
GskGpuOp * gsk_gpu_shader_op_vk_command_n (GskGpuOp *op,
GskGpuFrame *frame,
gpu: Add a CommandState struct to the command vfuncs This way, we can make it writable and track things like the active textures and the current program. We don't do that yet, but we can.
2023-11-04 02:57:38 +00:00
GskVulkanCommandState *state,
gpu: Add ability to run shaders This heaves over an inital chunk of code from the Vulkan renderer to execute shaders. The only shader that exists for now is a shader that draws a single texture. We use that to replace the blit op we were doing before.
2023-08-21 00:18:37 +00:00
gsize instance_scale);
GskGpuOp * gsk_gpu_shader_op_vk_command (GskGpuOp *op,
GskGpuFrame *frame,
gpu: Add a CommandState struct to the command vfuncs This way, we can make it writable and track things like the active textures and the current program. We don't do that yet, but we can.
2023-11-04 02:57:38 +00:00
GskVulkanCommandState *state);
gpu: Add ability to run shaders This heaves over an inital chunk of code from the Vulkan renderer to execute shaders. The only shader that exists for now is a shader that draws a single texture. We use that to replace the blit op we were doing before.
2023-08-21 00:18:37 +00:00
#endif
GskGpuOp * gsk_gpu_shader_op_gl_command_n (GskGpuOp *op,
GskGpuFrame *frame,
gpu: Add a CommandState struct to the command vfuncs This way, we can make it writable and track things like the active textures and the current program. We don't do that yet, but we can.
2023-11-04 02:57:38 +00:00
GskGLCommandState *state,
gpu: Add ability to run shaders This heaves over an inital chunk of code from the Vulkan renderer to execute shaders. The only shader that exists for now is a shader that draws a single texture. We use that to replace the blit op we were doing before.
2023-08-21 00:18:37 +00:00
gsize instance_scale);
GskGpuOp * gsk_gpu_shader_op_gl_command (GskGpuOp *op,
gpu: Add a flip_y argument to shader execution Because GL flips its shit sometimes (ie when it's the framebuffer), pass the height of the target as the flip variable, so commands that need to operate on the pixels can flip the y axis around this value.
2023-08-29 06:34:55 +00:00
GskGpuFrame *frame,
gpu: Add a CommandState struct to the command vfuncs This way, we can make it writable and track things like the active textures and the current program. We don't do that yet, but we can.
2023-11-04 02:57:38 +00:00
GskGLCommandState *state);
gpu: Add ability to run shaders This heaves over an inital chunk of code from the Vulkan renderer to execute shaders. The only shader that exists for now is a shader that draws a single texture. We use that to replace the blit op we were doing before.
2023-08-21 00:18:37 +00:00
gpu: Make color op obey ccs This makes use of the GskGpuColorStates by setting the ccs as output colorstate and the color's colorstate as alternative color state. The shader adaption is very straightforward because of that.
2024-07-03 17:51:16 +00:00
#define GSK_RGBA_TO_VEC4(_color) (float[4]) { (_color)->red, (_color)->green, (_color)->blue, (_color)->alpha }
#define GSK_RGBA_TO_VEC4_ALPHA(_color, _alpha) (float[4]) { (_color)->red, (_color)->green, (_color)->blue, (_color)->alpha * (_alpha) }
gpu: Convert values to float[4] from GdkRGBA We need to make sure our clear values are in the right colorstate, not in sRGB. The occluision culling managed to sneak through the big transition for that.
2024-07-13 00:05:41 +00:00
#define GSK_VEC4_TRANSPARENT (float[4]) { 0.0f, 0.0f, 0.0f, 0.0f }
gpu: Make color op obey ccs This makes use of the GskGpuColorStates by setting the ccs as output colorstate and the color's colorstate as alternative color state. The shader adaption is very straightforward because of that.
2024-07-03 17:51:16 +00:00
static inline void
gsk_gpu_color_to_float (const float color[4],
float values[4])
{
values[0] = color[0];
values[1] = color[1];
values[2] = color[2];
values[3] = color[3];
}
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 <graphene.h>
static inline void
gsk_gpu_point_to_float (const graphene_point_t *point,
const graphene_point_t *offset,
float values[2])
{
values[0] = point->x + offset->x;
values[1] = point->y + offset->y;
}
gpu: Add ability to run shaders This heaves over an inital chunk of code from the Vulkan renderer to execute shaders. The only shader that exists for now is a shader that draws a single texture. We use that to replace the blit op we were doing before.
2023-08-21 00:18:37 +00:00
G_END_DECLS
Reference in New Issue Copy Permalink