[WIP] Implement smooth and precise scrolling

kitty/child-monitor.c

@@ -246,7 +246,7 @@ schedule_write_to_child(unsigned long id, unsigned int num, ...) {
                 }
                 screen->write_buf_sz = screen->write_buf_used + sz;
                 screen->write_buf = PyMem_RawRealloc(screen->write_buf, screen->write_buf_sz);
-                if (screen->write_buf == NULL) { fatal("Out of memory."); }
+                if (screen->write_buf == NULL) fatal("Out of memory.");
             }
             va_start(ap, num);
             for (unsigned int i = 0; i < num; i++) {
@@ -259,7 +259,7 @@ schedule_write_to_child(unsigned long id, unsigned int num, ...) {
             if (screen->write_buf_sz > BUFSIZ && screen->write_buf_used < BUFSIZ) {
                 screen->write_buf_sz = BUFSIZ;
                 screen->write_buf = PyMem_RawRealloc(screen->write_buf, screen->write_buf_sz);
-                if (screen->write_buf == NULL) { fatal("Out of memory."); }
+                if (screen->write_buf == NULL) fatal("Out of memory.");
             }
             if (screen->write_buf_used) wakeup_io_loop(self, false);
             screen_mutex(unlock, write);
@@ -589,8 +589,13 @@ prepare_to_render_os_window(OSWindow *os_window, monotonic_t now, unsigned int *
 
 static inline void
 render_os_window(OSWindow *os_window, monotonic_t now, unsigned int active_window_id, color_type active_window_bg, unsigned int num_visible_windows, bool all_windows_have_same_bg) {
+    static bool first_time = true;
+    if (first_time) {
+        setup_scroll(os_window);
+        first_time = false;
+    }
     // ensure all pixels are cleared to background color at least once in every buffer
-    if (os_window->clear_count++ < 3) blank_os_window(os_window);
+    if (os_window->clear_count++ < 2) blank_os_window(os_window);
     Tab *tab = os_window->tabs + os_window->active_tab;
     BorderRects *br = &tab->border_rects;
     bool static_live_resize_in_progress = os_window->live_resize.in_progress && OPT(resize_draw_strategy) == RESIZE_DRAW_STATIC;
@@ -603,19 +608,24 @@ render_os_window(OSWindow *os_window, monotonic_t now, unsigned int active_windo
         draw_borders(br->vao_idx, br->num_border_rects, br->rect_buf, br->is_dirty, os_window->viewport_width, os_window->viewport_height, active_window_bg, num_visible_windows, all_windows_have_same_bg, os_window);
         br->is_dirty = false;
     }
-    if (TD.screen && os_window->num_tabs >= OPT(tab_bar_min_tabs)) draw_cells(TD.vao_idx, 0, TD.xstart, TD.ystart, TD.dx * x_ratio, TD.dy * y_ratio, TD.screen, os_window, true, false);
     for (unsigned int i = 0; i < tab->num_windows; i++) {
         Window *w = tab->windows + i;
         if (w->visible && WD.screen) {
+            before_render();
             bool is_active_window = i == tab->active_window;
-            draw_cells(WD.vao_idx, WD.gvao_idx, WD.xstart, WD.ystart, WD.dx * x_ratio, WD.dy * y_ratio, WD.screen, os_window, is_active_window, true);
-            if (WD.screen->start_visual_bell_at != 0) {
-                monotonic_t bell_left = OPT(visual_bell_duration) - (now - WD.screen->start_visual_bell_at);
-                set_maximum_wait(bell_left);
+            if (WD.screen->render_not_only_pixel_scroll) {
+                WD.screen->render_not_only_pixel_scroll = false;
+                draw_cells(WD.vao_idx, WD.gvao_idx, WD.xstart, WD.ystart, WD.dx * x_ratio, WD.dy * y_ratio, WD.screen, os_window, is_active_window, true);
+                if (WD.screen->start_visual_bell_at != 0) {
+                    monotonic_t bell_left = OPT(visual_bell_duration) - (now - WD.screen->start_visual_bell_at);
+                    set_maximum_wait(bell_left);
+                }
             }
+            after_render(os_window, (WD.screen->scrolled_by_pixels * 2.0) / os_window->viewport_height);
             w->cursor_visible_at_last_render = WD.screen->cursor_render_info.is_visible; w->last_cursor_x = WD.screen->cursor_render_info.x; w->last_cursor_y = WD.screen->cursor_render_info.y; w->last_cursor_shape = WD.screen->cursor_render_info.shape;
         }
     }
+    if (TD.screen && os_window->num_tabs >= OPT(tab_bar_min_tabs)) draw_cells(TD.vao_idx, 0, TD.xstart, TD.ystart, TD.dx, TD.dy, TD.screen, os_window, true, false);
     swap_window_buffers(os_window);
     os_window->last_active_tab = os_window->active_tab; os_window->last_num_tabs = os_window->num_tabs; os_window->last_active_window_id = active_window_id;
     os_window->focused_at_last_render = os_window->is_focused;
@@ -688,7 +698,7 @@ render(monotonic_t now, bool input_read) {
         bool needs_render = w->is_damaged || w->live_resize.in_progress;
         if (w->viewport_size_dirty) {
             w->clear_count = 0;
-            update_surface_size(w->viewport_width, w->viewport_height, w->offscreen_texture_id);
+            update_surface_size(w->viewport_width, w->viewport_height, w->offscreen_texture_id, w->scroll_texture_id);
             w->viewport_size_dirty = false;
             needs_render = true;
         }

kitty/fonts.c

@@ -720,7 +720,7 @@ extract_cell_from_canvas(FontGroup *fg, unsigned int i, unsigned int num_cells)
 
 static inline void
 render_group(FontGroup *fg, unsigned int num_cells, unsigned int num_glyphs, CPUCell *cpu_cells, GPUCell *gpu_cells, hb_glyph_info_t *info, hb_glyph_position_t *positions, Font *font, glyph_index glyph, ExtraGlyphs *extra_glyphs, bool center_glyph) {
-    static SpritePosition* sprite_position[16];
+    static SpritePosition* sprite_position[16]; // TODO: Remove magic number
     int error = 0;
     num_cells = MIN(arraysz(sprite_position), num_cells);
     for (unsigned int i = 0; i < num_cells; i++) {

kitty/gl.c

@@ -67,8 +67,12 @@ gl_init() {
 }
 
 void
-update_surface_size(int w, int h, GLuint offscreen_texture_id) {
+update_surface_size(int w, int h, GLuint offscreen_texture_id, GLuint scroll_texture_id) {
     glViewport(0, 0, w, h);
+    if (scroll_texture_id) {
+        glBindTexture(GL_TEXTURE_2D, scroll_texture_id);
+        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
+    }
     if (offscreen_texture_id) {
         glBindTexture(GL_TEXTURE_2D, offscreen_texture_id);
         glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);

kitty/gl.h

@@ -33,7 +33,7 @@ typedef struct {
 
 
 void gl_init(void);
-void update_surface_size(int w, int h, GLuint offscreen_texture_id);
+void update_surface_size(int w, int h, GLuint offscreen_texture_id, GLuint scroll_texture_id);
 void free_texture(GLuint *tex_id);
 void free_framebuffer(GLuint *fb_id);
 void remove_vao(ssize_t vao_idx);

kitty/glfw.c

@@ -203,7 +203,7 @@ framebuffer_size_callback(GLFWwindow *w, int width, int height) {
         window->live_resize.width = MAX(0, width); window->live_resize.height = MAX(0, height);
         window->live_resize.num_of_resize_events++;
         make_os_window_context_current(window);
-        update_surface_size(width, height, window->offscreen_texture_id);
+        update_surface_size(width, height, window->offscreen_texture_id, window->scroll_texture_id);
         request_tick_callback();
     } else log_error("Ignoring resize request for tiny size: %dx%d", width, height);
     global_state.callback_os_window = NULL;

kitty/keys.c

@@ -187,6 +187,7 @@ on_key_input(GLFWkeyevent *ev) {
     }
     if (screen->scrolled_by && action == GLFW_PRESS && !is_modifier_key(key)) {
         screen_history_scroll(screen, SCROLL_FULL, false);  // scroll back to bottom
+        pixel_scroll(screen, 0);
     }
     bool ok_to_send = action == GLFW_PRESS || action == GLFW_REPEAT || screen->modes.mEXTENDED_KEYBOARD;
     if (ok_to_send) {

kitty/mouse.c

@@ -192,6 +192,7 @@ do_drag_scroll(Window *w, bool upwards) {
     Screen *screen = w->render_data.screen;
     if (screen->linebuf == screen->main_linebuf) {
         screen_history_scroll(screen, SCROLL_LINE, upwards);
+        pixel_scroll(screen, 0);
         update_drag(false, w, false, 0);
         if (mouse_cursor_shape != ARROW) {
             mouse_cursor_shape = ARROW;
@@ -651,18 +652,12 @@ scroll_event(double UNUSED xoffset, double yoffset, int flags) {
     int s;
     bool is_high_resolution = flags & 1;
 
+    double pixels = screen->pending_scroll_pixels;
     if (is_high_resolution) {
         yoffset *= OPT(touch_scroll_multiplier);
-        if (yoffset * screen->pending_scroll_pixels < 0) {
-            screen->pending_scroll_pixels = 0;  // change of direction
-        }
-        double pixels = screen->pending_scroll_pixels + yoffset;
-        if (fabs(pixels) < global_state.callback_os_window->fonts_data->cell_height) {
-            screen->pending_scroll_pixels = pixels;
-            return;
-        }
+        pixels += yoffset;
         s = (int)round(pixels) / (int)global_state.callback_os_window->fonts_data->cell_height;
-        screen->pending_scroll_pixels = pixels - s * (int) global_state.callback_os_window->fonts_data->cell_height;
+        pixels = pixels - s * (int) global_state.callback_os_window->fonts_data->cell_height;
     } else {
         if (screen->linebuf == screen->main_linebuf || !screen->modes.mouse_tracking_mode) {
             // Only use wheel_scroll_multiplier if we are scrolling kitty scrollback or in mouse
@@ -677,13 +672,18 @@ scroll_event(double UNUSED xoffset, double yoffset, int flags) {
         // apparently on cocoa some mice generate really small yoffset values
         // when scrolling slowly https://github.com/kovidgoyal/kitty/issues/1238
         if (s == 0 && yoffset != 0) s = yoffset > 0 ? 1 : -1;
-        screen->pending_scroll_pixels = 0;
     }
-    if (s == 0) return;
     bool upwards = s > 0;
+    //printf("asdf %f\n", pixels);
     if (screen->linebuf == screen->main_linebuf) {
         screen_history_scroll(screen, abs(s), upwards);
+        if (screen->scrolled_by == 0 && pixels < 0) pixels = 0;
+        if (screen->scrolled_by == screen->historybuf->count && pixels > 0) pixels = 0;
+        screen->pending_scroll_pixels = pixels;
+        pixel_scroll(screen, (int)pixels);
     } else {
+        pixels = 0.0;
+        pixel_scroll(screen, (int)pixels);
         if (screen->modes.mouse_tracking_mode) {
             int sz = encode_mouse_event(w, upwards ? GLFW_MOUSE_BUTTON_4 : GLFW_MOUSE_BUTTON_5, PRESS, 0);
             if (sz > 0) {
@@ -696,6 +696,7 @@ scroll_event(double UNUSED xoffset, double yoffset, int flags) {
             fake_scroll(abs(s), upwards);
         }
     }
+    screen->pending_scroll_pixels = pixels;
 }
 
 static PyObject*

kitty/screen.c

@@ -97,6 +97,8 @@ new(PyTypeObject *type, PyObject *args, PyObject UNUSED *kwds) {
         self->modes = empty_modes;
         self->is_dirty = true;
         self->scroll_changed = false;
+        self->pixel_scroll_changed = false;
+        self->render_not_only_pixel_scroll = false;
         self->margin_top = 0; self->margin_bottom = self->lines - 1;
         self->history_line_added_count = 0;
         RESET_CHARSETS;
@@ -657,6 +659,7 @@ screen_toggle_screen_buffer(Screen *self) {
         self->grman = self->main_grman;
     }
     screen_history_scroll(self, SCROLL_FULL, false);
+    pixel_scroll(self, 0);
     self->is_dirty = true;
     self->selection = EMPTY_SELECTION;
 }
@@ -1199,6 +1202,7 @@ screen_erase_in_display(Screen *self, unsigned int how, bool private) {
             self->scrolled_by = 0;
             self->scroll_changed = true;
         }
+        pixel_scroll(self, 0);
     }
 }
 
@@ -2205,6 +2209,12 @@ screen_selection_range_for_word(Screen *self, const index_type x, const index_ty
 #undef is_ok
 }
 
+void pixel_scroll(Screen *self, int amt) {
+    //printf("pixel_scroll(%d)\n", amt);
+    self->scrolled_by_pixels = amt;
+    self->pixel_scroll_changed = true;
+}
+
 bool
 screen_history_scroll(Screen *self, int amt, bool upwards) {
     switch(amt) {
@@ -2239,6 +2249,7 @@ static PyObject*
 scroll(Screen *self, PyObject *args) {
     int amt, upwards;
     if (!PyArg_ParseTuple(args, "ip", &amt, &upwards)) return NULL;
+    pixel_scroll(self, 0);
     if (screen_history_scroll(self, amt, upwards)) { Py_RETURN_TRUE; }
     Py_RETURN_FALSE;
 }

kitty/screen.h

@@ -76,6 +76,7 @@ typedef struct {
     PyObject_HEAD
 
     unsigned int columns, lines, margin_top, margin_bottom, charset, scrolled_by;
+    int scrolled_by_pixels;
     double pending_scroll_pixels;
     CellPixelSize cell_size;
     OverlayLine overlay_line;
@@ -87,7 +88,7 @@ typedef struct {
         IterationData selection, url;
         unsigned int cursor_x, cursor_y, scrolled_by;
     } last_rendered;
-    bool use_latin1, is_dirty, scroll_changed, reload_all_gpu_data;
+    bool use_latin1, is_dirty, scroll_changed, pixel_scroll_changed, reload_all_gpu_data, render_not_only_pixel_scroll;
     Cursor *cursor;
     SavepointBuffer main_savepoints, alt_savepoints;
     SavemodesBuffer modes_savepoints;
@@ -197,6 +198,7 @@ bool screen_selection_range_for_line(Screen *self, index_type y, index_type *sta
 bool screen_selection_range_for_word(Screen *self, const index_type x, const index_type y, index_type *, index_type *, index_type *start, index_type *end, bool);
 void screen_start_selection(Screen *self, index_type x, index_type y, bool, bool, SelectionExtendMode);
 void screen_update_selection(Screen *self, index_type x, index_type y, bool in_left_half, bool ended, bool start_extended_selection);
+void pixel_scroll(Screen *self, int amt);
 bool screen_history_scroll(Screen *self, int amt, bool upwards);
 Line* screen_visual_line(Screen *self, index_type y);
 unsigned long screen_current_char_width(Screen *self);

kitty/scroll_fragment.glsl

@@ -0,0 +1,11 @@
+#version GLSL_VERSION
+out vec4 FragColor;
+
+in vec2 TexCoords;
+
+uniform sampler2D screenTexture;
+
+void main()
+{
+    FragColor = texture(screenTexture, TexCoords);
+}

kitty/scroll_vertex.glsl

@@ -0,0 +1,13 @@
+#version GLSL_VERSION
+layout (location = 0) in vec2 aPos;
+layout (location = 1) in vec2 aTexCoords;
+
+uniform float offset;
+
+out vec2 TexCoords;
+
+void main()
+{
+    gl_Position = vec4(aPos.x, aPos.y - offset, 0.0, 1.0);
+    TexCoords = aTexCoords;
+}