Image use key to know if it changed

I do that so that I can disable the save menu if the image hasn't been
changed.

This is cleaner than having a 'dirty' attribute I think, but I am a bit
worried this might be a bit slow since it forces us to recompute the key
at each iteration.

If this pose problem in the future I'll remove it.

Author: guillaumechereau

src/camera.c

@@ -150,3 +150,18 @@ void camera_fit_box(camera_t *cam, const float box[4][4])
     // XXX: not the proper way to compute the distance.
     cam->dist = max3(size[0], size[1], size[2]) * 8;
 }
+
+/*
+ * Function: camera_get_key
+ * Return a value that is guarantied to change when the camera change.
+ */
+uint64_t camera_get_key(const camera_t *cam)
+{
+    uint64_t key = 0;
+    key = crc64(key, &cam->name, sizeof(cam->name));
+    key = crc64(key, &cam->ortho, sizeof(cam->ortho));
+    key = crc64(key, &cam->dist, sizeof(cam->dist));
+    key = crc64(key, &cam->rot, sizeof(cam->rot));
+    key = crc64(key, &cam->ofs, sizeof(cam->ofs));
+    return key;
+}

src/formats/gox.c

@@ -537,6 +537,7 @@ int load_from_file(const char *path)
     }
 
     goxel->image->path = strdup(path);
+    goxel->image->saved_key = image_get_key(goxel->image);
     goxel_update_meshes(-1);
     gzclose(in);
 
@@ -582,6 +583,7 @@ static void save_as(const char *path, bool with_preview)
     if (path != goxel->image->path) {
         free(goxel->image->path);
         goxel->image->path = strdup(path);
+        goxel->image->saved_key = image_get_key(goxel->image);
     }
     save_to_file(goxel->image->path, with_preview);
 }

src/goxel.h

@@ -1462,6 +1462,12 @@ void camera_get_ray(const camera_t *camera, const float win[2],
  */
 void camera_fit_box(camera_t *camera, const float box[4][4]);
 
+/*
+ * Function: camera_get_key
+ * Return a value that is guarantied to change when the camera change.
+ */
+uint64_t camera_get_key(const camera_t *camera);
+
 typedef struct history history_t;
 
 typedef struct layer layer_t;
@@ -1489,9 +1495,10 @@ struct image {
     float    box[4][4];
 
     // For saving.
-    char    *path;
-    int     export_width;
-    int     export_height;
+    char     *path;
+    int      export_width;
+    int      export_height;
+    uint64_t saved_key;     // image_get_key() value of saved file.
 
     image_t *history;
     image_t *history_next, *history_prev;
@@ -1509,6 +1516,12 @@ void image_undo(image_t *img);
 void image_redo(image_t *img);
 bool image_layer_can_edit(const image_t *img, const layer_t *layer);
 
+/*
+ * Function: image_get_key
+ * Return a value that is guarantied to change when the image change.
+ */
+uint64_t image_get_key(const image_t *img);
+
 // ##### Procedural rendering ########################
 
 // The possible states of the procedural program.

src/gui.cpp

@@ -1063,11 +1063,11 @@ static int export_menu_action_callback(action_t *a, void *user)
     return 0;
 }
 
-static bool render_menu_item(const char *id, const char *label)
+static bool render_menu_item(const char *id, const char *label, bool enabled)
 {
     const action_t *action = action_get(id);
     assert(action);
-    if (ImGui::MenuItem(label, action->shortcut)) {
+    if (ImGui::MenuItem(label, action->shortcut, false, enabled)) {
         action_exec(action, "");
         return true;
     }
@@ -1081,9 +1081,10 @@ static void render_menu(void)
 
     if (!ImGui::BeginMenuBar()) return;
     if (ImGui::BeginMenu("File")) {
-        render_menu_item("save", "Save");
-        render_menu_item("save_as", "Save as");
-        render_menu_item("open", "Open");
+        render_menu_item("save", "Save",
+                image_get_key(goxel->image) != goxel->image->saved_key);
+        render_menu_item("save_as", "Save as", true);
+        render_menu_item("open", "Open", true);
         if (ImGui::BeginMenu("Import...")) {
             if (ImGui::MenuItem("image plane")) import_image_plane(goxel);
             actions_iter(import_menu_action_callback, NULL);
@@ -1093,16 +1094,16 @@ static void render_menu(void)
             actions_iter(export_menu_action_callback, NULL);
             ImGui::EndMenu();
         }
-        render_menu_item("quit", "Quit");
+        render_menu_item("quit", "Quit", true);
         ImGui::EndMenu();
     }
     if (ImGui::BeginMenu("Edit")) {
         if (ImGui::MenuItem("Clear", "Delete"))
             action_exec2("layer_clear", "");
-        render_menu_item("undo", "Undo");
-        render_menu_item("redo", "Redo");
-        render_menu_item("copy", "Copy");
-        render_menu_item("past", "Past");
+        render_menu_item("undo", "Undo", true);
+        render_menu_item("redo", "Redo", true);
+        render_menu_item("copy", "Copy", true);
+        render_menu_item("past", "Past", true);
         if (ImGui::MenuItem("Shift Alpha"))
             gui_open_popup("Shift Alpha", 0, NULL, shift_alpha_popup);
         if (ImGui::MenuItem("Settings"))
@@ -1111,11 +1112,11 @@ static void render_menu(void)
         ImGui::EndMenu();
     }
     if (ImGui::BeginMenu("View")) {
-        render_menu_item("view_left", "Left");
-        render_menu_item("view_right", "Right");
-        render_menu_item("view_front", "Front");
-        render_menu_item("view_top", "Top");
-        render_menu_item("view_default", "Default");
+        render_menu_item("view_left", "Left", true);
+        render_menu_item("view_right", "Right", true);
+        render_menu_item("view_front", "Front", true);
+        render_menu_item("view_top", "Top", true);
+        render_menu_item("view_default", "Default", true);
         ImGui::EndMenu();
     }
     if (ImGui::BeginMenu("Help")) {

src/image.c

@@ -134,6 +134,17 @@ static void layer_delete(layer_t *layer)
     free(layer);
 }
 
+static uint64_t layer_get_key(const layer_t *layer)
+{
+    uint64_t key;
+    key = mesh_get_key(layer->mesh);
+    key = crc64(key, &layer->visible, sizeof(layer->visible));
+    key = crc64(key, &layer->name, sizeof(layer->name));
+    key = crc64(key, &layer->box, sizeof(layer->box));
+    key = crc64(key, &layer->mat, sizeof(layer->mat));
+    return key;
+}
+
 image_t *image_new(void)
 {
     layer_t *layer;
@@ -470,6 +481,26 @@ bool image_layer_can_edit(const image_t *img, const layer_t *layer)
     return !layer->base_id && !layer->image;
 }
 
+/*
+ * Function: image_get_key
+ * Return a value that is garantied to change when the image change.
+ */
+uint64_t image_get_key(const image_t *img)
+{
+    uint64_t key = 0, k;
+    layer_t *layer;
+    camera_t *camera;
+    DL_FOREACH(img->layers, layer) {
+        k = layer_get_key(layer);
+        key = crc64(key, &k, sizeof(k));
+    }
+    DL_FOREACH(img->cameras, camera) {
+        k = camera_get_key(camera);
+        key = crc64(key, &k, sizeof(k));
+    }
+    return key;
+}
+
 ACTION_REGISTER(layer_clear,
     .help = "Clear the current layer",
     .cfunc = image_clear_layer,