mirrors/wlroots
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/wlroots/wlroots.git synced 2025-11-03 09:01:40 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions

surface: move position and scale out of wlr_surface_state

Browse source
This commit is contained in:
emersion 2018-06-28 23:49:40 +01:00
parent 233bfe2f4f
commit 78555abba3
No known key found for this signature in database
GPG key ID: 0FDE7BE0E88F5E48
4 changed files with 120 additions and 90 deletions
Download patch file Download diff file Expand all files Collapse all files

17
include/wlr/types/wlr_surface.h
View file

@ -32,8 +32,6 @@ struct wlr_surface_state {
int width, height; // in surface-local coordinates int width, height; // in surface-local coordinates
int buffer_width, buffer_height; int buffer_width, buffer_height;
int sx, sy; // in surface-local coordinates
pixman_region32_t damage; // in buffer-local coordinates
struct wl_listener buffer_destroy_listener; struct wl_listener buffer_destroy_listener;
}; };
@ -48,6 +46,21 @@ struct wlr_surface {
* or something went wrong with uploading the buffer. * or something went wrong with uploading the buffer.
*/ */
struct wlr_buffer *buffer; struct wlr_buffer *buffer;
/**
* The buffer position, in surface-local units.
*/
int sx, sy;
/**
* The last commit's buffer damage, in buffer-local coordinates. This
* contains both the damage accumulated by the client via
* `wlr_surface_state.surface_damage` and `wlr_surface_state.buffer_damage`.
* If the buffer has changed its size or moved, the whole buffer is
* damaged.
*
* This region needs to be scaled and transformed into output coordinates,
* just like the buffer's texture.
*/
pixman_region32_t buffer_damage;
/** /**
* `current` contains the current, committed surface state. `pending` * `current` contains the current, committed surface state. `pending`
* accumulates state changes from the client between commits and shouldn't * accumulates state changes from the client between commits and shouldn't

11
rootston/output.c
View file

@ -146,8 +146,8 @@ static bool surface_intersect_output(struct wlr_surface *surface,
double ox = lx, oy = ly; double ox = lx, oy = ly;
wlr_output_layout_output_coords(output_layout, wlr_output, &ox, &oy); wlr_output_layout_output_coords(output_layout, wlr_output, &ox, &oy);
ox += surface->current.sx; ox += surface->sx;
oy += surface->current.sy; oy += surface->sy;
if (box != NULL) { if (box != NULL) {
box->x = ox * wlr_output->scale; box->x = ox * wlr_output->scale;
@ -695,9 +695,14 @@ static void damage_from_surface(struct wlr_surface *surface, int sx, int sy,
int center_x = box.x + box.width/2; int center_x = box.x + box.width/2;
int center_y = box.y + box.height/2; int center_y = box.y + box.height/2;
enum wl_output_transform transform =
wlr_output_transform_invert(surface->current.transform);
pixman_region32_t damage; pixman_region32_t damage;
pixman_region32_init(&damage); pixman_region32_init(&damage);
pixman_region32_copy(&damage, &surface->current.damage); pixman_region32_copy(&damage, &surface->buffer_damage);
wlr_region_transform(&damage, &damage, transform,
surface->current.buffer_width, surface->current.buffer_height);
wlr_region_scale(&damage, &damage, wlr_region_scale(&damage, &damage,
wlr_output->scale / (float)surface->current.scale); wlr_output->scale / (float)surface->current.scale);
if (ceil(wlr_output->scale) > surface->current.scale) { if (ceil(wlr_output->scale) > surface->current.scale) {

4
types/wlr_output.c
View file

@ -405,8 +405,8 @@ static void output_cursor_get_box(struct wlr_output_cursor *cursor,
box->height = cursor->height; box->height = cursor->height;
if (cursor->surface != NULL) { if (cursor->surface != NULL) {
box->x += cursor->surface->current.sx * cursor->output->scale; box->x += cursor->surface->sx * cursor->output->scale;
box->y += cursor->surface->current.sy * cursor->output->scale; box->y += cursor->surface->sy * cursor->output->scale;
} }
} }

178
types/wlr_surface.c
View file

@ -139,93 +139,83 @@ static void surface_set_input_region(struct wl_client *client,
} }
} }
static void surface_state_update_size(struct wlr_surface_state *state) { static void surface_state_finalize(struct wlr_surface *surface,
struct wlr_surface_state *state) {
if ((state->committed & WLR_SURFACE_STATE_BUFFER)) {
wlr_buffer_get_resource_size(state->buffer, surface->renderer,
&state->buffer_width, &state->buffer_height);
}
int width = state->buffer_width / state->scale; int width = state->buffer_width / state->scale;
int height = state->buffer_height / state->scale; int height = state->buffer_height / state->scale;
if ((state->transform & WL_OUTPUT_TRANSFORM_90) != 0) { if ((state->transform & WL_OUTPUT_TRANSFORM_90) != 0) {
int tmp = width; int tmp = width;
width = height; width = height;
height = tmp; height = tmp;
} }
state->width = width; state->width = width;
state->height = height; state->height = height;
pixman_region32_intersect_rect(&state->surface_damage,
&state->surface_damage, 0, 0, state->width, state->height);
pixman_region32_intersect_rect(&state->buffer_damage,
&state->buffer_damage, 0, 0, state->buffer_width,
state->buffer_height);
pixman_region32_intersect_rect(&state->opaque, &state->opaque,
0, 0, state->width, state->height);
pixman_region32_intersect_rect(&state->input, &state->input,
0, 0, state->width, state->height);
} }
static void surface_state_update_damage(struct wlr_surface_state *state, static void surface_update_damage(pixman_region32_t *buffer_damage,
struct wlr_surface_state *next) { struct wlr_surface_state *previous, struct wlr_surface_state *current) {
pixman_region32_clear(&state->damage); pixman_region32_clear(buffer_damage);
if (next->buffer_width != state->buffer_width || if (current->buffer_width != previous->buffer_width ||
next->buffer_height != state->buffer_height) { current->buffer_height != previous->buffer_height ||
// Damage the whole surface on resize current->dx != 0 || current->dy != 0) {
pixman_region32_union_rect(&state->damage, // Damage the whole surface on resize or move
&state->damage, state->sx * state->scale, state->sy * state->scale, int prev_x = -current->dx;
state->buffer_width, state->buffer_height); int prev_y = -current->dy;
pixman_region32_union_rect(&state->damage, if ((previous->transform & WL_OUTPUT_TRANSFORM_90) != 0) {
&state->damage, next->sx * next->scale, next->sy * next->scale, int tmp = prev_x;
next->buffer_width, next->buffer_height); prev_x = prev_y;
prev_y = tmp;
}
pixman_region32_union_rect(buffer_damage, buffer_damage,
prev_x * previous->scale, prev_y * previous->scale,
previous->buffer_width, previous->buffer_height);
pixman_region32_union_rect(buffer_damage, buffer_damage, 0, 0,
current->buffer_width, current->buffer_height);
} else { } else {
// Copy over surface damage + buffer damage // Copy over surface damage + buffer damage
pixman_region32_union(&state->damage, &state->damage, pixman_region32_union(buffer_damage, buffer_damage,
&next->buffer_damage); &current->buffer_damage);
pixman_region32_t surface_damage; pixman_region32_t surface_damage;
pixman_region32_init(&surface_damage); pixman_region32_init(&surface_damage);
pixman_region32_copy(&surface_damage, &next->surface_damage); pixman_region32_copy(&surface_damage, &current->surface_damage);
wlr_region_transform(&surface_damage, &surface_damage, next->transform, wlr_region_transform(&surface_damage, &surface_damage,
next->buffer_width, next->buffer_height); current->transform, current->buffer_width, current->buffer_height);
wlr_region_scale(&surface_damage, &surface_damage, next->scale); wlr_region_scale(&surface_damage, &surface_damage, current->scale);
pixman_region32_union(&state->damage, &state->damage, &surface_damage); pixman_region32_union(buffer_damage, buffer_damage, &surface_damage);
pixman_region32_fini(&surface_damage); pixman_region32_fini(&surface_damage);
// TODO: handle sx, sy
} }
} }
/** /**
* Append pending state to current state and clear pending state. * Append pending state to current state and clear pending state.
*/ */
static void surface_move_state(struct wlr_surface *surface, static void surface_state_move(struct wlr_surface_state *state,
struct wlr_surface_state *next, struct wlr_surface_state *state) { struct wlr_surface_state *next) {
// Commit next state
if ((next->committed & WLR_SURFACE_STATE_BUFFER)) {
wlr_buffer_get_resource_size(next->buffer, surface->renderer,
&next->buffer_width, &next->buffer_height);
}
surface_state_update_size(next);
next->sx += next->dx;
next->sy += next->dy;
pixman_region32_intersect_rect(&next->surface_damage,
&next->surface_damage, 0, 0, next->width, next->height);
pixman_region32_intersect_rect(&next->buffer_damage,
&next->buffer_damage, 0, 0, next->buffer_width,
next->buffer_height);
pixman_region32_intersect_rect(&next->opaque, &next->opaque,
0, 0, next->width, next->height);
pixman_region32_intersect_rect(&next->input, &next->input,
0, 0, next->width, next->height);
// Compute new state
surface_state_update_damage(state, next);
state->width = next->width; state->width = next->width;
state->height = next->height; state->height = next->height;
state->buffer_width = next->buffer_width; state->buffer_width = next->buffer_width;
state->buffer_height = next->buffer_height; state->buffer_height = next->buffer_height;
state->sx = next->sx;
state->sy = next->sy;
// Move state from next one, clear next state
if ((next->committed & WLR_SURFACE_STATE_SCALE)) { if ((next->committed & WLR_SURFACE_STATE_SCALE)) {
state->scale = next->scale; state->scale = next->scale;
@ -276,10 +266,9 @@ static void surface_damage_subsurfaces(struct wlr_subsurface *subsurface) {
// seems to work ok. See the comment on weston_surface_damage for more info // seems to work ok. See the comment on weston_surface_damage for more info
// about a better approach. // about a better approach.
struct wlr_surface *surface = subsurface->surface; struct wlr_surface *surface = subsurface->surface;
pixman_region32_union_rect(&surface->current.surface_damage, pixman_region32_union_rect(&surface->buffer_damage,
&surface->current.surface_damage, &surface->buffer_damage, 0, 0,
0, 0, surface->current.width, surface->current.buffer_width, surface->current.buffer_height);
surface->current.height);
subsurface->reordered = false; subsurface->reordered = false;
@ -301,8 +290,19 @@ static void surface_apply_damage(struct wlr_surface *surface) {
if (surface->buffer != NULL && surface->buffer->released) { if (surface->buffer != NULL && surface->buffer->released) {
pixman_region32_t damage; pixman_region32_t damage;
pixman_region32_init(&damage); pixman_region32_init(&damage);
pixman_region32_copy(&damage, &surface->current.damage); pixman_region32_copy(&damage, &surface->current.buffer_damage);
// TODO: translate sx, sy
pixman_region32_t surface_damage;
pixman_region32_init(&surface_damage);
pixman_region32_copy(&surface_damage, &surface->current.surface_damage);
wlr_region_transform(&surface_damage, &surface_damage,
surface->current.transform,
surface->current.buffer_width, surface->current.buffer_height);
wlr_region_scale(&surface_damage, &surface_damage,
surface->current.scale);
pixman_region32_union(&damage, &damage, &surface_damage);
pixman_region32_fini(&surface_damage);
pixman_region32_intersect_rect(&damage, &damage, 0, 0, pixman_region32_intersect_rect(&damage, &damage, 0, 0,
surface->current.buffer_width, surface->current.buffer_height); surface->current.buffer_width, surface->current.buffer_height);
@ -332,7 +332,14 @@ static void surface_apply_damage(struct wlr_surface *surface) {
static void surface_commit_pending(struct wlr_surface *surface) { static void surface_commit_pending(struct wlr_surface *surface) {
bool invalid_buffer = surface->pending.committed & WLR_SURFACE_STATE_BUFFER; bool invalid_buffer = surface->pending.committed & WLR_SURFACE_STATE_BUFFER;
surface_move_state(surface, &surface->pending, &surface->current); surface_state_finalize(surface, &surface->pending);
surface->sx += surface->pending.dx;
surface->sy += surface->pending.dy;
surface_update_damage(&surface->buffer_damage,
&surface->current, &surface->pending);
surface_state_move(&surface->current, &surface->pending);
if (invalid_buffer) { if (invalid_buffer) {
surface_apply_damage(surface); surface_apply_damage(surface);
@ -385,7 +392,7 @@ static void subsurface_parent_commit(struct wlr_subsurface *subsurface,
struct wlr_surface *surface = subsurface->surface; struct wlr_surface *surface = subsurface->surface;
if (synchronized || subsurface->synchronized) { if (synchronized || subsurface->synchronized) {
if (subsurface->has_cache) { if (subsurface->has_cache) {
surface_move_state(surface, &subsurface->cached, &surface->pending); surface_state_move(&surface->pending, &subsurface->cached);
surface_commit_pending(surface); surface_commit_pending(surface);
subsurface->has_cache = false; subsurface->has_cache = false;
subsurface->cached.committed = 0; subsurface->cached.committed = 0;
@ -402,11 +409,11 @@ static void subsurface_commit(struct wlr_subsurface *subsurface) {
struct wlr_surface *surface = subsurface->surface; struct wlr_surface *surface = subsurface->surface;
if (subsurface_is_synchronized(subsurface)) { if (subsurface_is_synchronized(subsurface)) {
surface_move_state(surface, &surface->pending, &subsurface->cached); surface_state_move(&subsurface->cached, &surface->pending);
subsurface->has_cache = true; subsurface->has_cache = true;
} else { } else {
if (subsurface->has_cache) { if (subsurface->has_cache) {
surface_move_state(surface, &subsurface->cached, &surface->pending); surface_state_move(&surface->pending, &subsurface->cached);
surface_commit_pending(surface); surface_commit_pending(surface);
subsurface->has_cache = false; subsurface->has_cache = false;
} else { } else {
@ -492,7 +499,6 @@ static void surface_state_init(struct wlr_surface_state *state) {
pixman_region32_init(&state->opaque); pixman_region32_init(&state->opaque);
pixman_region32_init_rect(&state->input, pixman_region32_init_rect(&state->input,
INT32_MIN, INT32_MIN, UINT32_MAX, UINT32_MAX); INT32_MIN, INT32_MIN, UINT32_MAX, UINT32_MAX);
pixman_region32_init(&state->damage);
} }
static void surface_state_finish(struct wlr_surface_state *state) { static void surface_state_finish(struct wlr_surface_state *state) {
@ -507,7 +513,6 @@ static void surface_state_finish(struct wlr_surface_state *state) {
pixman_region32_fini(&state->buffer_damage); pixman_region32_fini(&state->buffer_damage);
pixman_region32_fini(&state->opaque); pixman_region32_fini(&state->opaque);
pixman_region32_fini(&state->input); pixman_region32_fini(&state->input);
pixman_region32_fini(&state->damage);
} }
static void subsurface_destroy(struct wlr_subsurface *subsurface) { static void subsurface_destroy(struct wlr_subsurface *subsurface) {
@ -543,6 +548,7 @@ static void surface_handle_resource_destroy(struct wl_resource *resource) {
wl_list_remove(&surface->renderer_destroy.link); wl_list_remove(&surface->renderer_destroy.link);
surface_state_finish(&surface->pending); surface_state_finish(&surface->pending);
surface_state_finish(&surface->current); surface_state_finish(&surface->current);
pixman_region32_fini(&surface->buffer_damage);
wlr_buffer_unref(surface->buffer); wlr_buffer_unref(surface->buffer);
free(surface); free(surface);
} }
@ -586,6 +592,7 @@ struct wlr_surface *wlr_surface_create(struct wl_client *client,
wl_signal_init(&surface->events.new_subsurface); wl_signal_init(&surface->events.new_subsurface);
wl_list_init(&surface->subsurfaces); wl_list_init(&surface->subsurfaces);
wl_list_init(&surface->subsurface_pending_list); wl_list_init(&surface->subsurface_pending_list);
pixman_region32_init(&surface->buffer_damage);
wl_signal_add(&renderer->events.destroy, &surface->renderer_destroy); wl_signal_add(&renderer->events.destroy, &surface->renderer_destroy);
surface->renderer_destroy.notify = surface_handle_renderer_destroy; surface->renderer_destroy.notify = surface_handle_renderer_destroy;
@ -773,23 +780,28 @@ static void subsurface_role_committed(struct wlr_surface *surface, void *data) {
if (subsurface->current.x != subsurface->pending.x || if (subsurface->current.x != subsurface->pending.x ||
subsurface->current.y != subsurface->pending.y) { subsurface->current.y != subsurface->pending.y) {
// Subsurface has moved // Subsurface has moved
int dx = subsurface->pending.x - subsurface->current.x; int dx = subsurface->current.x - subsurface->pending.x;
int dy = subsurface->pending.y - subsurface->current.y; int dy = subsurface->current.y - subsurface->pending.y;
subsurface->current.x = subsurface->pending.x; subsurface->current.x = subsurface->pending.x;
subsurface->current.y = subsurface->pending.y; subsurface->current.y = subsurface->pending.y;
if ((surface->current.transform & WL_OUTPUT_TRANSFORM_90) != 0) {
int tmp = dx;
dx = dy;
dy = tmp;
}
// TODO: take the previous size // TODO: take the previous size
pixman_region32_union_rect( pixman_region32_union_rect(&surface->buffer_damage,
&subsurface->surface->pending.surface_damage, &surface->buffer_damage,
&subsurface->surface->pending.surface_damage, dx, dy, dx * surface->current.scale, dy * surface->current.scale,
subsurface->surface->current.width, surface->current.width,
subsurface->surface->current.height); surface->current.height);
pixman_region32_union_rect( pixman_region32_union_rect(&surface->buffer_damage,
&subsurface->surface->pending.surface_damage, &surface->buffer_damage, 0, 0,
&subsurface->surface->pending.surface_damage, 0, 0, surface->pending.width,
subsurface->surface->pending.width, surface->pending.height);
subsurface->surface->pending.height);
} }
} }