AuroraMiddleware/gtk2
1
0
Fork 0
forked from AuroraMiddleware/gtk
Code Issues Pull Requests Projects Releases Wiki Activity
59d638a09f
gtk2/gsk/gskrendernode.h

109 lines
4.8 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
/* GSK - The GTK Scene Kit
*
* Copyright 2016 Endless
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __GSK_RENDER_NODE_H__
#define __GSK_RENDER_NODE_H__
#if !defined (__GSK_H_INSIDE__) && !defined (GSK_COMPILATION)
#error "Only <gsk/gsk.h> can be included directly."
#endif
#include <gsk/gsktypes.h>
G_BEGIN_DECLS
#define GSK_TYPE_RENDER_NODE (gsk_render_node_get_type ())
gsk: Make GskRenderNode a boxed type
2016-12-10 14:33:16 +00:00
#define GSK_IS_RENDER_NODE(obj) ((obj) != NULL)
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
typedef struct _GskRenderNode GskRenderNode;
gsk: Bump up all version annotations GSK is part of the 4.0 development cycle.
2016-10-18 10:37:10 +00:00
GDK_AVAILABLE_IN_3_90
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
GType gsk_render_node_get_type (void) G_GNUC_CONST;
gsk: Bump up all version annotations GSK is part of the 4.0 development cycle.
2016-10-18 10:37:10 +00:00
GDK_AVAILABLE_IN_3_90
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
GskRenderNode * gsk_render_node_ref (GskRenderNode *node);
gsk: Bump up all version annotations GSK is part of the 4.0 development cycle.
2016-10-18 10:37:10 +00:00
GDK_AVAILABLE_IN_3_90
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
void gsk_render_node_unref (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 GskRenderNodeType For now, this is unused.
2016-12-10 20:42:01 +00:00
GDK_AVAILABLE_IN_3_90
GskRenderNodeType gsk_render_node_get_node_type (GskRenderNode *node);
gsk: Add gsk_color_node_new()
2016-12-13 02:35:56 +00:00
GDK_AVAILABLE_IN_3_90
GskRenderNode * gsk_color_node_new (const GdkRGBA *rgba,
const graphene_rect_t *bounds);
gsk: Add gsk_texture_node_new() Start the transition into the different node types.
2016-12-10 21:52:22 +00:00
GDK_AVAILABLE_IN_3_90
GskRenderNode * gsk_texture_node_new (GskTexture *texture,
const graphene_rect_t *bounds);
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
GDK_AVAILABLE_IN_3_90
GskRenderNode * gsk_cairo_node_new (const graphene_rect_t *bounds);
GDK_AVAILABLE_IN_3_90
cairo_t * gsk_cairo_node_get_draw_context (GskRenderNode *node,
GskRenderer *renderer);
gsk: Add gsk_container_node_new() It replaces gsk_renderer_create_render_node() which was doing the eact same thing, only taking an unused extra argument.
2016-12-11 03:14:04 +00:00
GDK_AVAILABLE_IN_3_90
snapshot: Change how gtk_snapshot_push/pop works Instead of appending a container node and adding the nodes to it as they come in, we now collect the nodes until gtk_snapshot_pop() is called and then hand them out in a container node. The caller of gtk_snapshot_push() is then responsible for doing whatever he wants with the created node. Another addigion is the keep_coordinates flag to gtk_snapshot_push() which allows callers to keep the current offset and clip region or discard it. Discarding is useful when doing transforms, keeping it is useful when inserting effect nodes (like the ones I'm about to add).
2016-12-13 01:33:15 +00:00
GskRenderNode * gsk_container_node_new (GskRenderNode **children,
guint n_children);
gsk: Bump up all version annotations GSK is part of the 4.0 development cycle.
2016-10-18 10:37:10 +00:00
GDK_AVAILABLE_IN_3_90
snapshot: Change how gtk_snapshot_push/pop works Instead of appending a container node and adding the nodes to it as they come in, we now collect the nodes until gtk_snapshot_pop() is called and then hand them out in a container node. The caller of gtk_snapshot_push() is then responsible for doing whatever he wants with the created node. Another addigion is the keep_coordinates flag to gtk_snapshot_push() which allows callers to keep the current offset and clip region or discard it. Discarding is useful when doing transforms, keeping it is useful when inserting effect nodes (like the ones I'm about to add).
2016-12-13 01:33:15 +00:00
guint gsk_container_node_get_n_children (GskRenderNode *node);
gsk: Bump up all version annotations GSK is part of the 4.0 development cycle.
2016-10-18 10:37:10 +00:00
GDK_AVAILABLE_IN_3_90
snapshot: Change how gtk_snapshot_push/pop works Instead of appending a container node and adding the nodes to it as they come in, we now collect the nodes until gtk_snapshot_pop() is called and then hand them out in a container node. The caller of gtk_snapshot_push() is then responsible for doing whatever he wants with the created node. Another addigion is the keep_coordinates flag to gtk_snapshot_push() which allows callers to keep the current offset and clip region or discard it. Discarding is useful when doing transforms, keeping it is useful when inserting effect nodes (like the ones I'm about to add).
2016-12-13 01:33:15 +00:00
GskRenderNode * gsk_container_node_get_child (GskRenderNode *node,
guint idx);
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: Bump up all version annotations GSK is part of the 4.0 development cycle.
2016-10-18 10:37:10 +00:00
GDK_AVAILABLE_IN_3_90
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
GskRenderNode * gsk_transform_node_new (GskRenderNode *child,
gsk: Rename set_offset() to set_anchor_point() The naming is consistent with other scene graph libraries, as it represents an additional translation transformation applied on top of the provided transformation matrices. We can also simplify the implementation by applying the translation when we compute the world matrix.
2016-08-04 14:20:06 +00:00
const graphene_matrix_t *transform);
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
GDK_AVAILABLE_IN_3_90
GskRenderNode * gsk_transform_node_get_child (GskRenderNode *node);
gsk: Bump up all version annotations GSK is part of the 4.0 development cycle.
2016-10-18 10:37:10 +00:00
GDK_AVAILABLE_IN_3_90
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
GskRenderNode * gsk_opacity_node_new (GskRenderNode *child,
double opacity);
GDK_AVAILABLE_IN_3_90
GskRenderNode * gsk_opacity_node_get_child (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_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
GDK_AVAILABLE_IN_3_90
GskRenderNode * gsk_clip_node_new (GskRenderNode *child,
const graphene_rect_t *clip);
GDK_AVAILABLE_IN_3_90
GskRenderNode * gsk_clip_node_get_child (GskRenderNode *node);
gsk: Bump up all version annotations GSK is part of the 4.0 development cycle.
2016-10-18 10:37:10 +00:00
GDK_AVAILABLE_IN_3_90
gsk: Store blend mode in the render node
2016-07-01 11:12:30 +00:00
void gsk_render_node_set_blend_mode (GskRenderNode *node,
GskBlendMode blend_mode);
gsk: Add gsk_texture_node_new() Start the transition into the different node types.
2016-12-10 21:52:22 +00:00
gsk: Bump up all version annotations GSK is part of the 4.0 development cycle.
2016-10-18 10:37:10 +00:00
GDK_AVAILABLE_IN_3_90
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
void gsk_render_node_set_scaling_filter (GskRenderNode *node,
GskScalingFilter min_filter,
GskScalingFilter mag_filter);
gsk: Bump up all version annotations GSK is part of the 4.0 development cycle.
2016-10-18 10:37:10 +00:00
GDK_AVAILABLE_IN_3_90
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_set_name (GskRenderNode *node,
const char *name);
API: rendernode: Add gsk_render_node_get_name() Make the debug string available to public API.
2016-10-29 16:08:11 +00:00
GDK_AVAILABLE_IN_3_90
const char * gsk_render_node_get_name (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_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
GDK_AVAILABLE_IN_3_90
void gsk_render_node_draw (GskRenderNode *node,
cairo_t *cr);
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_H__ */
Reference in New Issue Copy Permalink