perf: offload drag and layer resize processing to the GPU

after a week of some of the most math intensive shit I have ever done
we now have smoother dragging thx to the GdkPaintable and some fucking
algorithm's I have made(or recreated?). I express my gratitude to my
data structures and alorithm's professor for the lessons.

Author: vani-tty1

src/meme-canvas.c

@@ -197,7 +197,9 @@ void on_drag_begin (GtkGestureDrag *gesture, double x, double y, MemeWindow *sel
             self->selected_layer = layer;
             self->drag_obj_start_scale = layer->scale;
             self->drag_start_x = ix * img_w; self->drag_start_y = iy * img_h; 
-            sync_ui_with_layer(self); render_meme(self); return;
+            sync_ui_with_layer(self);
+            if (!meme_window_begin_layer_drag(self)) render_meme(self);
+            return;
         }
 
         if (ix >= l_left && ix <= l_right && iy >= l_top && iy <= l_bot) {
@@ -207,7 +209,9 @@ void on_drag_begin (GtkGestureDrag *gesture, double x, double y, MemeWindow *sel
             self->drag_obj_start_x = layer->x; self->drag_obj_start_y = layer->y;
             self->drag_start_x = ix; self->drag_start_y = iy;
             self->snap_guide_v_active = FALSE; self->snap_guide_h_active = FALSE;
-            sync_ui_with_layer(self); render_meme(self); return;
+            sync_ui_with_layer(self);
+            if (!meme_window_begin_layer_drag(self)) render_meme(self);
+            return;
         }
     }
     if (self->selected_layer) { self->selected_layer = NULL; sync_ui_with_layer(self); render_meme(self); }
@@ -261,8 +265,8 @@ void on_drag_update (GtkGestureDrag *gesture, double offset_x, double offset_y,
         double cdx = (self->drag_start_x + offset_x/s) - cx, cdy = (self->drag_start_y + offset_y/s) - cy;
         double dist_s = sqrt(sdx*sdx + sdy*sdy), dist_c = sqrt(cdx*cdx + cdy*cdy);
         if (dist_s > 5.0) self->selected_layer->scale = CLAMP(self->drag_obj_start_scale * (dist_c/dist_s), 0.1, 5.0);
-        if (self->selected_layer->type == LAYER_TYPE_TEXT) {
-            self->selected_layer->pixbuf = NULL;
+        if (self->selected_layer->type == LAYER_TYPE_TEXT && !self->drag_preview) {
+            g_clear_object (&self->selected_layer->pixbuf);
         }
     } else if (self->drag_type == DRAG_TYPE_DRAW_STROKE && self->draw_points) {
         double start_x, start_y, wx, wy, pix, piy;
@@ -279,6 +283,10 @@ void on_drag_update (GtkGestureDrag *gesture, double offset_x, double offset_y,
     if (self->drag_type == DRAG_TYPE_CROP_MOVE || self->drag_type == DRAG_TYPE_CROP_RESIZE ||
         self->drag_type == DRAG_TYPE_DRAW_STROKE) {
         gtk_widget_queue_draw(GTK_WIDGET(self->crop_overlay_area));
+    } else if (self->drag_preview) {
+        meme_window_update_layer_drag(self);
+        if (self->drag_type == DRAG_TYPE_IMAGE_MOVE)
+            gtk_widget_queue_draw(GTK_WIDGET(self->crop_overlay_area));
     } else {
         render_meme(self);
         if (self->drag_type == DRAG_TYPE_IMAGE_MOVE)
@@ -319,6 +327,11 @@ void on_drag_end (GtkGestureDrag *g, double x, double y, MemeWindow *self) {
         g_array_free (self->draw_points, TRUE);
         self->draw_points = NULL;
     }
+    if (self->drag_preview && self->drag_type == DRAG_TYPE_IMAGE_RESIZE &&
+        self->selected_layer && self->selected_layer->type == LAYER_TYPE_TEXT) {
+        g_clear_object (&self->selected_layer->pixbuf);
+    }
+    meme_window_end_layer_drag(self);
     self->drag_type = DRAG_TYPE_NONE;
     render_meme(self);
 }

src/meme-window-canvas.c

@@ -23,11 +23,68 @@
 #include "meme-window-private.h"
 #include "meme-canvas.h"
 
+gboolean meme_window_begin_layer_drag (MemeWindow *self) {
+    ImageLayer *layer = self->selected_layer;
+    GdkTexture *below = NULL, *above = NULL, *layer_tex = NULL;
+    MemeDragLayerState state;
+    gboolean cinematic, deepfry, bw, reduce_quality_on_drag;
+
+    g_clear_object (&self->drag_preview);
+
+    if (!layer || !self->template_image) return FALSE;
+    if (self->drag_type != DRAG_TYPE_IMAGE_MOVE &&
+        self->drag_type != DRAG_TYPE_IMAGE_RESIZE) return FALSE;
+
+    cinematic = gtk_toggle_button_get_active (self->cinematic_button);
+    deepfry = gtk_toggle_button_get_active (self->deep_fry_button);
+    bw = gtk_toggle_button_get_active (self->bw_button);
+    reduce_quality_on_drag = g_settings_get_boolean (self->template_settings, "reduce-quality-on-drag");
+
+    if (bw) return FALSE;
+
+    if ((cinematic || deepfry) && !reduce_quality_on_drag) return FALSE;
+
+    if (!meme_render_drag_split (self->template_image, self->layers, layer,
+                                 &below, &above, &layer_tex))
+        return FALSE;
+
+    self->drag_preview = meme_drag_preview_new (below, above, layer_tex);
+    g_clear_object (&below);
+    g_clear_object (&above);
+    g_clear_object (&layer_tex);
+
+    meme_drag_preview_state_from_layer (&state, layer);
+    meme_drag_preview_set_state (self->drag_preview, &state);
+    gtk_picture_set_paintable (self->meme_preview, GDK_PAINTABLE (self->drag_preview));
+    return TRUE;
+}
+
+void meme_window_update_layer_drag (MemeWindow *self) {
+    MemeDragLayerState state;
+
+    if (!self->drag_preview || !self->selected_layer) return;
+    meme_drag_preview_state_from_layer (&state, self->selected_layer);
+    meme_drag_preview_set_state (self->drag_preview, &state);
+}
+
+void meme_window_end_layer_drag (MemeWindow *self) {
+    g_clear_object (&self->drag_preview);
+}
+
 void render_meme (MemeWindow *self) {
     gboolean is_dragging, is_crop_drag, crop_active, cinematic, deepfry, bw_button;
     gboolean reduce_quality_on_drag, use_fast_preview;
     GdkTexture *tex;
 
+    if (self->drag_preview) {
+        if (self->drag_type == DRAG_TYPE_IMAGE_MOVE ||
+            self->drag_type == DRAG_TYPE_IMAGE_RESIZE) {
+            meme_window_update_layer_drag (self);
+            return;
+        }
+        g_clear_object (&self->drag_preview);
+    }
+
     if (!self->template_image) return;
 
     is_dragging = (self->drag_type != DRAG_TYPE_NONE);

src/meme-window-private.h

@@ -3,6 +3,7 @@
 #include <adwaita.h>
 #include "meme-core.h"
 #include "meme-renderer.h"
+#include "meme-drag-preview.h"
 
 typedef struct {
     GdkPixbuf *pixbuf;
@@ -51,6 +52,7 @@ struct _MemeWindow {
     GtkWidget  *margin_color_btn;
     GtkButton *save_project_button, *load_project_button;   
     GdkPixbuf *template_image, *final_meme;
+    MemeDragPreview *drag_preview;   /* non-NULL while a layer is dragged on the GPU */
     GList *layers, *undo_stack, *redo_stack;
     ImageLayer *selected_layer; 
     DragType drag_type;
@@ -116,6 +118,9 @@ struct _MemeWindow {
 
 void sync_ui_with_layer(MemeWindow *self);
 void render_meme(MemeWindow *self);
+gboolean meme_window_begin_layer_drag(MemeWindow *self);
+void meme_window_update_layer_drag(MemeWindow *self);
+void meme_window_end_layer_drag(MemeWindow *self);
 void on_clear_clicked(MemeWindow *self);
 void apply_zoom(MemeWindow *self);
 void update_template_image(MemeWindow *self, GdkPixbuf *new_pixbuf);

src/meme-window.c

@@ -37,6 +37,7 @@ void on_clear_clicked (MemeWindow *self) {
     gtk_stack_set_visible_child_name (self->content_stack, "empty");
     g_clear_object (&self->template_image);
     g_clear_object (&self->final_meme);
+    g_clear_object (&self->drag_preview);
     g_clear_object (&self->crop_session_template_snapshot);
     if (self->layers) { meme_layer_list_free (self->layers); self->layers = NULL; }
     free_history_stack (&self->undo_stack); free_history_stack (&self->redo_stack);