aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rw-r--r--CHANGELOG.md5
-rw-r--r--render.c130
-rw-r--r--shm.c3
-rw-r--r--shm.h2
4 files changed, 73 insertions, 67 deletions
diff --git a/CHANGELOG.md b/CHANGELOG.md
index ffbdd08b..17430354 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -71,6 +71,11 @@
* Crash in `foot --server` on key press, after another `footclient`
has terminated very early (for example, by trying to launch a
non-existing shell/client).
+* Glitchy rendering when scrolling in the scrollback, on compositors
+ that does not allow Wayland buffer re-use (e.g. KDE/plasma)
+ ([#1173][1173])
+
+[1173]: https://codeberg.org/dnkl/foot/issues/1173
### Security
diff --git a/render.c b/render.c
index 8775171e..7f883220 100644
--- a/render.c
+++ b/render.c
@@ -1014,6 +1014,13 @@ grid_render_scroll(struct terminal *term, struct buffer *buf,
wl_surface_damage_buffer(
term->window->surface, term->margins.left, dst_y,
term->width - term->margins.left - term->margins.right, height);
+
+ /*
+ * TODO: remove this if re-enabling scroll damage when re-applying
+ * last frame’s damage (see reapply_old_damage()
+ */
+ pixman_region32_union_rect(
+ &buf->dirty, &buf->dirty, 0, dst_y, buf->width, height);
}
static void
@@ -1079,6 +1086,13 @@ grid_render_scroll_reverse(struct terminal *term, struct buffer *buf,
wl_surface_damage_buffer(
term->window->surface, term->margins.left, dst_y,
term->width - term->margins.left - term->margins.right, height);
+
+ /*
+ * TODO: remove this if re-enabling scroll damage when re-applying
+ * last frame’s damage (see reapply_old_damage()
+ */
+ pixman_region32_union_rect(
+ &buf->dirty, &buf->dirty, 0, dst_y, buf->width, height);
}
static void
@@ -2538,22 +2552,27 @@ reapply_old_damage(struct terminal *term, struct buffer *new, struct buffer *old
return;
}
+ pixman_region32_t dirty;
+ pixman_region32_init(&dirty);
+
/*
- * TODO: remove this frame’s damage from the region we copy from
- * the old frame.
+ * Figure out current frame’s damage region
+ *
+ * If current frame doesn’t have any scroll damage, we can simply
+ * subtract this frame’s damage from the last frame’s damage. That
+ * way, we don’t have to copy areas from the old frame that’ll
+ * just get overwritten by current frame.
*
- * - this frame’s dirty region is only valid *after* we’ve applied
- * its scroll damage.
- * - last frame’s dirty region is only valid *before* we’ve
- * applied this frame’s scroll damage.
+ * Note that this is row based. A “half damaged” row is not
+ * excluded. I.e. the entire row will be copied from the old frame
+ * to the new, and then when actually rendering the new frame, the
+ * updated cells will overwrite parts of the copied row.
*
- * Can we transform one of the regions? It’s not trivial, since
- * scroll damage isn’t just about counting lines; there may be
- * multiple damage records, each with different scrolling regions.
+ * Since we’re scanning the entire viewport anyway, we also track
+ * whether *all* cells are to be updated. In this case, just force
+ * a full re-rendering, and don’t copy anything from the old
+ * frame.
*/
- pixman_region32_t dirty;
- pixman_region32_init(&dirty);
-
bool full_repaint_needed = true;
for (int r = 0; r < term->rows; r++) {
@@ -2583,35 +2602,31 @@ reapply_old_damage(struct terminal *term, struct buffer *new, struct buffer *old
return;
}
- for (size_t i = 0; i < old->scroll_damage_count; i++) {
- const struct damage *dmg = &old->scroll_damage[i];
-
- switch (dmg->type) {
- case DAMAGE_SCROLL:
- if (term->grid->view == term->grid->offset)
- grid_render_scroll(term, new, dmg);
- break;
-
- case DAMAGE_SCROLL_REVERSE:
- if (term->grid->view == term->grid->offset)
- grid_render_scroll_reverse(term, new, dmg);
- break;
-
- case DAMAGE_SCROLL_IN_VIEW:
- grid_render_scroll(term, new, dmg);
- break;
-
- case DAMAGE_SCROLL_REVERSE_IN_VIEW:
- grid_render_scroll_reverse(term, new, dmg);
- break;
- }
- }
+ /*
+ * TODO: re-apply last frame’s scroll damage
+ *
+ * We used to do this, but it turned out to be buggy. If we decide
+ * to re-add it, this is where to do it. Note that we’d also have
+ * to remove the updates to buf->dirty from grid_render_scroll()
+ * and grid_render_scroll_reverse().
+ */
if (tll_length(term->grid->scroll_damage) == 0) {
+ /*
+ * We can only subtract current frame’s damage from the old
+ * frame’s if we don’t have any scroll damage.
+ *
+ * If we do have scroll damage, the damage region we
+ * calculated above is not (yet) valid - we need to apply the
+ * current frame’s scroll damage *first*. This is done later,
+ * when rendering the frame.
+ */
pixman_region32_subtract(&dirty, &old->dirty, &dirty);
pixman_image_set_clip_region32(new->pix[0], &dirty);
- } else
+ } else {
+ /* Copy *all* of last frame’s damaged areas */
pixman_image_set_clip_region32(new->pix[0], &old->dirty);
+ }
pixman_image_composite32(
PIXMAN_OP_SRC, old->pix[0], NULL, new->pix[0],
@@ -2702,38 +2717,29 @@ grid_render(struct terminal *term)
shm_addref(buf);
buf->age = 0;
- free(term->render.last_buf->scroll_damage);
- buf->scroll_damage_count = tll_length(term->grid->scroll_damage);
- buf->scroll_damage = xmalloc(
- buf->scroll_damage_count * sizeof(buf->scroll_damage[0]));
-
- {
- size_t i = 0;
- tll_foreach(term->grid->scroll_damage, it) {
- buf->scroll_damage[i++] = it->item;
-
- switch (it->item.type) {
- case DAMAGE_SCROLL:
- if (term->grid->view == term->grid->offset)
- grid_render_scroll(term, buf, &it->item);
- break;
-
- case DAMAGE_SCROLL_REVERSE:
- if (term->grid->view == term->grid->offset)
- grid_render_scroll_reverse(term, buf, &it->item);
- break;
- case DAMAGE_SCROLL_IN_VIEW:
+ tll_foreach(term->grid->scroll_damage, it) {
+ switch (it->item.type) {
+ case DAMAGE_SCROLL:
+ if (term->grid->view == term->grid->offset)
grid_render_scroll(term, buf, &it->item);
- break;
+ break;
- case DAMAGE_SCROLL_REVERSE_IN_VIEW:
+ case DAMAGE_SCROLL_REVERSE:
+ if (term->grid->view == term->grid->offset)
grid_render_scroll_reverse(term, buf, &it->item);
- break;
- }
+ break;
+
+ case DAMAGE_SCROLL_IN_VIEW:
+ grid_render_scroll(term, buf, &it->item);
+ break;
- tll_remove(term->grid->scroll_damage, it);
+ case DAMAGE_SCROLL_REVERSE_IN_VIEW:
+ grid_render_scroll_reverse(term, buf, &it->item);
+ break;
}
+
+ tll_remove(term->grid->scroll_damage, it);
}
/*
diff --git a/shm.c b/shm.c
index 4c342ddf..4394dbe9 100644
--- a/shm.c
+++ b/shm.c
@@ -151,7 +151,6 @@ buffer_destroy(struct buffer_private *buf)
pool_unref(buf->pool);
buf->pool = NULL;
- free(buf->public.scroll_damage);
pixman_region32_fini(&buf->public.dirty);
free(buf);
}
@@ -581,8 +580,6 @@ shm_get_buffer(struct buffer_chain *chain, int width, int height)
LOG_DBG("re-using buffer %p from cache", (void *)cached);
cached->busy = true;
pixman_region32_clear(&cached->public.dirty);
- free(cached->public.scroll_damage);
- cached->public.scroll_damage = NULL;
xassert(cached->public.pix_instances == chain->pix_instances);
return &cached->public;
}
diff --git a/shm.h b/shm.h
index bed4285c..440cfa1d 100644
--- a/shm.h
+++ b/shm.h
@@ -24,8 +24,6 @@ struct buffer {
unsigned age;
- struct damage *scroll_damage;
- size_t scroll_damage_count;
pixman_region32_t dirty;
};