AuroraMiddleware/gtk
1
0
Fork 1
mirror of https://gitlab.gnome.org/GNOME/gtk.git synced 2024-11-09 10:20:07 +00:00
Code Issues Projects Releases Wiki Activity
0600357373
gtk/gsk/gskrendernodeprivate.h

189 lines
9.4 KiB
C
Raw Normal View History

Convert headers to #pragma once The conversion was done by guard2one.
2023-03-31 19:11:10 +00:00
#pragma once
Initial implementation of GSK rendering pipeline GSK is conceptually split into two scene graphs: * a simple rendering tree of operations * a complex set of logical layers The latter is built on the former, and adds convenience and high level API for application developers. The lower layer, though, is what gets transformed into the rendering pipeline, as it's simple and thus can be transformed into appropriate rendering commands with minimal state changes. The lower layer is also suitable for reuse from more complex higher layers, like the CSS machinery in GTK, without necessarily port those layers to the GSK high level API. This lower layer is based on GskRenderNode instances, which represent the tree of rendering operations; and a GskRenderer instance, which takes the render nodes and submits them (after potentially reordering and transforming them to a more appropriate representation) to the underlying graphic system.
2016-03-17 13:48:19 +00:00
#include "gskrendernode.h"
#include <cairo.h>
rendernode: Change to gsk_render_node_get_preferred_depth() Instead of just tracking preferred_high_depth(), track the actual depth we'd like to have.
2023-06-15 18:27:13 +00:00
#include "gdk/gdkmemoryformatprivate.h"
gsk: Add private color node api Add a constructor that takes a color state, a getter for it, and also a getter for the color coordinates that avoids GdkRGBA.
2024-07-31 22:37:02 +00:00
#include "gdk/gdkcolorprivate.h"
rendernode: Change to gsk_render_node_get_preferred_depth() Instead of just tracking preferred_high_depth(), track the actual depth we'd like to have.
2023-06-15 18:27:13 +00:00
Initial implementation of GSK rendering pipeline GSK is conceptually split into two scene graphs: * a simple rendering tree of operations * a complex set of logical layers The latter is built on the former, and adds convenience and high level API for application developers. The lower layer, though, is what gets transformed into the rendering pipeline, as it's simple and thus can be transformed into appropriate rendering commands with minimal state changes. The lower layer is also suitable for reuse from more complex higher layers, like the CSS machinery in GTK, without necessarily port those layers to the GSK high level API. This lower layer is based on GskRenderNode instances, which represent the tree of rendering operations; and a GskRenderer instance, which takes the render nodes and submits them (after potentially reordering and transforming them to a more appropriate representation) to the underlying graphic system.
2016-03-17 13:48:19 +00:00
G_BEGIN_DECLS
gsk: Introduce GskRenderNodeClass This is modeled after GtkCssValueClass. So far it doesn't do anything.
2016-12-11 02:57:42 +00:00
typedef struct _GskRenderNodeClass GskRenderNodeClass;
Turn GskRenderNode into a derivable type Language bindings—especially ones based on introspection—cannot deal with custom type hiearchies. Luckily for us, GType has a derivable type with low overhead: GTypeInstance. By turning GskRenderNode into a GTypeInstance, and creating derived types for each class of node, we can provide an introspectable API to our non-C API consumers, with no functional change to the C API itself.
2020-04-07 22:33:54 +00:00
/* Keep this in sync with the GskRenderNodeType enumeration.
*
* We don't add an "n-types" value to avoid having to handle
* it in every single switch.
*/
gsk: Add subsurface nodes Also show them in the inspector recorder, with some information.
2023-10-29 15:48:16 +00:00
#define GSK_RENDER_NODE_TYPE_N_TYPES (GSK_SUBSURFACE_NODE + 1)
Turn GskRenderNode into a derivable type Language bindings—especially ones based on introspection—cannot deal with custom type hiearchies. Luckily for us, GType has a derivable type with low overhead: GTypeInstance. By turning GskRenderNode into a GTypeInstance, and creating derived types for each class of node, we can provide an introspectable API to our non-C API consumers, with no functional change to the C API itself.
2020-04-07 22:33:54 +00:00
Add get_type() functions for GskRenderNode subclasses The introspection scanner tries to match a type name with a get_type() function, in order to correctly identify a type as a class. If the function is not available, we have two choices: - add some special case inside the introspection scanner, similar to how GParamSpec subclasses are handled in GObject - add a simple get_type() function The latter is the simplest approach, and we don't need to change that much, since we still register all render nodes at once.
2020-04-08 14:34:11 +00:00
extern GType gsk_render_node_types[];
Turn GskRenderNode into a derivable type Language bindings—especially ones based on introspection—cannot deal with custom type hiearchies. Luckily for us, GType has a derivable type with low overhead: GTypeInstance. By turning GskRenderNode into a GTypeInstance, and creating derived types for each class of node, we can provide an introspectable API to our non-C API consumers, with no functional change to the C API itself.
2020-04-07 22:33:54 +00:00
#define GSK_IS_RENDER_NODE_TYPE(node,type) \
(G_TYPE_INSTANCE_GET_CLASS ((node), GSK_TYPE_RENDER_NODE, GskRenderNodeClass)->node_type == (type))
gsk: Introduce GskRenderNodeClass This is modeled after GtkCssValueClass. So far it doesn't do anything.
2016-12-11 02:57:42 +00:00
gsk/gl: remove TypeNode conformity checking for renderjob We don't need to be calling type node conformity checking from the tight loop of the renderjob. Hoist that into the private header and use that intead through via the Class pointer.
2023-09-27 01:36:22 +00:00
#define GSK_RENDER_NODE_TYPE(node) \
(G_TYPE_INSTANCE_GET_CLASS ((node), GSK_TYPE_RENDER_NODE, GskRenderNodeClass)->node_type)
Initial implementation of GSK rendering pipeline GSK is conceptually split into two scene graphs: * a simple rendering tree of operations * a complex set of logical layers The latter is built on the former, and adds convenience and high level API for application developers. The lower layer, though, is what gets transformed into the rendering pipeline, as it's simple and thus can be transformed into appropriate rendering commands with minimal state changes. The lower layer is also suitable for reuse from more complex higher layers, like the CSS machinery in GTK, without necessarily port those layers to the GSK high level API. This lower layer is based on GskRenderNode instances, which represent the tree of rendering operations; and a GskRenderer instance, which takes the render nodes and submits them (after potentially reordering and transforming them to a more appropriate representation) to the underlying graphic system.
2016-03-17 13:48:19 +00:00
struct _GskRenderNode
{
Turn GskRenderNode into a derivable type Language bindings—especially ones based on introspection—cannot deal with custom type hiearchies. Luckily for us, GType has a derivable type with low overhead: GTypeInstance. By turning GskRenderNode into a GTypeInstance, and creating derived types for each class of node, we can provide an introspectable API to our non-C API consumers, with no functional change to the C API itself.
2020-04-07 22:33:54 +00:00
GTypeInstance parent_instance;
gsk: Add GskRenderNodeType For now, this is unused.
2016-12-10 20:42:01 +00:00
Turn GskRenderNode into a derivable type Language bindings—especially ones based on introspection—cannot deal with custom type hiearchies. Luckily for us, GType has a derivable type with low overhead: GTypeInstance. By turning GskRenderNode into a GTypeInstance, and creating derived types for each class of node, we can provide an introspectable API to our non-C API consumers, with no functional change to the C API itself.
2020-04-07 22:33:54 +00:00
gatomicrefcount ref_count;
Initial implementation of GSK rendering pipeline GSK is conceptually split into two scene graphs: * a simple rendering tree of operations * a complex set of logical layers The latter is built on the former, and adds convenience and high level API for application developers. The lower layer, though, is what gets transformed into the rendering pipeline, as it's simple and thus can be transformed into appropriate rendering commands with minimal state changes. The lower layer is also suitable for reuse from more complex higher layers, like the CSS machinery in GTK, without necessarily port those layers to the GSK high level API. This lower layer is based on GskRenderNode instances, which represent the tree of rendering operations; and a GskRenderer instance, which takes the render nodes and submits them (after potentially reordering and transforming them to a more appropriate representation) to the underlying graphic system.
2016-03-17 13:48:19 +00:00
gsk: Add bounds member to RenderNode Instead of constantly recalculating this (especially recursively for parents!) we do it only on construction, because everything is immutable anyway. Also, most nodes had a bounds already and can use the new parent member instead. We also do direct access to the node bounds rather than calling gsk_render_node_get_bounds in various places, which means we do less copying.
2016-12-21 10:21:38 +00:00
graphene_rect_t bounds;
gsk: Add high depth rendernode api Add private api to find out if the content of a render node should be considered 'deep'. The information is collected at creation time, so there is no tree-walking involved when we are using this information in the renderer. Currently, this comes down to whether there are any texture nodes with high depth textures in the subtree. In the future, we may want to allow marking gradient nodes in this way as well.
2021-10-01 20:23:12 +00:00
rendernode: Make sure depth variable has enough bits This will be relevant when we add new values to it.
2024-07-03 16:36:49 +00:00
guint preferred_depth : GDK_MEMORY_DEPTH_BITS;
gsk: Collect opacity information Collect information about whether to use offscreens for opacity during node construction, so we don't need to walk the tree repeatedly, later.
2022-04-05 18:55:36 +00:00
guint offscreen_for_opacity : 1;
rendernode: Add fully-opaque flag Allows rendernodes to advertise themselves as fully opaque. This is used as a fast path for get_opaque_rect().
2024-07-07 16:24:53 +00:00
guint fully_opaque : 1;
gsk: Add gsk_render_node_is_hdr Add a function that tracks whether a render node's content is in a wide gamut color state (in practice, that means non-sRGB). This will be used in render_texture to determine the color state to use when creating a texture.
2024-08-06 16:45:16 +00:00
guint is_hdr : 1;
Initial implementation of GSK rendering pipeline GSK is conceptually split into two scene graphs: * a simple rendering tree of operations * a complex set of logical layers The latter is built on the former, and adds convenience and high level API for application developers. The lower layer, though, is what gets transformed into the rendering pipeline, as it's simple and thus can be transformed into appropriate rendering commands with minimal state changes. The lower layer is also suitable for reuse from more complex higher layers, like the CSS machinery in GTK, without necessarily port those layers to the GSK high level API. This lower layer is based on GskRenderNode instances, which represent the tree of rendering operations; and a GskRenderer instance, which takes the render nodes and submits them (after potentially reordering and transforming them to a more appropriate representation) to the underlying graphic system.
2016-03-17 13:48:19 +00:00
};
Rework diffing one more time Pass the surface along. We need it to identify the inspector case in gsk_subsurface_node_diff.
2024-02-11 20:53:37 +00:00
typedef struct
{
cairo_region_t *region;
GdkSurface *surface;
} GskDiffData;
gsk: Introduce GskRenderNodeClass This is modeled after GtkCssValueClass. So far it doesn't do anything.
2016-12-11 02:57:42 +00:00
struct _GskRenderNodeClass
{
Turn GskRenderNode into a derivable type Language bindings—especially ones based on introspection—cannot deal with custom type hiearchies. Luckily for us, GType has a derivable type with low overhead: GTypeInstance. By turning GskRenderNode into a GTypeInstance, and creating derived types for each class of node, we can provide an introspectable API to our non-C API consumers, with no functional change to the C API itself.
2020-04-07 22:33:54 +00:00
GTypeClass parent_class;
gsk: Introduce GskRenderNodeClass This is modeled after GtkCssValueClass. So far it doesn't do anything.
2016-12-11 02:57:42 +00:00
GskRenderNodeType node_type;
rendernode: Add getters for box-shadow nodes
2017-01-17 23:05:25 +00:00
gsk: Add gsk_render_node_get_opaque_rect() Gets a rectangle inside the rendernode that is opaque. This function only adds the API. So far, no implementation exists.
2023-04-03 12:52:00 +00:00
void (* finalize) (GskRenderNode *node);
void (* draw) (GskRenderNode *node,
cairo: Add colorstate to GskRenderNode::draw and use it This adds the following: - ccs argument to GskRenderNode::draw This is the compositing color state to use when drawing. - make implementations use the CCS argument FIXME: Some implementations are missing - gsk_render_node_draw_with_color_state() Draws a node with any color state, by switching to its compositing color state, drawing in that color state and then converting to the desired color state. This does draw the result OVER the previous contents in the passed in color state, so this function should be called with the target being empty. - gsk_render_node_draw_ccs() This needs to be passed a css and then draws with that ccs. The main use for this is chaining up in rendernode draw() implementations. - split out shared Cairo functions into gdkcairoprivate.h gskrendernode.c and gskrendernodeimpl.c need the same functions. Plus, there's various code in GDK that wants to use it, so put it in gdk/ not in gsk/ gsk_render_node_draw() now calls gsk_render_node_draw_with_color_state() with GDK_COLOR_STATE_SRGB.
2024-07-02 05:02:09 +00:00
cairo_t *cr,
GdkColorState *ccs);
gsk: Add gsk_render_node_get_opaque_rect() Gets a rectangle inside the rendernode that is opaque. This function only adds the API. So far, no implementation exists.
2023-04-03 12:52:00 +00:00
gboolean (* can_diff) (const GskRenderNode *node1,
const GskRenderNode *node2);
void (* diff) (GskRenderNode *node1,
GskRenderNode *node2,
GskDiffData *data);
gboolean (* get_opaque_rect) (GskRenderNode *node,
graphene_rect_t *out_opaque);
Make render node getter public Keeping these private does not really buy us anything.
2017-10-20 06:06:20 +00:00
};
gsk: Move GskRenderNode getters to internal API GskRenderNode is, at its core, a write-only API; you're supposed to set up the render nodes instead of querying them for state. Querying render nodes is left to the GskRenderer implementation.
2016-08-24 13:07:26 +00:00
Turn GskRenderNode into a derivable type Language bindings—especially ones based on introspection—cannot deal with custom type hiearchies. Luckily for us, GType has a derivable type with low overhead: GTypeInstance. By turning GskRenderNode into a GTypeInstance, and creating derived types for each class of node, we can provide an introspectable API to our non-C API consumers, with no functional change to the C API itself.
2020-04-07 22:33:54 +00:00
void gsk_render_node_init_types (void);
GType gsk_render_node_type_register_static (const char *node_name,
rendernode: Get rid of GskRenderNodeTypeInfo Instead, use class_init functions.
2023-04-03 14:39:52 +00:00
gsize instance_size,
GClassInitFunc class_init);
gsk: Add cross-fade node And implement stack crossfades with it.
2016-12-17 06:44:10 +00:00
Turn GskRenderNode into a derivable type Language bindings—especially ones based on introspection—cannot deal with custom type hiearchies. Luckily for us, GType has a derivable type with low overhead: GTypeInstance. By turning GskRenderNode into a GTypeInstance, and creating derived types for each class of node, we can provide an introspectable API to our non-C API consumers, with no functional change to the C API itself.
2020-04-07 22:33:54 +00:00
gpointer gsk_render_node_alloc (GskRenderNodeType node_type);
rendernode: Add gsk_render_node_diff() ... and gsk_render_node_can_diff(). Those are vfuncs to compute a region containing all the pixels that differ between the two nodes. This is just the plumbing that chains into node classes. No node implements it yet.
2018-03-20 00:37:05 +00:00
gsk: remove excessive type checking within GSK Anything that includes gskrendernodeprivate.h will get an alternate form of ref/unref for render nodes which does not need to do type checking on the parameter. We can expect that things are correct within GTK itself and this saves excessive amounts of TypeNode conformities checking.
2023-09-27 01:28:11 +00:00
void _gsk_render_node_unref (GskRenderNode *node);
Turn GskRenderNode into a derivable type Language bindings—especially ones based on introspection—cannot deal with custom type hiearchies. Luckily for us, GType has a derivable type with low overhead: GTypeInstance. By turning GskRenderNode into a GTypeInstance, and creating derived types for each class of node, we can provide an introspectable API to our non-C API consumers, with no functional change to the C API itself.
2020-04-07 22:33:54 +00:00
gboolean gsk_render_node_can_diff (const GskRenderNode *node1,
const GskRenderNode *node2) G_GNUC_PURE;
void gsk_render_node_diff (GskRenderNode *node1,
GskRenderNode *node2,
Rework diffing one more time Pass the surface along. We need it to identify the inspector case in gsk_subsurface_node_diff.
2024-02-11 20:53:37 +00:00
GskDiffData *data);
Turn GskRenderNode into a derivable type Language bindings—especially ones based on introspection—cannot deal with custom type hiearchies. Luckily for us, GType has a derivable type with low overhead: GTypeInstance. By turning GskRenderNode into a GTypeInstance, and creating derived types for each class of node, we can provide an introspectable API to our non-C API consumers, with no functional change to the C API itself.
2020-04-07 22:33:54 +00:00
void gsk_render_node_diff_impossible (GskRenderNode *node1,
GskRenderNode *node2,
Rework diffing one more time Pass the surface along. We need it to identify the inspector case in gsk_subsurface_node_diff.
2024-02-11 20:53:37 +00:00
GskDiffData *data);
gsk: Make rendernode diffing smarter Allow comparing container nodes to any other node, by pretending the other node is a single child container (if it isn't one already). This fixes a glitch where we redraw the full entry text when the blinking cursor goes to opacity 0, since GskSnapshot then optimizes away first the opacity node, and then the single-child container.
2021-03-28 14:18:23 +00:00
void gsk_container_node_diff_with (GskRenderNode *container,
GskRenderNode *other,
Rework diffing one more time Pass the surface along. We need it to identify the inspector case in gsk_subsurface_node_diff.
2024-02-11 20:53:37 +00:00
GskDiffData *data);
cairo: Add colorstate to GskRenderNode::draw and use it This adds the following: - ccs argument to GskRenderNode::draw This is the compositing color state to use when drawing. - make implementations use the CCS argument FIXME: Some implementations are missing - gsk_render_node_draw_with_color_state() Draws a node with any color state, by switching to its compositing color state, drawing in that color state and then converting to the desired color state. This does draw the result OVER the previous contents in the passed in color state, so this function should be called with the target being empty. - gsk_render_node_draw_ccs() This needs to be passed a css and then draws with that ccs. The main use for this is chaining up in rendernode draw() implementations. - split out shared Cairo functions into gdkcairoprivate.h gskrendernode.c and gskrendernodeimpl.c need the same functions. Plus, there's various code in GDK that wants to use it, so put it in gdk/ not in gsk/ gsk_render_node_draw() now calls gsk_render_node_draw_with_color_state() with GDK_COLOR_STATE_SRGB.
2024-07-02 05:02:09 +00:00
void gsk_render_node_draw_ccs (GskRenderNode *node,
cairo_t *cr,
GdkColorState *ccs);
void gsk_render_node_draw_with_color_state (GskRenderNode *node,
cairo_t *cr,
GdkColorState *color_state);
gsk: Repurpose GSK_DEBUG=cairo Use it to overlay an error pattern over all Cairo drawing done by renderers. This has 2 purposes: 1. It allows detecting fallbacks in GPU renderers. 2. Application code can use it to detect where it is using Cairo drawing. As such, it is meant to trigger both with cairo nodes as well as when renderers fallback for regular nodes. The old use of the debug flag - which were 2 not very useful print statements - was removed.
2023-12-26 03:53:09 +00:00
void gsk_render_node_draw_fallback (GskRenderNode *node,
cairo_t *cr);
gsk: Make gsk_text_node_new_with_bounds private We pulled out the bounds calculation for performance reasons, but the caller can't know how to properly compute them. Inside gtk+, we can do that but it's not good enough for public API.
2018-04-21 09:20:15 +00:00
Add a few annotations Add a few pure, const and malloc annotations. These were suggested by the gcc -Wsuggest-attribute option.
2023-12-27 02:55:59 +00:00
bool gsk_border_node_get_uniform (const GskRenderNode *self) G_GNUC_PURE;
bool gsk_border_node_get_uniform_color (const GskRenderNode *self) G_GNUC_PURE;
gsk: Remember border node uniformity Lots of border nodes have all the same width and the same color. Renderers might be able to simplifty that, so keep an extra bit per border node.
2020-07-24 13:59:45 +00:00
gsk: Export the glyph serialization privately We want to use the same serialization in the inspector, so export this function.
2020-12-21 18:11:08 +00:00
void gsk_text_node_serialize_glyphs (GskRenderNode *self,
GString *str);
Add gsk_text_node_get_font_hint_style Getting the hint style is one of the more expensive calls we do when adding glyph nodes, so cache this information in the node.
2024-09-08 15:07:28 +00:00
cairo_hint_style_t
gsk_text_node_get_font_hint_style (const GskRenderNode *self) G_GNUC_PURE;
rendernode: Change to gsk_render_node_get_preferred_depth() Instead of just tracking preferred_high_depth(), track the actual depth we'd like to have.
2023-06-15 18:27:13 +00:00
GskRenderNode ** gsk_container_node_get_children (const GskRenderNode *node,
guint *n_children);
gsk: Add a private getter for container children No need to get them one-by-one, in our inner loop.
2021-07-24 13:49:09 +00:00
rendernode: Change to gsk_render_node_get_preferred_depth() Instead of just tracking preferred_high_depth(), track the actual depth we'd like to have.
2023-06-15 18:27:13 +00:00
void gsk_transform_node_get_translate (const GskRenderNode *node,
float *dx,
float *dy);
Add a few annotations Add a few pure, const and malloc annotations. These were suggested by the gcc -Wsuggest-attribute option.
2023-12-27 02:55:59 +00:00
GdkMemoryDepth gsk_render_node_get_preferred_depth (const GskRenderNode *node) G_GNUC_PURE;
gsk: Add gsk_render_node_is_hdr Add a function that tracks whether a render node's content is in a wide gamut color state (in practice, that means non-sRGB). This will be used in render_texture to determine the color state to use when creating a texture.
2024-08-06 16:45:16 +00:00
gboolean gsk_render_node_is_hdr (const GskRenderNode *node) G_GNUC_PURE;
gsk: Add a shortcut for a common transform case Add a private getter for the translation part of a transform node, to avoid pulling it out of the transform over and over.
2021-07-24 14:48:20 +00:00
Add a few annotations Add a few pure, const and malloc annotations. These were suggested by the gcc -Wsuggest-attribute option.
2023-12-27 02:55:59 +00:00
gboolean gsk_container_node_is_disjoint (const GskRenderNode *node) G_GNUC_PURE;
gsk: Track disjointness of container nodes This can be used to optimize some things in the GL renderer.
2022-04-03 23:28:53 +00:00
Add a few annotations Add a few pure, const and malloc annotations. These were suggested by the gcc -Wsuggest-attribute option.
2023-12-27 02:55:59 +00:00
gboolean gsk_render_node_use_offscreen_for_opacity (const GskRenderNode *node) G_GNUC_PURE;
gsk: Collect opacity information Collect information about whether to use offscreens for opacity during node construction, so we don't need to walk the tree repeatedly, later.
2022-04-05 18:55:36 +00:00
gsk: remove excessive type checking within GSK Anything that includes gskrendernodeprivate.h will get an alternate form of ref/unref for render nodes which does not need to do type checking on the parameter. We can expect that things are correct within GTK itself and this saves excessive amounts of TypeNode conformities checking.
2023-09-27 01:28:11 +00:00
#define gsk_render_node_ref(node) _gsk_render_node_ref(node)
#define gsk_render_node_unref(node) _gsk_render_node_unref(node)
static inline GskRenderNode *
_gsk_render_node_ref (GskRenderNode *node)
{
g_atomic_ref_count_inc (&node->ref_count);
return node;
}
gsk: Add a private getter for container children No need to get them one-by-one, in our inner loop.
2021-07-24 13:49:09 +00:00
gsk: Switch box shadow nodes to use offsets Instead of float dx; float dy; have a graphene_point_t offset; in the object and in all APIs relating to them.
2024-08-09 23:04:54 +00:00
GskRenderNode * gsk_color_node_new2 (const GdkColor *color,
const graphene_rect_t *bounds);
const GdkColor * gsk_color_node_get_color2 (const GskRenderNode *node);
GskRenderNode * gsk_border_node_new2 (const GskRoundedRect *outline,
const float border_width[4],
const GdkColor border_color[4]);
const GdkColor * gsk_border_node_get_colors2 (const GskRenderNode *node);
GskRenderNode * gsk_inset_shadow_node_new2 (const GskRoundedRect *outline,
const GdkColor *color,
const graphene_point_t *offset,
float spread,
float blur_radius);
const GdkColor * gsk_inset_shadow_node_get_color2 (const GskRenderNode *node);
const graphene_point_t *gsk_inset_shadow_node_get_offset (const GskRenderNode *node);
GskRenderNode * gsk_outset_shadow_node_new2 (const GskRoundedRect *outline,
const GdkColor *color,
const graphene_point_t *offset,
float spread,
float blur_radius);
const GdkColor * gsk_outset_shadow_node_get_color2 (const GskRenderNode *node);
const graphene_point_t *gsk_outset_shadow_node_get_offset (const GskRenderNode *node);
gsk: Add private box shadow node api Add a constructor that takes a GdkColor, and a getter for it.
2024-08-02 11:40:27 +00:00
gsk: Add private shadow node api Add a new GskShadow2 struct that has a GdkColor instead of a GdkRGBA, and a new constructor and getter to go along with it. With this commit, my_color_get_depth is no longer used and has been dropped.
2024-08-02 14:53:06 +00:00
typedef struct _GskShadow2 GskShadow2;
struct _GskShadow2
{
GdkColor color;
graphene_point_t offset;
float radius;
};
GskRenderNode * gsk_shadow_node_new2 (GskRenderNode *child,
const GskShadow2 *shadows,
gsize n_shadows);
const GskShadow2 *gsk_shadow_node_get_shadow2 (const GskRenderNode *node,
gsize i);
gsk: Add private box shadow node api Add a constructor that takes a GdkColor, and a getter for it.
2024-08-02 11:40:27 +00:00
gsk: Add private text node api Add a constructor that takes a GdkColor and a corresponding getter.
2024-08-02 04:41:29 +00:00
GskRenderNode * gsk_text_node_new2 (PangoFont *font,
PangoGlyphString *glyphs,
const GdkColor *color,
const graphene_point_t *offset);
const GdkColor *gsk_text_node_get_color2 (const GskRenderNode *node);
gsk: Add private box shadow node api Add a constructor that takes a GdkColor, and a getter for it.
2024-08-02 11:40:27 +00:00
rendernode: Inline gsk_render_node_get_node_type This is the most-called function on render nodes.
2024-09-08 13:47:47 +00:00
#define GSK_RENDER_NODE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GSK_TYPE_RENDER_NODE, GskRenderNodeClass))
#define gsk_render_node_get_node_type(node) _gsk_render_node_get_node_type (node)
G_GNUC_PURE static inline
GskRenderNodeType
_gsk_render_node_get_node_type (const GskRenderNode *node)
{
return GSK_RENDER_NODE_GET_CLASS (node)->node_type;
}
Initial implementation of GSK rendering pipeline GSK is conceptually split into two scene graphs: * a simple rendering tree of operations * a complex set of logical layers The latter is built on the former, and adds convenience and high level API for application developers. The lower layer, though, is what gets transformed into the rendering pipeline, as it's simple and thus can be transformed into appropriate rendering commands with minimal state changes. The lower layer is also suitable for reuse from more complex higher layers, like the CSS machinery in GTK, without necessarily port those layers to the GSK high level API. This lower layer is based on GskRenderNode instances, which represent the tree of rendering operations; and a GskRenderer instance, which takes the render nodes and submits them (after potentially reordering and transforming them to a more appropriate representation) to the underlying graphic system.
2016-03-17 13:48:19 +00:00
G_END_DECLS
Reference in New Issue Copy Permalink