AuroraMiddleware/gtk
1
0
Fork 1
mirror of https://gitlab.gnome.org/GNOME/gtk.git synced 2024-12-27 06:00:22 +00:00
Code Issues Projects Releases Wiki Activity
b03abea402
gtk/gsk/gskrendernodeprivate.h

93 lines
3.9 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: Don't change the GskRenderNodeType order As we use their values to check that a node can be downcasted to a node type in the Rust bindings such change would break existing code
2023-08-09 18:03:29 +00:00
#define GSK_RENDER_NODE_TYPE_N_TYPES (GSK_STROKE_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
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
};
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,
cairo_region_t *region);
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
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,
cairo_region_t *region);
void gsk_render_node_diff_impossible (GskRenderNode *node1,
GskRenderNode *node2,
cairo_region_t *region);
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,
cairo_region_t *region);
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
gsk: make render node getters const This also removes the return if fail macros from these as a good portion of them didn't have them anyway. I think it's fair to say that access to these incorrectly is a programmer error. It significantly reduces the amount of code generated into generally a movss,ret.
2021-02-03 22:49:42 +00:00
bool gsk_border_node_get_uniform (const GskRenderNode *self);
gsk: Add gsk_border_node_get_uniform_color Maintain this bit of information separately, it will be useful in the next commit.
2021-03-09 02:36:41 +00:00
bool gsk_border_node_get_uniform_color (const GskRenderNode *self);
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);
GdkMemoryDepth gsk_render_node_get_preferred_depth (const GskRenderNode *node);
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
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
gboolean gsk_container_node_is_disjoint (const GskRenderNode *node);
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
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
gboolean gsk_render_node_use_offscreen_for_opacity (const GskRenderNode *node);
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: 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