2019-12-25 17:53:58 +00:00
|
|
|
/*
|
|
|
|
* This an unstable interface of wlroots. No guarantees are made regarding the
|
|
|
|
* future consistency of this API.
|
|
|
|
*/
|
|
|
|
#ifndef WLR_USE_UNSTABLE
|
|
|
|
#error "Add -DWLR_USE_UNSTABLE to enable unstable wlroots features"
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifndef WLR_TYPES_WLR_SCENE_H
|
|
|
|
#define WLR_TYPES_WLR_SCENE_H
|
|
|
|
|
|
|
|
/**
|
|
|
|
* The scene-graph API provides a declarative way to display surfaces. The
|
|
|
|
* compositor creates a scene, adds surfaces, then renders the scene on
|
|
|
|
* outputs.
|
|
|
|
*
|
|
|
|
* The scene-graph API only supports basic 2D composition operations (like the
|
|
|
|
* KMS API or the Wayland protocol does). For anything more complicated,
|
|
|
|
* compositors need to implement custom rendering logic.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <pixman.h>
|
|
|
|
#include <wayland-server-core.h>
|
|
|
|
#include <wlr/types/wlr_surface.h>
|
|
|
|
|
|
|
|
struct wlr_output;
|
2021-09-02 10:47:28 +00:00
|
|
|
struct wlr_output_layout;
|
2021-10-25 16:29:24 +00:00
|
|
|
struct wlr_xdg_surface;
|
2019-12-25 17:53:58 +00:00
|
|
|
|
|
|
|
enum wlr_scene_node_type {
|
|
|
|
WLR_SCENE_NODE_ROOT,
|
2021-08-20 09:25:02 +00:00
|
|
|
WLR_SCENE_NODE_TREE,
|
2019-12-25 17:53:58 +00:00
|
|
|
WLR_SCENE_NODE_SURFACE,
|
2021-08-13 20:20:48 +00:00
|
|
|
WLR_SCENE_NODE_RECT,
|
2021-09-20 14:05:19 +00:00
|
|
|
WLR_SCENE_NODE_BUFFER,
|
2019-12-25 17:53:58 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
struct wlr_scene_node_state {
|
|
|
|
struct wl_list link; // wlr_scene_node_state.children
|
|
|
|
|
|
|
|
struct wl_list children; // wlr_scene_node_state.link
|
|
|
|
|
2020-05-06 14:16:45 +00:00
|
|
|
bool enabled;
|
2019-12-25 17:53:58 +00:00
|
|
|
int x, y; // relative to parent
|
|
|
|
};
|
|
|
|
|
|
|
|
/** A node is an object in the scene. */
|
|
|
|
struct wlr_scene_node {
|
|
|
|
enum wlr_scene_node_type type;
|
|
|
|
struct wlr_scene_node *parent;
|
|
|
|
struct wlr_scene_node_state state;
|
|
|
|
|
|
|
|
struct {
|
|
|
|
struct wl_signal destroy;
|
|
|
|
} events;
|
2021-08-10 08:42:03 +00:00
|
|
|
|
|
|
|
void *data;
|
2019-12-25 17:53:58 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/** The root scene-graph node. */
|
|
|
|
struct wlr_scene {
|
|
|
|
struct wlr_scene_node node;
|
2021-08-17 10:24:11 +00:00
|
|
|
|
|
|
|
struct wl_list outputs; // wlr_scene_output.link
|
2019-12-25 17:53:58 +00:00
|
|
|
};
|
|
|
|
|
2021-08-20 09:25:02 +00:00
|
|
|
/** A sub-tree in the scene-graph. */
|
|
|
|
struct wlr_scene_tree {
|
|
|
|
struct wlr_scene_node node;
|
|
|
|
};
|
|
|
|
|
2019-12-25 17:53:58 +00:00
|
|
|
/** A scene-graph node displaying a single surface. */
|
|
|
|
struct wlr_scene_surface {
|
|
|
|
struct wlr_scene_node node;
|
|
|
|
struct wlr_surface *surface;
|
|
|
|
|
|
|
|
// private state
|
|
|
|
|
|
|
|
struct wl_listener surface_destroy;
|
2021-08-17 13:12:47 +00:00
|
|
|
struct wl_listener surface_commit;
|
2019-12-25 17:53:58 +00:00
|
|
|
};
|
|
|
|
|
2021-08-13 20:20:48 +00:00
|
|
|
/** A scene-graph node displaying a solid-colored rectangle */
|
|
|
|
struct wlr_scene_rect {
|
|
|
|
struct wlr_scene_node node;
|
|
|
|
int width, height;
|
|
|
|
float color[4];
|
|
|
|
};
|
|
|
|
|
2021-09-20 14:05:19 +00:00
|
|
|
/** A scene-graph node displaying a buffer */
|
|
|
|
struct wlr_scene_buffer {
|
|
|
|
struct wlr_scene_node node;
|
|
|
|
struct wlr_buffer *buffer;
|
|
|
|
|
|
|
|
// private state
|
|
|
|
|
|
|
|
struct wlr_texture *texture;
|
2021-09-20 15:41:52 +00:00
|
|
|
struct wlr_fbox src_box;
|
2021-09-20 16:05:11 +00:00
|
|
|
int dst_width, dst_height;
|
2021-09-20 16:19:05 +00:00
|
|
|
enum wl_output_transform transform;
|
2021-09-20 14:05:19 +00:00
|
|
|
};
|
|
|
|
|
2021-08-17 10:24:11 +00:00
|
|
|
/** A viewport for an output in the scene-graph */
|
|
|
|
struct wlr_scene_output {
|
|
|
|
struct wlr_output *output;
|
|
|
|
struct wl_list link; // wlr_scene.outputs
|
|
|
|
struct wlr_scene *scene;
|
|
|
|
struct wlr_addon addon;
|
|
|
|
|
2021-08-17 13:12:47 +00:00
|
|
|
struct wlr_output_damage *damage;
|
|
|
|
|
2021-08-17 10:24:11 +00:00
|
|
|
int x, y;
|
2021-10-20 14:08:47 +00:00
|
|
|
|
|
|
|
// private state
|
|
|
|
|
|
|
|
bool prev_scanout;
|
2021-08-17 10:24:11 +00:00
|
|
|
};
|
|
|
|
|
2021-08-13 20:18:29 +00:00
|
|
|
typedef void (*wlr_scene_node_iterator_func_t)(struct wlr_scene_node *node,
|
|
|
|
int sx, int sy, void *data);
|
|
|
|
|
2019-12-25 17:53:58 +00:00
|
|
|
/**
|
|
|
|
* Immediately destroy the scene-graph node.
|
|
|
|
*/
|
|
|
|
void wlr_scene_node_destroy(struct wlr_scene_node *node);
|
2020-05-06 14:16:45 +00:00
|
|
|
/**
|
|
|
|
* Enable or disable this node. If a node is disabled, all of its children are
|
|
|
|
* implicitly disabled as well.
|
|
|
|
*/
|
|
|
|
void wlr_scene_node_set_enabled(struct wlr_scene_node *node, bool enabled);
|
2019-12-25 17:53:58 +00:00
|
|
|
/**
|
|
|
|
* Set the position of the node relative to its parent.
|
|
|
|
*/
|
|
|
|
void wlr_scene_node_set_position(struct wlr_scene_node *node, int x, int y);
|
|
|
|
/**
|
|
|
|
* Move the node right above the specified sibling.
|
2021-10-13 14:00:53 +00:00
|
|
|
* Asserts that node and sibling are distinct and share the same parent.
|
2019-12-25 17:53:58 +00:00
|
|
|
*/
|
|
|
|
void wlr_scene_node_place_above(struct wlr_scene_node *node,
|
|
|
|
struct wlr_scene_node *sibling);
|
|
|
|
/**
|
|
|
|
* Move the node right below the specified sibling.
|
2021-10-13 14:00:53 +00:00
|
|
|
* Asserts that node and sibling are distinct and share the same parent.
|
2019-12-25 17:53:58 +00:00
|
|
|
*/
|
|
|
|
void wlr_scene_node_place_below(struct wlr_scene_node *node,
|
|
|
|
struct wlr_scene_node *sibling);
|
2021-10-13 14:11:54 +00:00
|
|
|
/**
|
|
|
|
* Move the node above all of its sibling nodes.
|
|
|
|
*/
|
|
|
|
void wlr_scene_node_raise_to_top(struct wlr_scene_node *node);
|
|
|
|
/**
|
|
|
|
* Move the node below all of its sibling nodes.
|
|
|
|
*/
|
|
|
|
void wlr_scene_node_lower_to_bottom(struct wlr_scene_node *node);
|
2021-08-23 19:32:59 +00:00
|
|
|
/**
|
|
|
|
* Move the node to another location in the tree.
|
|
|
|
*/
|
|
|
|
void wlr_scene_node_reparent(struct wlr_scene_node *node,
|
|
|
|
struct wlr_scene_node *new_parent);
|
2021-08-17 11:20:32 +00:00
|
|
|
/**
|
|
|
|
* Get the node's layout-local coordinates.
|
|
|
|
*
|
|
|
|
* True is returned if the node and all of its ancestors are enabled.
|
|
|
|
*/
|
|
|
|
bool wlr_scene_node_coords(struct wlr_scene_node *node, int *lx, int *ly);
|
2019-12-25 17:53:58 +00:00
|
|
|
/**
|
|
|
|
* Call `iterator` on each surface in the scene-graph, with the surface's
|
|
|
|
* position in layout coordinates. The function is called from root to leaves
|
|
|
|
* (in rendering order).
|
|
|
|
*/
|
|
|
|
void wlr_scene_node_for_each_surface(struct wlr_scene_node *node,
|
|
|
|
wlr_surface_iterator_func_t iterator, void *user_data);
|
2021-08-10 09:26:34 +00:00
|
|
|
/**
|
2021-08-28 19:14:16 +00:00
|
|
|
* Find the topmost node in this scene-graph that contains the point at the
|
|
|
|
* given layout-local coordinates. (For surface nodes, this means accepting
|
|
|
|
* input events at that point.) Returns the node and coordinates relative to the
|
|
|
|
* returned node, or NULL if no node is found at that location.
|
2021-08-10 09:26:34 +00:00
|
|
|
*/
|
2021-08-28 19:14:16 +00:00
|
|
|
struct wlr_scene_node *wlr_scene_node_at(struct wlr_scene_node *node,
|
|
|
|
double lx, double ly, double *nx, double *ny);
|
2019-12-25 17:53:58 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Create a new scene-graph.
|
|
|
|
*/
|
|
|
|
struct wlr_scene *wlr_scene_create(void);
|
|
|
|
/**
|
|
|
|
* Manually render the scene-graph on an output. The compositor needs to call
|
|
|
|
* wlr_renderer_begin before and wlr_renderer_end after calling this function.
|
|
|
|
* Damage is given in output-buffer-local coordinates and can be set to NULL to
|
|
|
|
* disable damage tracking.
|
|
|
|
*/
|
|
|
|
void wlr_scene_render_output(struct wlr_scene *scene, struct wlr_output *output,
|
|
|
|
int lx, int ly, pixman_region32_t *damage);
|
|
|
|
|
2021-08-20 09:25:02 +00:00
|
|
|
/**
|
|
|
|
* Add a node displaying nothing but its children.
|
|
|
|
*/
|
|
|
|
struct wlr_scene_tree *wlr_scene_tree_create(struct wlr_scene_node *parent);
|
|
|
|
|
2019-12-25 17:53:58 +00:00
|
|
|
/**
|
|
|
|
* Add a node displaying a single surface to the scene-graph.
|
|
|
|
*
|
|
|
|
* The child sub-surfaces are ignored.
|
|
|
|
*/
|
|
|
|
struct wlr_scene_surface *wlr_scene_surface_create(struct wlr_scene_node *parent,
|
|
|
|
struct wlr_surface *surface);
|
|
|
|
|
2021-08-28 19:14:16 +00:00
|
|
|
struct wlr_scene_surface *wlr_scene_surface_from_node(struct wlr_scene_node *node);
|
|
|
|
|
2021-08-13 20:20:48 +00:00
|
|
|
/**
|
|
|
|
* Add a node displaying a solid-colored rectangle to the scene-graph.
|
|
|
|
*/
|
|
|
|
struct wlr_scene_rect *wlr_scene_rect_create(struct wlr_scene_node *parent,
|
|
|
|
int width, int height, const float color[static 4]);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Change the width and height of an existing rectangle node.
|
|
|
|
*/
|
|
|
|
void wlr_scene_rect_set_size(struct wlr_scene_rect *rect, int width, int height);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Change the color of an existing rectangle node.
|
|
|
|
*/
|
|
|
|
void wlr_scene_rect_set_color(struct wlr_scene_rect *rect, const float color[static 4]);
|
|
|
|
|
2021-09-20 14:05:19 +00:00
|
|
|
/**
|
|
|
|
* Add a node displaying a buffer to the scene-graph.
|
|
|
|
*/
|
|
|
|
struct wlr_scene_buffer *wlr_scene_buffer_create(struct wlr_scene_node *parent,
|
|
|
|
struct wlr_buffer *buffer);
|
|
|
|
|
2021-09-20 15:41:52 +00:00
|
|
|
/**
|
|
|
|
* Set the source rectangle describing the region of the buffer which will be
|
|
|
|
* sampled to render this node. This allows cropping the buffer.
|
|
|
|
*
|
|
|
|
* If NULL, the whole buffer is sampled. By default, the source box is NULL.
|
|
|
|
*/
|
|
|
|
void wlr_scene_buffer_set_source_box(struct wlr_scene_buffer *scene_buffer,
|
|
|
|
const struct wlr_fbox *box);
|
|
|
|
|
2021-09-20 16:05:11 +00:00
|
|
|
/**
|
|
|
|
* Set the destination size describing the region of the scene-graph the buffer
|
|
|
|
* will be painted onto. This allows scaling the buffer.
|
|
|
|
*
|
|
|
|
* If zero, the destination size will be the buffer size. By default, the
|
|
|
|
* destination size is zero.
|
|
|
|
*/
|
|
|
|
void wlr_scene_buffer_set_dest_size(struct wlr_scene_buffer *scene_buffer,
|
|
|
|
int width, int height);
|
|
|
|
|
2021-09-20 16:19:05 +00:00
|
|
|
/**
|
|
|
|
* Set a transform which will be applied to the buffer.
|
|
|
|
*/
|
|
|
|
void wlr_scene_buffer_set_transform(struct wlr_scene_buffer *scene_buffer,
|
|
|
|
enum wl_output_transform transform);
|
|
|
|
|
2021-08-17 10:24:11 +00:00
|
|
|
/**
|
|
|
|
* Add a viewport for the specified output to the scene-graph.
|
|
|
|
*
|
|
|
|
* An output can only be added once to the scene-graph.
|
|
|
|
*/
|
|
|
|
struct wlr_scene_output *wlr_scene_output_create(struct wlr_scene *scene,
|
|
|
|
struct wlr_output *output);
|
|
|
|
/**
|
|
|
|
* Destroy a scene-graph output.
|
|
|
|
*/
|
|
|
|
void wlr_scene_output_destroy(struct wlr_scene_output *scene_output);
|
|
|
|
/**
|
|
|
|
* Set the output's position in the scene-graph.
|
|
|
|
*/
|
|
|
|
void wlr_scene_output_set_position(struct wlr_scene_output *scene_output,
|
|
|
|
int lx, int ly);
|
2021-08-17 10:30:17 +00:00
|
|
|
/**
|
|
|
|
* Render and commit an output.
|
|
|
|
*/
|
|
|
|
bool wlr_scene_output_commit(struct wlr_scene_output *scene_output);
|
2021-08-17 10:24:11 +00:00
|
|
|
|
2021-10-20 16:16:27 +00:00
|
|
|
/**
|
|
|
|
* Call `iterator` on each surface in the scene-graph visible on the output,
|
|
|
|
* with the surface's position in layout coordinates. The function is called
|
|
|
|
* from root to leaves (in rendering order).
|
|
|
|
*/
|
|
|
|
void wlr_scene_output_for_each_surface(struct wlr_scene_output *scene_output,
|
|
|
|
wlr_surface_iterator_func_t iterator, void *user_data);
|
2021-11-30 19:55:04 +00:00
|
|
|
/**
|
|
|
|
* Get a scene-graph output from a wlr_output.
|
|
|
|
*
|
|
|
|
* If the output hasn't been added to the scene-graph, returns NULL.
|
|
|
|
*/
|
|
|
|
struct wlr_scene_output *wlr_scene_get_scene_output(struct wlr_scene *scene,
|
|
|
|
struct wlr_output *output);
|
2021-10-20 16:16:27 +00:00
|
|
|
|
2021-09-02 10:47:28 +00:00
|
|
|
/**
|
|
|
|
* Attach an output layout to a scene.
|
|
|
|
*
|
|
|
|
* Outputs in the output layout are automatically added to the scene. Any
|
|
|
|
* change to the output layout is mirrored to the scene-graph outputs.
|
|
|
|
*/
|
|
|
|
bool wlr_scene_attach_output_layout(struct wlr_scene *scene,
|
|
|
|
struct wlr_output_layout *output_layout);
|
|
|
|
|
2021-08-20 10:41:23 +00:00
|
|
|
/**
|
|
|
|
* Add a node displaying a surface and all of its sub-surfaces to the
|
|
|
|
* scene-graph.
|
|
|
|
*/
|
|
|
|
struct wlr_scene_node *wlr_scene_subsurface_tree_create(
|
|
|
|
struct wlr_scene_node *parent, struct wlr_surface *surface);
|
|
|
|
|
2021-10-25 16:29:24 +00:00
|
|
|
/**
|
|
|
|
* Add a node displaying an xdg_surface and all of its sub-surfaces to the
|
|
|
|
* scene-graph.
|
|
|
|
*
|
|
|
|
* The origin of the returned scene-graph node will match the top-left corner
|
|
|
|
* of the xdg_surface window geometry.
|
|
|
|
*/
|
|
|
|
struct wlr_scene_node *wlr_scene_xdg_surface_create(
|
|
|
|
struct wlr_scene_node *parent, struct wlr_xdg_surface *xdg_surface);
|
|
|
|
|
2019-12-25 17:53:58 +00:00
|
|
|
#endif
|