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

70 lines
1.9 KiB
C
Raw Normal View History

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
#ifndef __GSK_RENDER_NODE_PRIVATE_H__
#define __GSK_RENDER_NODE_PRIVATE_H__
#include "gskrendernode.h"
#include <cairo.h>
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;
#define GSK_IS_RENDER_NODE_TYPE(node,type) (GSK_IS_RENDER_NODE (node) && (node)->node_class->node_type == (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
{
gsk: Introduce GskRenderNodeClass This is modeled after GtkCssValueClass. So far it doesn't do anything.
2016-12-11 02:57:42 +00:00
const GskRenderNodeClass *node_class;
gsk: Add GskRenderNodeType For now, this is unused.
2016-12-10 20:42:01 +00:00
gsk: Turn GskRenderNode into a pure GTypeInstance Using GObject as the base type for a transient tree may prove to be too intensive, especially when creating a lot of node instances. Since we don't need properties or signals, and we don't need complex destruction semantics, we can use GTypeInstance directly as the base type for GskRenderNode.
2016-06-29 18:05:33 +00:00
volatile int 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
/* Use for debugging */
char *name;
gsk: Move scaling filters to GskRenderNode The renderer will always use nearest-neighbor filters because it renders at 1:1 pixel to texel ratio. On the other hand, render nodes may be scaled, so we need to offer a way to control the minification and magnification filters.
2016-08-13 07:34:22 +00:00
/* Scaling filters */
GskScalingFilter min_filter;
GskScalingFilter mag_filter;
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
/* Bit fields; leave at the end */
gsk: Rework GskRenderer and GskRenderNode semantics This commit changes the way GskRenderer and GskRenderNode interact and are meant to be used. GskRenderNode should represent a transient tree of rendering nodes, which are submitted to the GskRenderer at render time; this allows the renderer to take ownership of the render tree. Once the toolkit and application code have finished assembling it, the render tree ownership is transferred to the renderer.
2016-06-22 16:30:36 +00:00
gboolean is_mutable : 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
{
GskRenderNodeType node_type;
gsk: Add custom structs to RenderNode subclasses So now we don't need to keep a texture pointer and a surface pointer and so on in the base struct.
2016-12-11 03:28:21 +00:00
gsize struct_size;
gsk: Introduce GskRenderNodeClass This is modeled after GtkCssValueClass. So far it doesn't do anything.
2016-12-11 02:57:42 +00:00
const char *type_name;
gsk: Add GskRenderNodeClass.finalize()
2016-12-11 03:18:25 +00:00
void (* finalize) (GskRenderNode *node);
gsk: Add GskRenderNodeClass.make_immutable()
2016-12-11 10:53:17 +00:00
void (* make_immutable) (GskRenderNode *node);
gsk: Add gsk_render_node_draw() Draws a node to a given cairo_t. This is mostly intended for fallback usage.
2016-12-13 02:05:15 +00:00
void (* draw) (GskRenderNode *node,
cairo_t *cr);
gsk: Remove gsk_render_node_set_bounds() gsk_render_node_get_bounds() still exists and is computed via vfunc call: - containers dynamically compute the bounds from their children - surface and texture nodes get bounds passed on construction
2016-12-12 05:29:04 +00:00
void (* get_bounds) (GskRenderNode *node,
graphene_rect_t *bounds);
gsk: Introduce GskRenderNodeClass This is modeled after GtkCssValueClass. So far it doesn't do anything.
2016-12-11 02:57:42 +00:00
};
GskRenderNode *gsk_render_node_new (const GskRenderNodeClass *node_class);
gsk: Tie render nodes to renderers Render nodes need access to rendering information like scaling factors. If we keep render nodes separate from renderers until we submit a nodes tree for rendering we're going to have to duplicate all that information in a way that makes the API more complicated and fuzzier on its semantics. By having GskRenderer create GskRenderNode instances we can tie nodes and renderers together; since higher layers will also have access to the renderer instance, this does not add any burden to callers. Additionally, if memory measurements indicate that we are spending too much time in the allocation of new render nodes, we can now easily implement a free-list or a renderer-specific allocator without breaking the API.
2016-07-27 15:23:44 +00:00
gsk: Rework GskRenderer and GskRenderNode semantics This commit changes the way GskRenderer and GskRenderNode interact and are meant to be used. GskRenderNode should represent a transient tree of rendering nodes, which are submitted to the GskRenderer at render time; this allows the renderer to take ownership of the render tree. Once the toolkit and application code have finished assembling it, the render tree ownership is transferred to the renderer.
2016-06-22 16:30:36 +00:00
void gsk_render_node_make_immutable (GskRenderNode *node);
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
void gsk_render_node_get_bounds (GskRenderNode *node,
graphene_rect_t *frame);
gsk: Replace gsk_render_node_set_opacity() ... with gsk_opacity_node_new(). Also implement support for opacity in gtk_widget_snapshot() using this new node.
2016-12-13 04:49:57 +00:00
double gsk_opacity_node_get_opacity (GskRenderNode *node);
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 gsk_cairo_node_new() Split off Cairo drawn content nodes and require you to allocate them using this new function.
2016-12-11 00:23:02 +00:00
cairo_surface_t *gsk_cairo_node_get_surface (GskRenderNode *node);
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 gsk_texture_node_new() Start the transition into the different node types.
2016-12-10 21:52:22 +00:00
GskTexture *gsk_texture_node_get_texture (GskRenderNode *node);
gsk: Allow adding a GL texture as a node content If we already have a GL texture we definitely don't want to use gdk_cairo_draw_from_gl() to draw on a Cairo context if we're going to take the Cairo surface to which we draw and put it into an OpenGL texture.
2016-08-12 15:44:29 +00:00
gsk: Add gsk_color_node_new()
2016-12-13 02:35:56 +00:00
const GdkRGBA *gsk_color_node_peek_color (GskRenderNode *node);
gsk: Add gsk_clip_node_new() The node is a simple clipping node: It does a rectangular clip of its contents.
2016-12-13 08:37:51 +00:00
const graphene_rect_t * gsk_clip_node_peek_clip (GskRenderNode *node);
gsk: Add support for rounded clip rectangles Also add support to GtkSnapshot, so people can push rounded clips.
2016-12-13 20:59:28 +00:00
const GskRoundedRect * gsk_rounded_clip_node_peek_clip (GskRenderNode *node);
gsk: gsk_render_node_set_transform() => GskTransformNode Instead of having a setter for the transform, have a GskTransformNode. Most of the oprations that GTK does do not require a transform, so it doesn't make sense to have it as a primary attribute. Also, changing the transform requires updating the uniforms of the GL renderer, so we're happy if we can avoid that.
2016-12-12 23:11:06 +00:00
void gsk_transform_node_get_transform (GskRenderNode *node, graphene_matrix_t *transform);
gsk: Add blend nodes Implement blend mode support in GTK background compositing with it.
2016-12-15 03:24:37 +00:00
GskRenderNode * gsk_blend_node_get_bottom_child (GskRenderNode *node);
GskRenderNode * gsk_blend_node_get_top_child (GskRenderNode *node);
GskBlendMode gsk_blend_node_get_blend_node (GskRenderNode *node);
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
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
#endif /* __GSK_RENDER_NODE_PRIVATE_H__ */
Reference in New Issue Copy Permalink