mirror of
https://gitlab.freedesktop.org/wlroots/wlroots.git
synced 2026-04-21 06:46:46 -04:00
wlr_scene_buffer: Rework to use wlr_raster
This commit is contained in:
Alexander Orzechowski
parent
605c4aed38
commit
a193d450ed
6 changed files with 252 additions and 250 deletions
|
|
@ -99,7 +99,7 @@ static void surface_handle_commit(struct wl_listener *listener, void *data) {
|
|||
|
||||
static void surface_handle_destroy(struct wl_listener *listener, void *data) {
|
||||
struct surface *surface = wl_container_of(listener, surface, destroy);
|
||||
wlr_scene_node_destroy(&surface->scene_surface->buffer->node);
|
||||
wlr_scene_node_destroy(&surface->scene_surface->raster->node);
|
||||
wlr_scene_node_destroy(&surface->border->node);
|
||||
wl_list_remove(&surface->destroy.link);
|
||||
wl_list_remove(&surface->link);
|
||||
|
|
@ -129,7 +129,7 @@ static void server_handle_new_surface(struct wl_listener *listener,
|
|||
surface->scene_surface =
|
||||
wlr_scene_surface_create(&server->scene->tree, wlr_surface);
|
||||
|
||||
wlr_scene_node_set_position(&surface->scene_surface->buffer->node,
|
||||
wlr_scene_node_set_position(&surface->scene_surface->raster->node,
|
||||
pos + border_width, pos + border_width);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -31,21 +31,21 @@ struct wlr_xdg_surface;
|
|||
struct wlr_layer_surface_v1;
|
||||
|
||||
struct wlr_scene_node;
|
||||
struct wlr_scene_buffer;
|
||||
struct wlr_scene_raster;
|
||||
|
||||
typedef void (*wlr_scene_node_iterator_func_t)(struct wlr_scene_node *node,
|
||||
int sx, int sy, void *data);
|
||||
|
||||
typedef bool (*wlr_scene_buffer_point_accepts_input_func_t)(
|
||||
struct wlr_scene_buffer *buffer, int sx, int sy);
|
||||
typedef bool (*wlr_scene_raster_point_accepts_input_func_t)(
|
||||
struct wlr_scene_raster *raster, int sx, int sy);
|
||||
|
||||
typedef void (*wlr_scene_buffer_iterator_func_t)(
|
||||
struct wlr_scene_buffer *buffer, int sx, int sy, void *user_data);
|
||||
typedef void (*wlr_scene_raster_iterator_func_t)(
|
||||
struct wlr_scene_raster *raster, int sx, int sy, void *user_data);
|
||||
|
||||
enum wlr_scene_node_type {
|
||||
WLR_SCENE_NODE_TREE,
|
||||
WLR_SCENE_NODE_RECT,
|
||||
WLR_SCENE_NODE_BUFFER,
|
||||
WLR_SCENE_NODE_RASTER,
|
||||
};
|
||||
|
||||
/** A node is an object in the scene. */
|
||||
|
|
@ -98,7 +98,7 @@ struct wlr_scene {
|
|||
|
||||
/** A scene-graph node displaying a single surface. */
|
||||
struct wlr_scene_surface {
|
||||
struct wlr_scene_buffer *buffer;
|
||||
struct wlr_scene_raster *raster;
|
||||
struct wlr_surface *surface;
|
||||
|
||||
// private state
|
||||
|
|
@ -120,12 +120,12 @@ struct wlr_scene_rect {
|
|||
float color[4];
|
||||
};
|
||||
|
||||
/** A scene-graph node displaying a buffer */
|
||||
struct wlr_scene_buffer {
|
||||
/** A scene-graph node displaying a raster */
|
||||
struct wlr_scene_raster {
|
||||
struct wlr_scene_node node;
|
||||
|
||||
// May be NULL
|
||||
struct wlr_buffer *buffer;
|
||||
struct wlr_raster *raster;
|
||||
|
||||
struct {
|
||||
struct wl_signal output_enter; // struct wlr_scene_output
|
||||
|
|
@ -135,11 +135,11 @@ struct wlr_scene_buffer {
|
|||
} events;
|
||||
|
||||
// May be NULL
|
||||
wlr_scene_buffer_point_accepts_input_func_t point_accepts_input;
|
||||
wlr_scene_raster_point_accepts_input_func_t point_accepts_input;
|
||||
|
||||
/**
|
||||
* The output that the largest area of this buffer is displayed on.
|
||||
* This may be NULL if the buffer is not currently displayed on any
|
||||
* The output that the largest area of this raster is displayed on.
|
||||
* This may be NULL if the raster is not currently displayed on any
|
||||
* outputs. This is the output that should be used for frame callbacks,
|
||||
* presentation feedback, etc.
|
||||
*/
|
||||
|
|
@ -148,7 +148,6 @@ struct wlr_scene_buffer {
|
|||
// private state
|
||||
|
||||
uint64_t active_outputs;
|
||||
struct wlr_raster *raster;
|
||||
struct wlr_fbox src_box;
|
||||
int dst_width, dst_height;
|
||||
enum wl_output_transform transform;
|
||||
|
|
@ -240,12 +239,12 @@ void wlr_scene_node_reparent(struct wlr_scene_node *node,
|
|||
*/
|
||||
bool wlr_scene_node_coords(struct wlr_scene_node *node, int *lx, int *ly);
|
||||
/**
|
||||
* Call `iterator` on each buffer in the scene-graph, with the buffer's
|
||||
* Call `iterator` on each raster in the scene-graph, with the raster's
|
||||
* position in layout coordinates. The function is called from root to leaves
|
||||
* (in rendering order).
|
||||
*/
|
||||
void wlr_scene_node_for_each_buffer(struct wlr_scene_node *node,
|
||||
wlr_scene_buffer_iterator_func_t iterator, void *user_data);
|
||||
void wlr_scene_node_for_each_raster(struct wlr_scene_node *node,
|
||||
wlr_scene_raster_iterator_func_t iterator, void *user_data);
|
||||
/**
|
||||
* Find the topmost node in this scene-graph that contains the point at the
|
||||
* given layout-local coordinates. (For surface nodes, this means accepting
|
||||
|
|
@ -285,14 +284,14 @@ struct wlr_scene_tree *wlr_scene_tree_create(struct wlr_scene_tree *parent);
|
|||
struct wlr_scene_surface *wlr_scene_surface_create(struct wlr_scene_tree *parent,
|
||||
struct wlr_surface *surface);
|
||||
|
||||
struct wlr_scene_buffer *wlr_scene_buffer_from_node(struct wlr_scene_node *node);
|
||||
struct wlr_scene_raster *wlr_scene_raster_from_node(struct wlr_scene_node *node);
|
||||
|
||||
/**
|
||||
* If this buffer is backed by a surface, then the struct wlr_scene_surface is
|
||||
* If this raster is backed by a surface, then the struct wlr_scene_surface is
|
||||
* returned. If not, NULL will be returned.
|
||||
*/
|
||||
struct wlr_scene_surface *wlr_scene_surface_from_buffer(
|
||||
struct wlr_scene_buffer *scene_buffer);
|
||||
struct wlr_scene_surface *wlr_scene_surface_from_raster(
|
||||
struct wlr_scene_raster *scene_raster);
|
||||
|
||||
/**
|
||||
* Add a node displaying a solid-colored rectangle to the scene-graph.
|
||||
|
|
@ -311,59 +310,59 @@ void wlr_scene_rect_set_size(struct wlr_scene_rect *rect, int width, int height)
|
|||
void wlr_scene_rect_set_color(struct wlr_scene_rect *rect, const float color[static 4]);
|
||||
|
||||
/**
|
||||
* Add a node displaying a buffer to the scene-graph.
|
||||
* Add a node displaying a raster to the scene-graph.
|
||||
*
|
||||
* If the buffer is NULL, this node will not be displayed.
|
||||
* If the raster is NULL, this node will not be displayed.
|
||||
*/
|
||||
struct wlr_scene_buffer *wlr_scene_buffer_create(struct wlr_scene_tree *parent,
|
||||
struct wlr_buffer *buffer);
|
||||
struct wlr_scene_raster *wlr_scene_raster_create(struct wlr_scene_tree *parent,
|
||||
struct wlr_raster *raster);
|
||||
|
||||
/**
|
||||
* Sets the buffer's backing buffer.
|
||||
* Sets the raster's backing raster.
|
||||
*
|
||||
* If the buffer is NULL, the buffer node will not be displayed.
|
||||
* If the raster is NULL, the raster node will not be displayed.
|
||||
*/
|
||||
void wlr_scene_buffer_set_buffer(struct wlr_scene_buffer *scene_buffer,
|
||||
struct wlr_buffer *buffer);
|
||||
void wlr_scene_raster_set_raster(struct wlr_scene_raster *scene_raster,
|
||||
struct wlr_raster *raster);
|
||||
|
||||
/**
|
||||
* Sets the buffer's backing buffer with a custom damage region.
|
||||
* Sets the raster's backing raster with a custom damage region.
|
||||
*
|
||||
* The damage region is in buffer-local coordinates. If the region is NULL,
|
||||
* the whole buffer node will be damaged.
|
||||
* The damage region is in raster-local coordinates. If the region is NULL,
|
||||
* the whole raster node will be damaged.
|
||||
*/
|
||||
void wlr_scene_buffer_set_buffer_with_damage(struct wlr_scene_buffer *scene_buffer,
|
||||
struct wlr_buffer *buffer, pixman_region32_t *region);
|
||||
void wlr_scene_raster_set_raster_with_damage(struct wlr_scene_raster *scene_raster,
|
||||
struct wlr_raster *raster, pixman_region32_t *region);
|
||||
|
||||
/**
|
||||
* Set the source rectangle describing the region of the buffer which will be
|
||||
* sampled to render this node. This allows cropping the buffer.
|
||||
* Set the source rectangle describing the region of the raster which will be
|
||||
* sampled to render this node. This allows cropping the raster.
|
||||
*
|
||||
* If NULL, the whole buffer is sampled. By default, the source box is NULL.
|
||||
* If NULL, the whole raster is sampled. By default, the source box is NULL.
|
||||
*/
|
||||
void wlr_scene_buffer_set_source_box(struct wlr_scene_buffer *scene_buffer,
|
||||
void wlr_scene_raster_set_source_box(struct wlr_scene_raster *scene_raster,
|
||||
const struct wlr_fbox *box);
|
||||
|
||||
/**
|
||||
* Set the destination size describing the region of the scene-graph the buffer
|
||||
* will be painted onto. This allows scaling the buffer.
|
||||
* Set the destination size describing the region of the scene-graph the raster
|
||||
* will be painted onto. This allows scaling the raster.
|
||||
*
|
||||
* If zero, the destination size will be the buffer size. By default, the
|
||||
* If zero, the destination size will be the raster size. By default, the
|
||||
* destination size is zero.
|
||||
*/
|
||||
void wlr_scene_buffer_set_dest_size(struct wlr_scene_buffer *scene_buffer,
|
||||
void wlr_scene_raster_set_dest_size(struct wlr_scene_raster *scene_raster,
|
||||
int width, int height);
|
||||
|
||||
/**
|
||||
* Set a transform which will be applied to the buffer.
|
||||
* Set a transform which will be applied to the raster.
|
||||
*/
|
||||
void wlr_scene_buffer_set_transform(struct wlr_scene_buffer *scene_buffer,
|
||||
void wlr_scene_raster_set_transform(struct wlr_scene_raster *scene_raster,
|
||||
enum wl_output_transform transform);
|
||||
|
||||
/**
|
||||
* Calls the buffer's frame_done signal.
|
||||
* Calls the raster's frame_done signal.
|
||||
*/
|
||||
void wlr_scene_buffer_send_frame_done(struct wlr_scene_buffer *scene_buffer,
|
||||
void wlr_scene_raster_send_frame_done(struct wlr_scene_raster *scene_raster,
|
||||
struct timespec *now);
|
||||
|
||||
/**
|
||||
|
|
@ -394,12 +393,12 @@ bool wlr_scene_output_commit(struct wlr_scene_output *scene_output);
|
|||
void wlr_scene_output_send_frame_done(struct wlr_scene_output *scene_output,
|
||||
struct timespec *now);
|
||||
/**
|
||||
* Call `iterator` on each buffer in the scene-graph visible on the output,
|
||||
* with the buffer's position in layout coordinates. The function is called
|
||||
* Call `iterator` on each raster in the scene-graph visible on the output,
|
||||
* with the raster's position in layout coordinates. The function is called
|
||||
* from root to leaves (in rendering order).
|
||||
*/
|
||||
void wlr_scene_output_for_each_buffer(struct wlr_scene_output *scene_output,
|
||||
wlr_scene_buffer_iterator_func_t iterator, void *user_data);
|
||||
void wlr_scene_output_for_each_raster(struct wlr_scene_output *scene_output,
|
||||
wlr_scene_raster_iterator_func_t iterator, void *user_data);
|
||||
/**
|
||||
* Get a scene-graph output from a struct wlr_output.
|
||||
*
|
||||
|
|
|
|||
|
|
@ -343,12 +343,12 @@ static struct tinywl_view *desktop_view_at(
|
|||
* surface in the surface tree of a tinywl_view. */
|
||||
struct wlr_scene_node *node = wlr_scene_node_at(
|
||||
&server->scene->tree.node, lx, ly, sx, sy);
|
||||
if (node == NULL || node->type != WLR_SCENE_NODE_BUFFER) {
|
||||
if (node == NULL || node->type != WLR_SCENE_NODE_RASTER) {
|
||||
return NULL;
|
||||
}
|
||||
struct wlr_scene_buffer *scene_buffer = wlr_scene_buffer_from_node(node);
|
||||
struct wlr_scene_raster *scene_raster = wlr_scene_raster_from_node(node);
|
||||
struct wlr_scene_surface *scene_surface =
|
||||
wlr_scene_surface_from_buffer(scene_buffer);
|
||||
wlr_scene_surface_from_raster(scene_raster);
|
||||
if (!scene_surface) {
|
||||
return NULL;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -81,9 +81,9 @@ static void subsurface_tree_reconfigure(
|
|||
}
|
||||
|
||||
if (prev != NULL) {
|
||||
wlr_scene_node_place_above(&subsurface_tree->scene_surface->buffer->node, prev);
|
||||
wlr_scene_node_place_above(&subsurface_tree->scene_surface->raster->node, prev);
|
||||
}
|
||||
prev = &subsurface_tree->scene_surface->buffer->node;
|
||||
prev = &subsurface_tree->scene_surface->raster->node;
|
||||
|
||||
wl_list_for_each(subsurface, &surface->current.subsurfaces_above,
|
||||
current.link) {
|
||||
|
|
|
|||
|
|
@ -3,7 +3,7 @@
|
|||
#include <wlr/types/wlr_presentation_time.h>
|
||||
#include "types/wlr_scene.h"
|
||||
|
||||
static void handle_scene_buffer_output_enter(
|
||||
static void handle_scene_raster_output_enter(
|
||||
struct wl_listener *listener, void *data) {
|
||||
struct wlr_scene_surface *surface =
|
||||
wl_container_of(listener, surface, output_enter);
|
||||
|
|
@ -12,7 +12,7 @@ static void handle_scene_buffer_output_enter(
|
|||
wlr_surface_send_enter(surface->surface, output->output);
|
||||
}
|
||||
|
||||
static void handle_scene_buffer_output_leave(
|
||||
static void handle_scene_raster_output_leave(
|
||||
struct wl_listener *listener, void *data) {
|
||||
struct wlr_scene_surface *surface =
|
||||
wl_container_of(listener, surface, output_leave);
|
||||
|
|
@ -21,14 +21,14 @@ static void handle_scene_buffer_output_leave(
|
|||
wlr_surface_send_leave(surface->surface, output->output);
|
||||
}
|
||||
|
||||
static void handle_scene_buffer_output_present(
|
||||
static void handle_scene_raster_output_present(
|
||||
struct wl_listener *listener, void *data) {
|
||||
struct wlr_scene_surface *surface =
|
||||
wl_container_of(listener, surface, output_present);
|
||||
struct wlr_scene_output *scene_output = data;
|
||||
|
||||
if (surface->buffer->primary_output == scene_output) {
|
||||
struct wlr_scene *root = scene_node_get_root(&surface->buffer->node);
|
||||
if (surface->raster->primary_output == scene_output) {
|
||||
struct wlr_scene *root = scene_node_get_root(&surface->raster->node);
|
||||
struct wlr_presentation *presentation = root->presentation;
|
||||
|
||||
if (presentation) {
|
||||
|
|
@ -38,7 +38,7 @@ static void handle_scene_buffer_output_present(
|
|||
}
|
||||
}
|
||||
|
||||
static void handle_scene_buffer_frame_done(
|
||||
static void handle_scene_raster_frame_done(
|
||||
struct wl_listener *listener, void *data) {
|
||||
struct wlr_scene_surface *surface =
|
||||
wl_container_of(listener, surface, frame_done);
|
||||
|
|
@ -52,53 +52,60 @@ static void scene_surface_handle_surface_destroy(
|
|||
struct wlr_scene_surface *surface =
|
||||
wl_container_of(listener, surface, surface_destroy);
|
||||
|
||||
wlr_scene_node_destroy(&surface->buffer->node);
|
||||
wlr_scene_node_destroy(&surface->raster->node);
|
||||
}
|
||||
|
||||
static void set_buffer_with_surface_state(struct wlr_scene_buffer *scene_buffer,
|
||||
static void set_raster_with_surface_state(struct wlr_scene_raster *scene_raster,
|
||||
struct wlr_surface *surface) {
|
||||
struct wlr_surface_state *state = &surface->current;
|
||||
|
||||
struct wlr_fbox src_box;
|
||||
wlr_surface_get_buffer_source_box(surface, &src_box);
|
||||
wlr_scene_buffer_set_source_box(scene_buffer, &src_box);
|
||||
wlr_scene_raster_set_source_box(scene_raster, &src_box);
|
||||
|
||||
wlr_scene_buffer_set_dest_size(scene_buffer, state->width, state->height);
|
||||
wlr_scene_buffer_set_transform(scene_buffer, state->transform);
|
||||
wlr_scene_raster_set_dest_size(scene_raster, state->width, state->height);
|
||||
wlr_scene_raster_set_transform(scene_raster, state->transform);
|
||||
|
||||
struct wlr_raster *raster = NULL;
|
||||
if (surface->current.buffer) {
|
||||
wlr_scene_buffer_set_buffer_with_damage(scene_buffer,
|
||||
surface->current.buffer, &surface->buffer_damage);
|
||||
} else {
|
||||
wlr_scene_buffer_set_buffer(scene_buffer, NULL);
|
||||
raster = wlr_raster_create(surface->current.buffer);
|
||||
}
|
||||
|
||||
if (raster) {
|
||||
wlr_scene_raster_set_raster_with_damage(scene_raster,
|
||||
raster, &surface->buffer_damage);
|
||||
} else {
|
||||
wlr_scene_raster_set_raster(scene_raster, NULL);
|
||||
}
|
||||
|
||||
wlr_raster_unlock(raster);
|
||||
}
|
||||
|
||||
static void handle_scene_surface_surface_commit(
|
||||
struct wl_listener *listener, void *data) {
|
||||
struct wlr_scene_surface *surface =
|
||||
wl_container_of(listener, surface, surface_commit);
|
||||
struct wlr_scene_buffer *scene_buffer = surface->buffer;
|
||||
struct wlr_scene_raster *scene_raster = surface->raster;
|
||||
|
||||
set_buffer_with_surface_state(scene_buffer, surface->surface);
|
||||
set_raster_with_surface_state(scene_raster, surface->surface);
|
||||
|
||||
// Even if the surface hasn't submitted damage, schedule a new frame if
|
||||
// the client has requested a wl_surface.frame callback. Check if the node
|
||||
// is visible. If not, the client will never receive a frame_done event
|
||||
// anyway so it doesn't make sense to schedule here.
|
||||
int lx, ly;
|
||||
bool enabled = wlr_scene_node_coords(&scene_buffer->node, &lx, &ly);
|
||||
bool enabled = wlr_scene_node_coords(&scene_raster->node, &lx, &ly);
|
||||
|
||||
if (!wl_list_empty(&surface->surface->current.frame_callback_list) &&
|
||||
surface->buffer->primary_output != NULL && enabled) {
|
||||
wlr_output_schedule_frame(surface->buffer->primary_output->output);
|
||||
surface->raster->primary_output != NULL && enabled) {
|
||||
wlr_output_schedule_frame(surface->raster->primary_output->output);
|
||||
}
|
||||
}
|
||||
|
||||
static bool scene_buffer_point_accepts_input(struct wlr_scene_buffer *scene_buffer,
|
||||
static bool scene_raster_point_accepts_input(struct wlr_scene_raster *scene_raster,
|
||||
int sx, int sy) {
|
||||
struct wlr_scene_surface *scene_surface =
|
||||
wlr_scene_surface_from_buffer(scene_buffer);
|
||||
wlr_scene_surface_from_raster(scene_raster);
|
||||
|
||||
return wlr_surface_point_accepts_input(scene_surface->surface, sx, sy);
|
||||
}
|
||||
|
|
@ -123,10 +130,10 @@ static const struct wlr_addon_interface surface_addon_impl = {
|
|||
.destroy = surface_addon_destroy,
|
||||
};
|
||||
|
||||
struct wlr_scene_surface *wlr_scene_surface_from_buffer(
|
||||
struct wlr_scene_buffer *scene_buffer) {
|
||||
struct wlr_addon *addon = wlr_addon_find(&scene_buffer->node.addons,
|
||||
scene_buffer, &surface_addon_impl);
|
||||
struct wlr_scene_surface *wlr_scene_surface_from_raster(
|
||||
struct wlr_scene_raster *scene_raster) {
|
||||
struct wlr_addon *addon = wlr_addon_find(&scene_raster->node.addons,
|
||||
scene_raster, &surface_addon_impl);
|
||||
if (!addon) {
|
||||
return NULL;
|
||||
}
|
||||
|
|
@ -142,27 +149,27 @@ struct wlr_scene_surface *wlr_scene_surface_create(struct wlr_scene_tree *parent
|
|||
return NULL;
|
||||
}
|
||||
|
||||
struct wlr_scene_buffer *scene_buffer = wlr_scene_buffer_create(parent, NULL);
|
||||
if (!scene_buffer) {
|
||||
struct wlr_scene_raster *scene_raster = wlr_scene_raster_create(parent, NULL);
|
||||
if (!scene_raster) {
|
||||
free(surface);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
surface->buffer = scene_buffer;
|
||||
surface->raster = scene_raster;
|
||||
surface->surface = wlr_surface;
|
||||
scene_buffer->point_accepts_input = scene_buffer_point_accepts_input;
|
||||
scene_raster->point_accepts_input = scene_raster_point_accepts_input;
|
||||
|
||||
surface->output_enter.notify = handle_scene_buffer_output_enter;
|
||||
wl_signal_add(&scene_buffer->events.output_enter, &surface->output_enter);
|
||||
surface->output_enter.notify = handle_scene_raster_output_enter;
|
||||
wl_signal_add(&scene_raster->events.output_enter, &surface->output_enter);
|
||||
|
||||
surface->output_leave.notify = handle_scene_buffer_output_leave;
|
||||
wl_signal_add(&scene_buffer->events.output_leave, &surface->output_leave);
|
||||
surface->output_leave.notify = handle_scene_raster_output_leave;
|
||||
wl_signal_add(&scene_raster->events.output_leave, &surface->output_leave);
|
||||
|
||||
surface->output_present.notify = handle_scene_buffer_output_present;
|
||||
wl_signal_add(&scene_buffer->events.output_present, &surface->output_present);
|
||||
surface->output_present.notify = handle_scene_raster_output_present;
|
||||
wl_signal_add(&scene_raster->events.output_present, &surface->output_present);
|
||||
|
||||
surface->frame_done.notify = handle_scene_buffer_frame_done;
|
||||
wl_signal_add(&scene_buffer->events.frame_done, &surface->frame_done);
|
||||
surface->frame_done.notify = handle_scene_raster_frame_done;
|
||||
wl_signal_add(&scene_raster->events.frame_done, &surface->frame_done);
|
||||
|
||||
surface->surface_destroy.notify = scene_surface_handle_surface_destroy;
|
||||
wl_signal_add(&wlr_surface->events.destroy, &surface->surface_destroy);
|
||||
|
|
@ -170,10 +177,10 @@ struct wlr_scene_surface *wlr_scene_surface_create(struct wlr_scene_tree *parent
|
|||
surface->surface_commit.notify = handle_scene_surface_surface_commit;
|
||||
wl_signal_add(&wlr_surface->events.commit, &surface->surface_commit);
|
||||
|
||||
wlr_addon_init(&surface->addon, &scene_buffer->node.addons,
|
||||
scene_buffer, &surface_addon_impl);
|
||||
wlr_addon_init(&surface->addon, &scene_raster->node.addons,
|
||||
scene_raster, &surface_addon_impl);
|
||||
|
||||
set_buffer_with_surface_state(scene_buffer, wlr_surface);
|
||||
set_raster_with_surface_state(scene_raster, wlr_surface);
|
||||
|
||||
return surface;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -28,10 +28,10 @@ static struct wlr_scene_rect *scene_rect_from_node(
|
|||
return (struct wlr_scene_rect *)node;
|
||||
}
|
||||
|
||||
struct wlr_scene_buffer *wlr_scene_buffer_from_node(
|
||||
struct wlr_scene_raster *wlr_scene_raster_from_node(
|
||||
struct wlr_scene_node *node) {
|
||||
assert(node->type == WLR_SCENE_NODE_BUFFER);
|
||||
return (struct wlr_scene_buffer *)node;
|
||||
assert(node->type == WLR_SCENE_NODE_RASTER);
|
||||
return (struct wlr_scene_raster *)node;
|
||||
}
|
||||
|
||||
struct wlr_scene *scene_node_get_root(struct wlr_scene_node *node) {
|
||||
|
|
@ -87,22 +87,21 @@ void wlr_scene_node_destroy(struct wlr_scene_node *node) {
|
|||
wlr_signal_emit_safe(&node->events.destroy, NULL);
|
||||
|
||||
struct wlr_scene *scene = scene_node_get_root(node);
|
||||
if (node->type == WLR_SCENE_NODE_BUFFER) {
|
||||
struct wlr_scene_buffer *scene_buffer = wlr_scene_buffer_from_node(node);
|
||||
if (node->type == WLR_SCENE_NODE_RASTER) {
|
||||
struct wlr_scene_raster *scene_raster = wlr_scene_raster_from_node(node);
|
||||
|
||||
uint64_t active = scene_buffer->active_outputs;
|
||||
uint64_t active = scene_raster->active_outputs;
|
||||
if (active) {
|
||||
struct wlr_scene_output *scene_output;
|
||||
wl_list_for_each(scene_output, &scene->outputs, link) {
|
||||
if (active & (1ull << scene_output->index)) {
|
||||
wlr_signal_emit_safe(&scene_buffer->events.output_leave,
|
||||
wlr_signal_emit_safe(&scene_raster->events.output_leave,
|
||||
scene_output);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
wlr_raster_unlock(scene_buffer->raster);
|
||||
wlr_buffer_unlock(scene_buffer->buffer);
|
||||
wlr_raster_unlock(scene_raster->raster);
|
||||
} else if (node->type == WLR_SCENE_NODE_TREE) {
|
||||
struct wlr_scene_tree *scene_tree = scene_tree_from_node(node);
|
||||
|
||||
|
|
@ -182,16 +181,16 @@ struct wlr_scene_tree *wlr_scene_tree_create(struct wlr_scene_tree *parent) {
|
|||
static void scene_node_get_size(struct wlr_scene_node *node, int *lx, int *ly);
|
||||
|
||||
// This function must be called whenever the coordinates/dimensions of a scene
|
||||
// buffer or scene output change. It is not necessary to call when a scene
|
||||
// buffer's node is enabled/disabled or obscured by other nodes.
|
||||
static void scene_buffer_update_outputs(struct wlr_scene_buffer *scene_buffer,
|
||||
// raster or scene output change. It is not necessary to call when a scene
|
||||
// raster's node is enabled/disabled or obscured by other nodes.
|
||||
static void scene_raster_update_outputs(struct wlr_scene_raster *scene_raster,
|
||||
int lx, int ly, struct wlr_scene *scene,
|
||||
struct wlr_scene_output *ignore) {
|
||||
struct wlr_box buffer_box = { .x = lx, .y = ly };
|
||||
scene_node_get_size(&scene_buffer->node, &buffer_box.width, &buffer_box.height);
|
||||
struct wlr_box raster_box = { .x = lx, .y = ly };
|
||||
scene_node_get_size(&scene_raster->node, &raster_box.width, &raster_box.height);
|
||||
|
||||
int largest_overlap = 0;
|
||||
scene_buffer->primary_output = NULL;
|
||||
scene_raster->primary_output = NULL;
|
||||
|
||||
uint64_t active_outputs = 0;
|
||||
|
||||
|
|
@ -215,21 +214,21 @@ static void scene_buffer_update_outputs(struct wlr_scene_buffer *scene_buffer,
|
|||
&output_box.width, &output_box.height);
|
||||
|
||||
struct wlr_box intersection;
|
||||
bool intersects = wlr_box_intersection(&intersection, &buffer_box, &output_box);
|
||||
bool intersects = wlr_box_intersection(&intersection, &raster_box, &output_box);
|
||||
|
||||
if (intersects) {
|
||||
int overlap = intersection.width * intersection.height;
|
||||
if (overlap > largest_overlap) {
|
||||
largest_overlap = overlap;
|
||||
scene_buffer->primary_output = scene_output;
|
||||
scene_raster->primary_output = scene_output;
|
||||
}
|
||||
|
||||
active_outputs |= 1ull << scene_output->index;
|
||||
}
|
||||
}
|
||||
|
||||
uint64_t old_active = scene_buffer->active_outputs;
|
||||
scene_buffer->active_outputs = active_outputs;
|
||||
uint64_t old_active = scene_raster->active_outputs;
|
||||
scene_raster->active_outputs = active_outputs;
|
||||
|
||||
wl_list_for_each(scene_output, &scene->outputs, link) {
|
||||
uint64_t mask = 1ull << scene_output->index;
|
||||
|
|
@ -237,9 +236,9 @@ static void scene_buffer_update_outputs(struct wlr_scene_buffer *scene_buffer,
|
|||
bool intersects_before = old_active & mask;
|
||||
|
||||
if (intersects && !intersects_before) {
|
||||
wlr_signal_emit_safe(&scene_buffer->events.output_enter, scene_output);
|
||||
wlr_signal_emit_safe(&scene_raster->events.output_enter, scene_output);
|
||||
} else if (!intersects && intersects_before) {
|
||||
wlr_signal_emit_safe(&scene_buffer->events.output_leave, scene_output);
|
||||
wlr_signal_emit_safe(&scene_raster->events.output_leave, scene_output);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -247,10 +246,10 @@ static void scene_buffer_update_outputs(struct wlr_scene_buffer *scene_buffer,
|
|||
static void _scene_node_update_outputs(struct wlr_scene_node *node,
|
||||
int lx, int ly, struct wlr_scene *scene,
|
||||
struct wlr_scene_output *ignore) {
|
||||
if (node->type == WLR_SCENE_NODE_BUFFER) {
|
||||
struct wlr_scene_buffer *scene_buffer =
|
||||
wlr_scene_buffer_from_node(node);
|
||||
scene_buffer_update_outputs(scene_buffer, lx, ly, scene, ignore);
|
||||
if (node->type == WLR_SCENE_NODE_RASTER) {
|
||||
struct wlr_scene_raster *scene_raster =
|
||||
wlr_scene_raster_from_node(node);
|
||||
scene_raster_update_outputs(scene_raster, lx, ly, scene, ignore);
|
||||
} else if (node->type == WLR_SCENE_NODE_TREE) {
|
||||
struct wlr_scene_tree *scene_tree = scene_tree_from_node(node);
|
||||
struct wlr_scene_node *child;
|
||||
|
|
@ -308,57 +307,54 @@ void wlr_scene_rect_set_color(struct wlr_scene_rect *rect, const float color[sta
|
|||
scene_node_damage_whole(&rect->node);
|
||||
}
|
||||
|
||||
struct wlr_scene_buffer *wlr_scene_buffer_create(struct wlr_scene_tree *parent,
|
||||
struct wlr_buffer *buffer) {
|
||||
struct wlr_scene_buffer *scene_buffer = calloc(1, sizeof(*scene_buffer));
|
||||
if (scene_buffer == NULL) {
|
||||
struct wlr_scene_raster *wlr_scene_raster_create(struct wlr_scene_tree *parent,
|
||||
struct wlr_raster *raster) {
|
||||
struct wlr_scene_raster *scene_raster = calloc(1, sizeof(*scene_raster));
|
||||
if (scene_raster == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
assert(parent);
|
||||
scene_node_init(&scene_buffer->node, WLR_SCENE_NODE_BUFFER, parent);
|
||||
scene_node_init(&scene_raster->node, WLR_SCENE_NODE_RASTER, parent);
|
||||
|
||||
if (buffer) {
|
||||
scene_buffer->buffer = wlr_buffer_lock(buffer);
|
||||
if (raster) {
|
||||
scene_raster->raster = wlr_raster_lock(raster);
|
||||
}
|
||||
|
||||
wl_signal_init(&scene_buffer->events.output_enter);
|
||||
wl_signal_init(&scene_buffer->events.output_leave);
|
||||
wl_signal_init(&scene_buffer->events.output_present);
|
||||
wl_signal_init(&scene_buffer->events.frame_done);
|
||||
wl_signal_init(&scene_raster->events.output_enter);
|
||||
wl_signal_init(&scene_raster->events.output_leave);
|
||||
wl_signal_init(&scene_raster->events.output_present);
|
||||
wl_signal_init(&scene_raster->events.frame_done);
|
||||
|
||||
scene_node_damage_whole(&scene_buffer->node);
|
||||
scene_node_damage_whole(&scene_raster->node);
|
||||
|
||||
scene_node_update_outputs(&scene_buffer->node, NULL);
|
||||
scene_node_update_outputs(&scene_raster->node, NULL);
|
||||
|
||||
return scene_buffer;
|
||||
return scene_raster;
|
||||
}
|
||||
|
||||
void wlr_scene_buffer_set_buffer_with_damage(struct wlr_scene_buffer *scene_buffer,
|
||||
struct wlr_buffer *buffer, pixman_region32_t *damage) {
|
||||
// specifying a region for a NULL buffer doesn't make sense. We need to know
|
||||
// about the buffer to scale the buffer local coordinates down to scene
|
||||
void wlr_scene_raster_set_raster_with_damage(struct wlr_scene_raster *scene_raster,
|
||||
struct wlr_raster *raster, pixman_region32_t *damage) {
|
||||
// specifying a region for a NULL raster doesn't make sense. We need to know
|
||||
// about the raster to scale the raster local coordinates down to scene
|
||||
// coordinates.
|
||||
assert(buffer || !damage);
|
||||
assert(raster || !damage);
|
||||
|
||||
if (buffer != scene_buffer->buffer) {
|
||||
if (raster != scene_raster->raster) {
|
||||
if (!damage) {
|
||||
scene_node_damage_whole(&scene_buffer->node);
|
||||
scene_node_damage_whole(&scene_raster->node);
|
||||
}
|
||||
|
||||
wlr_raster_unlock(scene_buffer->raster);
|
||||
scene_buffer->raster = NULL;
|
||||
wlr_buffer_unlock(scene_buffer->buffer);
|
||||
wlr_raster_unlock(scene_raster->raster);
|
||||
scene_raster->raster = NULL;
|
||||
|
||||
if (buffer) {
|
||||
scene_buffer->buffer = wlr_buffer_lock(buffer);
|
||||
} else {
|
||||
scene_buffer->buffer = NULL;
|
||||
if (raster) {
|
||||
scene_raster->raster = wlr_raster_lock(raster);
|
||||
}
|
||||
|
||||
scene_node_update_outputs(&scene_buffer->node, NULL);
|
||||
scene_node_update_outputs(&scene_raster->node, NULL);
|
||||
|
||||
if (!damage) {
|
||||
scene_node_damage_whole(&scene_buffer->node);
|
||||
scene_node_damage_whole(&scene_raster->node);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -367,41 +363,41 @@ void wlr_scene_buffer_set_buffer_with_damage(struct wlr_scene_buffer *scene_buff
|
|||
}
|
||||
|
||||
int lx, ly;
|
||||
if (!wlr_scene_node_coords(&scene_buffer->node, &lx, &ly)) {
|
||||
if (!wlr_scene_node_coords(&scene_raster->node, &lx, &ly)) {
|
||||
return;
|
||||
}
|
||||
|
||||
struct wlr_fbox box = scene_buffer->src_box;
|
||||
struct wlr_fbox box = scene_raster->src_box;
|
||||
if (wlr_fbox_empty(&box)) {
|
||||
box.x = 0;
|
||||
box.y = 0;
|
||||
|
||||
if (scene_buffer->transform & WL_OUTPUT_TRANSFORM_90) {
|
||||
box.width = buffer->height;
|
||||
box.height = buffer->width;
|
||||
if (scene_raster->transform & WL_OUTPUT_TRANSFORM_90) {
|
||||
box.width = raster->height;
|
||||
box.height = raster->width;
|
||||
} else {
|
||||
box.width = buffer->width;
|
||||
box.height = buffer->height;
|
||||
box.width = raster->width;
|
||||
box.height = raster->height;
|
||||
}
|
||||
}
|
||||
|
||||
double scale_x, scale_y;
|
||||
if (scene_buffer->dst_width || scene_buffer->dst_height) {
|
||||
scale_x = scene_buffer->dst_width / box.width;
|
||||
scale_y = scene_buffer->dst_height / box.height;
|
||||
if (scene_raster->dst_width || scene_raster->dst_height) {
|
||||
scale_x = scene_raster->dst_width / box.width;
|
||||
scale_y = scene_raster->dst_height / box.height;
|
||||
} else {
|
||||
scale_x = buffer->width / box.width;
|
||||
scale_y = buffer->height / box.height;
|
||||
scale_x = raster->width / box.width;
|
||||
scale_y = raster->height / box.height;
|
||||
}
|
||||
|
||||
pixman_region32_t trans_damage;
|
||||
pixman_region32_init(&trans_damage);
|
||||
wlr_region_transform(&trans_damage, damage,
|
||||
scene_buffer->transform, buffer->width, buffer->height);
|
||||
scene_raster->transform, raster->width, raster->height);
|
||||
pixman_region32_intersect_rect(&trans_damage, &trans_damage,
|
||||
box.x, box.y, box.width, box.height);
|
||||
|
||||
struct wlr_scene *scene = scene_node_get_root(&scene_buffer->node);
|
||||
struct wlr_scene *scene = scene_node_get_root(&scene_raster->node);
|
||||
struct wlr_scene_output *scene_output;
|
||||
wl_list_for_each(scene_output, &scene->outputs, link) {
|
||||
float output_scale = scene_output->output->scale;
|
||||
|
|
@ -421,14 +417,14 @@ void wlr_scene_buffer_set_buffer_with_damage(struct wlr_scene_buffer *scene_buff
|
|||
pixman_region32_fini(&trans_damage);
|
||||
}
|
||||
|
||||
void wlr_scene_buffer_set_buffer(struct wlr_scene_buffer *scene_buffer,
|
||||
struct wlr_buffer *buffer) {
|
||||
wlr_scene_buffer_set_buffer_with_damage(scene_buffer, buffer, NULL);
|
||||
void wlr_scene_raster_set_raster(struct wlr_scene_raster *scene_raster,
|
||||
struct wlr_raster *raster) {
|
||||
wlr_scene_raster_set_raster_with_damage(scene_raster, raster, NULL);
|
||||
}
|
||||
|
||||
void wlr_scene_buffer_set_source_box(struct wlr_scene_buffer *scene_buffer,
|
||||
void wlr_scene_raster_set_source_box(struct wlr_scene_raster *scene_raster,
|
||||
const struct wlr_fbox *box) {
|
||||
struct wlr_fbox *cur = &scene_buffer->src_box;
|
||||
struct wlr_fbox *cur = &scene_raster->src_box;
|
||||
if ((wlr_fbox_empty(box) && wlr_fbox_empty(cur)) ||
|
||||
(box != NULL && memcmp(cur, box, sizeof(*box)) == 0)) {
|
||||
return;
|
||||
|
|
@ -440,39 +436,39 @@ void wlr_scene_buffer_set_source_box(struct wlr_scene_buffer *scene_buffer,
|
|||
memset(cur, 0, sizeof(*cur));
|
||||
}
|
||||
|
||||
scene_node_damage_whole(&scene_buffer->node);
|
||||
scene_node_damage_whole(&scene_raster->node);
|
||||
}
|
||||
|
||||
void wlr_scene_buffer_set_dest_size(struct wlr_scene_buffer *scene_buffer,
|
||||
void wlr_scene_raster_set_dest_size(struct wlr_scene_raster *scene_raster,
|
||||
int width, int height) {
|
||||
if (scene_buffer->dst_width == width && scene_buffer->dst_height == height) {
|
||||
if (scene_raster->dst_width == width && scene_raster->dst_height == height) {
|
||||
return;
|
||||
}
|
||||
|
||||
scene_node_damage_whole(&scene_buffer->node);
|
||||
scene_buffer->dst_width = width;
|
||||
scene_buffer->dst_height = height;
|
||||
scene_node_damage_whole(&scene_buffer->node);
|
||||
scene_node_damage_whole(&scene_raster->node);
|
||||
scene_raster->dst_width = width;
|
||||
scene_raster->dst_height = height;
|
||||
scene_node_damage_whole(&scene_raster->node);
|
||||
|
||||
scene_node_update_outputs(&scene_buffer->node, NULL);
|
||||
scene_node_update_outputs(&scene_raster->node, NULL);
|
||||
}
|
||||
|
||||
void wlr_scene_buffer_set_transform(struct wlr_scene_buffer *scene_buffer,
|
||||
void wlr_scene_raster_set_transform(struct wlr_scene_raster *scene_raster,
|
||||
enum wl_output_transform transform) {
|
||||
if (scene_buffer->transform == transform) {
|
||||
if (scene_raster->transform == transform) {
|
||||
return;
|
||||
}
|
||||
|
||||
scene_node_damage_whole(&scene_buffer->node);
|
||||
scene_buffer->transform = transform;
|
||||
scene_node_damage_whole(&scene_buffer->node);
|
||||
scene_node_damage_whole(&scene_raster->node);
|
||||
scene_raster->transform = transform;
|
||||
scene_node_damage_whole(&scene_raster->node);
|
||||
|
||||
scene_node_update_outputs(&scene_buffer->node, NULL);
|
||||
scene_node_update_outputs(&scene_raster->node, NULL);
|
||||
}
|
||||
|
||||
void wlr_scene_buffer_send_frame_done(struct wlr_scene_buffer *scene_buffer,
|
||||
void wlr_scene_raster_send_frame_done(struct wlr_scene_raster *scene_raster,
|
||||
struct timespec *now) {
|
||||
wlr_signal_emit_safe(&scene_buffer->events.frame_done, now);
|
||||
wlr_signal_emit_safe(&scene_raster->events.frame_done, now);
|
||||
}
|
||||
|
||||
static void scene_node_get_size(struct wlr_scene_node *node,
|
||||
|
|
@ -488,18 +484,18 @@ static void scene_node_get_size(struct wlr_scene_node *node,
|
|||
*width = scene_rect->width;
|
||||
*height = scene_rect->height;
|
||||
break;
|
||||
case WLR_SCENE_NODE_BUFFER:;
|
||||
struct wlr_scene_buffer *scene_buffer = wlr_scene_buffer_from_node(node);
|
||||
if (scene_buffer->dst_width > 0 && scene_buffer->dst_height > 0) {
|
||||
*width = scene_buffer->dst_width;
|
||||
*height = scene_buffer->dst_height;
|
||||
} else if (scene_buffer->buffer) {
|
||||
if (scene_buffer->transform & WL_OUTPUT_TRANSFORM_90) {
|
||||
*height = scene_buffer->buffer->width;
|
||||
*width = scene_buffer->buffer->height;
|
||||
case WLR_SCENE_NODE_RASTER:;
|
||||
struct wlr_scene_raster *scene_raster = wlr_scene_raster_from_node(node);
|
||||
if (scene_raster->dst_width > 0 && scene_raster->dst_height > 0) {
|
||||
*width = scene_raster->dst_width;
|
||||
*height = scene_raster->dst_height;
|
||||
} else if (scene_raster->raster) {
|
||||
if (scene_raster->transform & WL_OUTPUT_TRANSFORM_90) {
|
||||
*height = scene_raster->raster->width;
|
||||
*width = scene_raster->raster->height;
|
||||
} else {
|
||||
*width = scene_buffer->buffer->width;
|
||||
*height = scene_buffer->buffer->height;
|
||||
*width = scene_raster->raster->width;
|
||||
*height = scene_raster->raster->height;
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
|
@ -687,8 +683,8 @@ bool wlr_scene_node_coords(struct wlr_scene_node *node,
|
|||
return enabled;
|
||||
}
|
||||
|
||||
static void scene_node_for_each_scene_buffer(struct wlr_scene_node *node,
|
||||
int lx, int ly, wlr_scene_buffer_iterator_func_t user_iterator,
|
||||
static void scene_node_for_each_scene_raster(struct wlr_scene_node *node,
|
||||
int lx, int ly, wlr_scene_raster_iterator_func_t user_iterator,
|
||||
void *user_data) {
|
||||
if (!node->enabled) {
|
||||
return;
|
||||
|
|
@ -697,21 +693,21 @@ static void scene_node_for_each_scene_buffer(struct wlr_scene_node *node,
|
|||
lx += node->x;
|
||||
ly += node->y;
|
||||
|
||||
if (node->type == WLR_SCENE_NODE_BUFFER) {
|
||||
struct wlr_scene_buffer *scene_buffer = wlr_scene_buffer_from_node(node);
|
||||
user_iterator(scene_buffer, lx, ly, user_data);
|
||||
if (node->type == WLR_SCENE_NODE_RASTER) {
|
||||
struct wlr_scene_raster *scene_raster = wlr_scene_raster_from_node(node);
|
||||
user_iterator(scene_raster, lx, ly, user_data);
|
||||
} else if (node->type == WLR_SCENE_NODE_TREE) {
|
||||
struct wlr_scene_tree *scene_tree = scene_tree_from_node(node);
|
||||
struct wlr_scene_node *child;
|
||||
wl_list_for_each(child, &scene_tree->children, link) {
|
||||
scene_node_for_each_scene_buffer(child, lx, ly, user_iterator, user_data);
|
||||
scene_node_for_each_scene_raster(child, lx, ly, user_iterator, user_data);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void wlr_scene_node_for_each_buffer(struct wlr_scene_node *node,
|
||||
wlr_scene_buffer_iterator_func_t user_iterator, void *user_data) {
|
||||
scene_node_for_each_scene_buffer(node, 0, 0, user_iterator, user_data);
|
||||
void wlr_scene_node_for_each_raster(struct wlr_scene_node *node,
|
||||
wlr_scene_raster_iterator_func_t user_iterator, void *user_data) {
|
||||
scene_node_for_each_scene_raster(node, 0, 0, user_iterator, user_data);
|
||||
}
|
||||
|
||||
struct wlr_scene_node *wlr_scene_node_at(struct wlr_scene_node *node,
|
||||
|
|
@ -742,11 +738,11 @@ struct wlr_scene_node *wlr_scene_node_at(struct wlr_scene_node *node,
|
|||
scene_node_get_size(node, &width, &height);
|
||||
intersects = lx >= 0 && lx < width && ly >= 0 && ly < height;
|
||||
break;
|
||||
case WLR_SCENE_NODE_BUFFER:;
|
||||
struct wlr_scene_buffer *scene_buffer = wlr_scene_buffer_from_node(node);
|
||||
case WLR_SCENE_NODE_RASTER:;
|
||||
struct wlr_scene_raster *scene_raster = wlr_scene_raster_from_node(node);
|
||||
|
||||
if (scene_buffer->point_accepts_input) {
|
||||
intersects = scene_buffer->point_accepts_input(scene_buffer, lx, ly);
|
||||
if (scene_raster->point_accepts_input) {
|
||||
intersects = scene_raster->point_accepts_input(scene_raster, lx, ly);
|
||||
} else {
|
||||
int width, height;
|
||||
scene_node_get_size(node, &width, &height);
|
||||
|
|
@ -871,24 +867,20 @@ static void render_node_iterator(struct wlr_scene_node *node,
|
|||
render_rect(output, output_damage, scene_rect->color, &dst_box,
|
||||
output->transform_matrix);
|
||||
break;
|
||||
case WLR_SCENE_NODE_BUFFER:;
|
||||
struct wlr_scene_buffer *scene_buffer = wlr_scene_buffer_from_node(node);
|
||||
if (!scene_buffer->buffer) {
|
||||
case WLR_SCENE_NODE_RASTER:;
|
||||
struct wlr_scene_raster *scene_raster = wlr_scene_raster_from_node(node);
|
||||
if (!scene_raster->raster) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (!scene_buffer->raster) {
|
||||
scene_buffer->raster = wlr_raster_create(scene_buffer->buffer);
|
||||
}
|
||||
|
||||
transform = wlr_output_transform_invert(scene_buffer->transform);
|
||||
transform = wlr_output_transform_invert(scene_raster->transform);
|
||||
wlr_matrix_project_box(matrix, &dst_box, transform, 0.0,
|
||||
output->transform_matrix);
|
||||
|
||||
render_raster(output, output_damage, scene_buffer->raster,
|
||||
&scene_buffer->src_box, &dst_box, matrix);
|
||||
render_raster(output, output_damage, scene_raster->raster,
|
||||
&scene_raster->src_box, &dst_box, matrix);
|
||||
|
||||
wlr_signal_emit_safe(&scene_buffer->events.output_present, scene_output);
|
||||
wlr_signal_emit_safe(&scene_raster->events.output_present, scene_output);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
|
@ -1143,31 +1135,35 @@ static bool scene_output_scanout(struct wlr_scene_output *scene_output) {
|
|||
}
|
||||
|
||||
struct wlr_scene_node *node = check_scanout_data.node;
|
||||
struct wlr_buffer *buffer;
|
||||
struct wlr_raster *raster;
|
||||
switch (node->type) {
|
||||
case WLR_SCENE_NODE_BUFFER:;
|
||||
struct wlr_scene_buffer *scene_buffer = wlr_scene_buffer_from_node(node);
|
||||
if (scene_buffer->buffer == NULL ||
|
||||
!wlr_fbox_empty(&scene_buffer->src_box) ||
|
||||
scene_buffer->transform != output->transform) {
|
||||
case WLR_SCENE_NODE_RASTER:;
|
||||
struct wlr_scene_raster *scene_raster = wlr_scene_raster_from_node(node);
|
||||
if (scene_raster->raster == NULL ||
|
||||
!wlr_fbox_empty(&scene_raster->src_box) ||
|
||||
scene_raster->transform != output->transform) {
|
||||
return false;
|
||||
}
|
||||
buffer = scene_buffer->buffer;
|
||||
raster = scene_raster->raster;
|
||||
break;
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
|
||||
wlr_output_attach_buffer(output, buffer);
|
||||
if (!raster->buffer) {
|
||||
return false;
|
||||
}
|
||||
|
||||
wlr_output_attach_buffer(output, raster->buffer);
|
||||
if (!wlr_output_test(output)) {
|
||||
wlr_output_rollback(output);
|
||||
return false;
|
||||
}
|
||||
|
||||
if (node->type == WLR_SCENE_NODE_BUFFER) {
|
||||
struct wlr_scene_buffer *scene_buffer =
|
||||
wlr_scene_buffer_from_node(node);
|
||||
wlr_signal_emit_safe(&scene_buffer->events.output_present, scene_output);
|
||||
if (node->type == WLR_SCENE_NODE_RASTER) {
|
||||
struct wlr_scene_raster *scene_raster =
|
||||
wlr_scene_raster_from_node(node);
|
||||
wlr_signal_emit_safe(&scene_raster->events.output_present, scene_output);
|
||||
}
|
||||
|
||||
return wlr_output_commit(output);
|
||||
|
|
@ -1333,12 +1329,12 @@ static void scene_node_send_frame_done(struct wlr_scene_node *node,
|
|||
return;
|
||||
}
|
||||
|
||||
if (node->type == WLR_SCENE_NODE_BUFFER) {
|
||||
struct wlr_scene_buffer *scene_buffer =
|
||||
wlr_scene_buffer_from_node(node);
|
||||
if (node->type == WLR_SCENE_NODE_RASTER) {
|
||||
struct wlr_scene_raster *scene_raster =
|
||||
wlr_scene_raster_from_node(node);
|
||||
|
||||
if (scene_buffer->primary_output == scene_output) {
|
||||
wlr_scene_buffer_send_frame_done(scene_buffer, now);
|
||||
if (scene_raster->primary_output == scene_output) {
|
||||
wlr_scene_raster_send_frame_done(scene_raster, now);
|
||||
}
|
||||
} else if (node->type == WLR_SCENE_NODE_TREE) {
|
||||
struct wlr_scene_tree *scene_tree = scene_tree_from_node(node);
|
||||
|
|
@ -1355,9 +1351,9 @@ void wlr_scene_output_send_frame_done(struct wlr_scene_output *scene_output,
|
|||
scene_output, now);
|
||||
}
|
||||
|
||||
static void scene_output_for_each_scene_buffer(const struct wlr_box *output_box,
|
||||
static void scene_output_for_each_scene_raster(const struct wlr_box *output_box,
|
||||
struct wlr_scene_node *node, int lx, int ly,
|
||||
wlr_scene_buffer_iterator_func_t user_iterator, void *user_data) {
|
||||
wlr_scene_raster_iterator_func_t user_iterator, void *user_data) {
|
||||
if (!node->enabled) {
|
||||
return;
|
||||
}
|
||||
|
|
@ -1365,31 +1361,31 @@ static void scene_output_for_each_scene_buffer(const struct wlr_box *output_box,
|
|||
lx += node->x;
|
||||
ly += node->y;
|
||||
|
||||
if (node->type == WLR_SCENE_NODE_BUFFER) {
|
||||
if (node->type == WLR_SCENE_NODE_RASTER) {
|
||||
struct wlr_box node_box = { .x = lx, .y = ly };
|
||||
scene_node_get_size(node, &node_box.width, &node_box.height);
|
||||
|
||||
struct wlr_box intersection;
|
||||
if (wlr_box_intersection(&intersection, output_box, &node_box)) {
|
||||
struct wlr_scene_buffer *scene_buffer =
|
||||
wlr_scene_buffer_from_node(node);
|
||||
user_iterator(scene_buffer, lx, ly, user_data);
|
||||
struct wlr_scene_raster *scene_raster =
|
||||
wlr_scene_raster_from_node(node);
|
||||
user_iterator(scene_raster, lx, ly, user_data);
|
||||
}
|
||||
} else if (node->type == WLR_SCENE_NODE_TREE) {
|
||||
struct wlr_scene_tree *scene_tree = scene_tree_from_node(node);
|
||||
struct wlr_scene_node *child;
|
||||
wl_list_for_each(child, &scene_tree->children, link) {
|
||||
scene_output_for_each_scene_buffer(output_box, child, lx, ly,
|
||||
scene_output_for_each_scene_raster(output_box, child, lx, ly,
|
||||
user_iterator, user_data);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void wlr_scene_output_for_each_buffer(struct wlr_scene_output *scene_output,
|
||||
wlr_scene_buffer_iterator_func_t iterator, void *user_data) {
|
||||
void wlr_scene_output_for_each_raster(struct wlr_scene_output *scene_output,
|
||||
wlr_scene_raster_iterator_func_t iterator, void *user_data) {
|
||||
struct wlr_box box = { .x = scene_output->x, .y = scene_output->y };
|
||||
wlr_output_effective_resolution(scene_output->output,
|
||||
&box.width, &box.height);
|
||||
scene_output_for_each_scene_buffer(&box, &scene_output->scene->tree.node, 0, 0,
|
||||
scene_output_for_each_scene_raster(&box, &scene_output->scene->tree.node, 0, 0,
|
||||
iterator, user_data);
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue