AuroraMiddleware/gtk
1
0
Fork 1
mirror of https://gitlab.gnome.org/GNOME/gtk.git synced 2024-12-26 13:41:07 +00:00
Code Issues Projects Releases Wiki Activity
34fb08af6e
gtk/gsk/gskrendernodeprivate.h

115 lines
4.7 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"
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: 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
guint preferred_depth : 2;
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;
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
Make render node getter public Keeping these private does not really buy us anything.
2017-10-20 06:06:20 +00:00
void (* finalize) (GskRenderNode *node);
void (* draw) (GskRenderNode *node,
cairo_t *cr);
Add pure and const annotations to various functions
2020-01-24 12:17:09 +00:00
gboolean (* can_diff) (const GskRenderNode *node1,
const GskRenderNode *node2);
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
void (* 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);
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);
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);
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 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
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