Cleanup: remove unused arguments
[blender.git] / source / blender / editors / mesh / editmesh_undo.c
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  */
16
17 /** \file
18  * \ingroup edmesh
19  */
20
21 #include "MEM_guardedalloc.h"
22
23 #include "CLG_log.h"
24
25 #include "DNA_mesh_types.h"
26 #include "DNA_meshdata_types.h"
27 #include "DNA_object_types.h"
28 #include "DNA_key_types.h"
29 #include "DNA_layer_types.h"
30
31 #include "BLI_listbase.h"
32 #include "BLI_array_utils.h"
33
34 #include "BKE_context.h"
35 #include "BKE_key.h"
36 #include "BKE_layer.h"
37 #include "BKE_main.h"
38 #include "BKE_mesh.h"
39 #include "BKE_editmesh.h"
40 #include "BKE_undo_system.h"
41
42 #include "DEG_depsgraph.h"
43
44 #include "ED_object.h"
45 #include "ED_mesh.h"
46 #include "ED_util.h"
47 #include "ED_undo.h"
48
49 #include "WM_types.h"
50 #include "WM_api.h"
51
52 #define USE_ARRAY_STORE
53
54 #ifdef USE_ARRAY_STORE
55 // #  define DEBUG_PRINT
56 // #  define DEBUG_TIME
57 #  ifdef DEBUG_TIME
58 #    include "PIL_time_utildefines.h"
59 #  endif
60
61 #  include "BLI_array_store.h"
62 #  include "BLI_array_store_utils.h"
63 /* check on best size later... */
64 #  define ARRAY_CHUNK_SIZE 256
65
66 #  define USE_ARRAY_STORE_THREAD
67 #endif
68
69 #ifdef USE_ARRAY_STORE_THREAD
70 #  include "BLI_task.h"
71 #endif
72
73 /** We only need this locally. */
74 static CLG_LogRef LOG = {"ed.undo.mesh"};
75
76 /* -------------------------------------------------------------------- */
77 /** \name Undo Conversion
78  * \{ */
79
80 #ifdef USE_ARRAY_STORE
81
82 /* Single linked list of layers stored per type */
83 typedef struct BArrayCustomData {
84   struct BArrayCustomData *next;
85   CustomDataType type;
86   int states_len; /* number of layers for each type */
87   BArrayState *states[0];
88 } BArrayCustomData;
89
90 #endif
91
92 typedef struct UndoMesh {
93   Mesh me;
94   int selectmode;
95
96   /** \note
97    * this isn't a prefect solution, if you edit keys and change shapes this works well
98    * (fixing T32442), but editing shape keys, going into object mode, removing or changing their
99    * order, then go back into editmode and undo will give issues - where the old index will be
100    * out of sync with the new object index.
101    *
102    * There are a few ways this could be made to work but for now its a known limitation with mixing
103    * object and editmode operations - Campbell. */
104   int shapenr;
105
106 #ifdef USE_ARRAY_STORE
107   /* NULL arrays are considered empty */
108   struct { /* most data is stored as 'custom' data */
109     BArrayCustomData *vdata, *edata, *ldata, *pdata;
110     BArrayState **keyblocks;
111     BArrayState *mselect;
112   } store;
113 #endif /* USE_ARRAY_STORE */
114
115   size_t undo_size;
116 } UndoMesh;
117
118 #ifdef USE_ARRAY_STORE
119
120 /** \name Array Store
121  * \{ */
122
123 static struct {
124   struct BArrayStore_AtSize bs_stride;
125   int users;
126
127   /* We could have the undo API pass in the previous state, for now store a local list */
128   ListBase local_links;
129
130 #  ifdef USE_ARRAY_STORE_THREAD
131   TaskPool *task_pool;
132 #  endif
133
134 } um_arraystore = {{NULL}};
135
136 static void um_arraystore_cd_compact(struct CustomData *cdata,
137                                      const size_t data_len,
138                                      bool create,
139                                      const BArrayCustomData *bcd_reference,
140                                      BArrayCustomData **r_bcd_first)
141 {
142   if (data_len == 0) {
143     if (create) {
144       *r_bcd_first = NULL;
145     }
146   }
147
148   const BArrayCustomData *bcd_reference_current = bcd_reference;
149   BArrayCustomData *bcd = NULL, *bcd_first = NULL, *bcd_prev = NULL;
150   for (int layer_start = 0, layer_end; layer_start < cdata->totlayer; layer_start = layer_end) {
151     const CustomDataType type = cdata->layers[layer_start].type;
152
153     layer_end = layer_start + 1;
154     while ((layer_end < cdata->totlayer) && (type == cdata->layers[layer_end].type)) {
155       layer_end++;
156     }
157
158     const int stride = CustomData_sizeof(type);
159     BArrayStore *bs = create ? BLI_array_store_at_size_ensure(
160                                    &um_arraystore.bs_stride, stride, ARRAY_CHUNK_SIZE) :
161                                NULL;
162     const int layer_len = layer_end - layer_start;
163
164     if (create) {
165       if (bcd_reference_current && (bcd_reference_current->type == type)) {
166         /* common case, the reference is aligned */
167       }
168       else {
169         bcd_reference_current = NULL;
170
171         /* do a full lookup when un-alligned */
172         if (bcd_reference) {
173           const BArrayCustomData *bcd_iter = bcd_reference;
174           while (bcd_iter) {
175             if (bcd_iter->type == type) {
176               bcd_reference_current = bcd_iter;
177               break;
178             }
179             bcd_iter = bcd_iter->next;
180           }
181         }
182       }
183     }
184
185     if (create) {
186       bcd = MEM_callocN(sizeof(BArrayCustomData) + (layer_len * sizeof(BArrayState *)), __func__);
187       bcd->next = NULL;
188       bcd->type = type;
189       bcd->states_len = layer_end - layer_start;
190
191       if (bcd_prev) {
192         bcd_prev->next = bcd;
193         bcd_prev = bcd;
194       }
195       else {
196         bcd_first = bcd;
197         bcd_prev = bcd;
198       }
199     }
200
201     CustomDataLayer *layer = &cdata->layers[layer_start];
202     for (int i = 0; i < layer_len; i++, layer++) {
203       if (create) {
204         if (layer->data) {
205           BArrayState *state_reference = (bcd_reference_current &&
206                                           i < bcd_reference_current->states_len) ?
207                                              bcd_reference_current->states[i] :
208                                              NULL;
209           bcd->states[i] = BLI_array_store_state_add(
210               bs, layer->data, (size_t)data_len * stride, state_reference);
211         }
212         else {
213           bcd->states[i] = NULL;
214         }
215       }
216
217       if (layer->data) {
218         MEM_freeN(layer->data);
219         layer->data = NULL;
220       }
221     }
222
223     if (create) {
224       if (bcd_reference_current) {
225         bcd_reference_current = bcd_reference_current->next;
226       }
227     }
228   }
229
230   if (create) {
231     *r_bcd_first = bcd_first;
232   }
233 }
234
235 /**
236  * \note There is no room for data going out of sync here.
237  * The layers and the states are stored together so this can be kept working.
238  */
239 static void um_arraystore_cd_expand(const BArrayCustomData *bcd,
240                                     struct CustomData *cdata,
241                                     const size_t data_len)
242 {
243   CustomDataLayer *layer = cdata->layers;
244   while (bcd) {
245     const int stride = CustomData_sizeof(bcd->type);
246     for (int i = 0; i < bcd->states_len; i++) {
247       BLI_assert(bcd->type == layer->type);
248       if (bcd->states[i]) {
249         size_t state_len;
250         layer->data = BLI_array_store_state_data_get_alloc(bcd->states[i], &state_len);
251         BLI_assert(stride * data_len == state_len);
252         UNUSED_VARS_NDEBUG(stride, data_len);
253       }
254       else {
255         layer->data = NULL;
256       }
257       layer++;
258     }
259     bcd = bcd->next;
260   }
261 }
262
263 static void um_arraystore_cd_free(BArrayCustomData *bcd)
264 {
265   while (bcd) {
266     BArrayCustomData *bcd_next = bcd->next;
267     const int stride = CustomData_sizeof(bcd->type);
268     BArrayStore *bs = BLI_array_store_at_size_get(&um_arraystore.bs_stride, stride);
269     for (int i = 0; i < bcd->states_len; i++) {
270       if (bcd->states[i]) {
271         BLI_array_store_state_remove(bs, bcd->states[i]);
272       }
273     }
274     MEM_freeN(bcd);
275     bcd = bcd_next;
276   }
277 }
278
279 /**
280  * \param create: When false, only free the arrays.
281  * This is done since when reading from an undo state, they must be temporarily expanded.
282  * then discarded afterwards, having this argument avoids having 2x code paths.
283  */
284 static void um_arraystore_compact_ex(UndoMesh *um, const UndoMesh *um_ref, bool create)
285 {
286   Mesh *me = &um->me;
287
288   um_arraystore_cd_compact(
289       &me->vdata, me->totvert, create, um_ref ? um_ref->store.vdata : NULL, &um->store.vdata);
290   um_arraystore_cd_compact(
291       &me->edata, me->totedge, create, um_ref ? um_ref->store.edata : NULL, &um->store.edata);
292   um_arraystore_cd_compact(
293       &me->ldata, me->totloop, create, um_ref ? um_ref->store.ldata : NULL, &um->store.ldata);
294   um_arraystore_cd_compact(
295       &me->pdata, me->totpoly, create, um_ref ? um_ref->store.pdata : NULL, &um->store.pdata);
296
297   if (me->key && me->key->totkey) {
298     const size_t stride = me->key->elemsize;
299     BArrayStore *bs = create ? BLI_array_store_at_size_ensure(
300                                    &um_arraystore.bs_stride, stride, ARRAY_CHUNK_SIZE) :
301                                NULL;
302     if (create) {
303       um->store.keyblocks = MEM_mallocN(me->key->totkey * sizeof(*um->store.keyblocks), __func__);
304     }
305     KeyBlock *keyblock = me->key->block.first;
306     for (int i = 0; i < me->key->totkey; i++, keyblock = keyblock->next) {
307       if (create) {
308         BArrayState *state_reference = (um_ref && um_ref->me.key && (i < um_ref->me.key->totkey)) ?
309                                            um_ref->store.keyblocks[i] :
310                                            NULL;
311         um->store.keyblocks[i] = BLI_array_store_state_add(
312             bs, keyblock->data, (size_t)keyblock->totelem * stride, state_reference);
313       }
314
315       if (keyblock->data) {
316         MEM_freeN(keyblock->data);
317         keyblock->data = NULL;
318       }
319     }
320   }
321
322   if (me->mselect && me->totselect) {
323     BLI_assert(create == (um->store.mselect == NULL));
324     if (create) {
325       BArrayState *state_reference = um_ref ? um_ref->store.mselect : NULL;
326       const size_t stride = sizeof(*me->mselect);
327       BArrayStore *bs = BLI_array_store_at_size_ensure(
328           &um_arraystore.bs_stride, stride, ARRAY_CHUNK_SIZE);
329       um->store.mselect = BLI_array_store_state_add(
330           bs, me->mselect, (size_t)me->totselect * stride, state_reference);
331     }
332
333     /* keep me->totselect for validation */
334     MEM_freeN(me->mselect);
335     me->mselect = NULL;
336   }
337
338   if (create) {
339     um_arraystore.users += 1;
340   }
341
342   BKE_mesh_update_customdata_pointers(me, false);
343 }
344
345 /**
346  * Move data from allocated arrays to de-duplicated states and clear arrays.
347  */
348 static void um_arraystore_compact(UndoMesh *um, const UndoMesh *um_ref)
349 {
350   um_arraystore_compact_ex(um, um_ref, true);
351 }
352
353 static void um_arraystore_compact_with_info(UndoMesh *um, const UndoMesh *um_ref)
354 {
355 #  ifdef DEBUG_PRINT
356   size_t size_expanded_prev, size_compacted_prev;
357   BLI_array_store_at_size_calc_memory_usage(
358       &um_arraystore.bs_stride, &size_expanded_prev, &size_compacted_prev);
359 #  endif
360
361 #  ifdef DEBUG_TIME
362   TIMEIT_START(mesh_undo_compact);
363 #  endif
364
365   um_arraystore_compact(um, um_ref);
366
367 #  ifdef DEBUG_TIME
368   TIMEIT_END(mesh_undo_compact);
369 #  endif
370
371 #  ifdef DEBUG_PRINT
372   {
373     size_t size_expanded, size_compacted;
374     BLI_array_store_at_size_calc_memory_usage(
375         &um_arraystore.bs_stride, &size_expanded, &size_compacted);
376
377     const double percent_total = size_expanded ?
378                                      (((double)size_compacted / (double)size_expanded) * 100.0) :
379                                      -1.0;
380
381     size_t size_expanded_step = size_expanded - size_expanded_prev;
382     size_t size_compacted_step = size_compacted - size_compacted_prev;
383     const double percent_step = size_expanded_step ?
384                                     (((double)size_compacted_step / (double)size_expanded_step) *
385                                      100.0) :
386                                     -1.0;
387
388     printf("overall memory use: %.8f%% of expanded size\n", percent_total);
389     printf("step memory use:    %.8f%% of expanded size\n", percent_step);
390   }
391 #  endif
392 }
393
394 #  ifdef USE_ARRAY_STORE_THREAD
395
396 struct UMArrayData {
397   UndoMesh *um;
398   const UndoMesh *um_ref; /* can be NULL */
399 };
400 static void um_arraystore_compact_cb(TaskPool *__restrict UNUSED(pool),
401                                      void *taskdata,
402                                      int UNUSED(threadid))
403 {
404   struct UMArrayData *um_data = taskdata;
405   um_arraystore_compact_with_info(um_data->um, um_data->um_ref);
406 }
407
408 #  endif /* USE_ARRAY_STORE_THREAD */
409
410 /**
411  * Remove data we only expanded for temporary use.
412  */
413 static void um_arraystore_expand_clear(UndoMesh *um)
414 {
415   um_arraystore_compact_ex(um, NULL, false);
416 }
417
418 static void um_arraystore_expand(UndoMesh *um)
419 {
420   Mesh *me = &um->me;
421
422   um_arraystore_cd_expand(um->store.vdata, &me->vdata, me->totvert);
423   um_arraystore_cd_expand(um->store.edata, &me->edata, me->totedge);
424   um_arraystore_cd_expand(um->store.ldata, &me->ldata, me->totloop);
425   um_arraystore_cd_expand(um->store.pdata, &me->pdata, me->totpoly);
426
427   if (um->store.keyblocks) {
428     const size_t stride = me->key->elemsize;
429     KeyBlock *keyblock = me->key->block.first;
430     for (int i = 0; i < me->key->totkey; i++, keyblock = keyblock->next) {
431       BArrayState *state = um->store.keyblocks[i];
432       size_t state_len;
433       keyblock->data = BLI_array_store_state_data_get_alloc(state, &state_len);
434       BLI_assert(keyblock->totelem == (state_len / stride));
435       UNUSED_VARS_NDEBUG(stride);
436     }
437   }
438
439   if (um->store.mselect) {
440     const size_t stride = sizeof(*me->mselect);
441     BArrayState *state = um->store.mselect;
442     size_t state_len;
443     me->mselect = BLI_array_store_state_data_get_alloc(state, &state_len);
444     BLI_assert(me->totselect == (state_len / stride));
445     UNUSED_VARS_NDEBUG(stride);
446   }
447
448   /* not essential, but prevents accidental dangling pointer access */
449   BKE_mesh_update_customdata_pointers(me, false);
450 }
451
452 static void um_arraystore_free(UndoMesh *um)
453 {
454   Mesh *me = &um->me;
455
456   um_arraystore_cd_free(um->store.vdata);
457   um_arraystore_cd_free(um->store.edata);
458   um_arraystore_cd_free(um->store.ldata);
459   um_arraystore_cd_free(um->store.pdata);
460
461   if (um->store.keyblocks) {
462     const size_t stride = me->key->elemsize;
463     BArrayStore *bs = BLI_array_store_at_size_get(&um_arraystore.bs_stride, stride);
464     for (int i = 0; i < me->key->totkey; i++) {
465       BArrayState *state = um->store.keyblocks[i];
466       BLI_array_store_state_remove(bs, state);
467     }
468     MEM_freeN(um->store.keyblocks);
469     um->store.keyblocks = NULL;
470   }
471
472   if (um->store.mselect) {
473     const size_t stride = sizeof(*me->mselect);
474     BArrayStore *bs = BLI_array_store_at_size_get(&um_arraystore.bs_stride, stride);
475     BArrayState *state = um->store.mselect;
476     BLI_array_store_state_remove(bs, state);
477     um->store.mselect = NULL;
478   }
479
480   um_arraystore.users -= 1;
481
482   BLI_assert(um_arraystore.users >= 0);
483
484   if (um_arraystore.users == 0) {
485 #  ifdef DEBUG_PRINT
486     printf("mesh undo store: freeing all data!\n");
487 #  endif
488     BLI_array_store_at_size_clear(&um_arraystore.bs_stride);
489
490 #  ifdef USE_ARRAY_STORE_THREAD
491     BLI_task_pool_free(um_arraystore.task_pool);
492     um_arraystore.task_pool = NULL;
493 #  endif
494   }
495 }
496
497 /** \} */
498
499 #endif /* USE_ARRAY_STORE */
500
501 /* for callbacks */
502 /* undo simply makes copies of a bmesh */
503 static void *undomesh_from_editmesh(UndoMesh *um, BMEditMesh *em, Key *key)
504 {
505   BLI_assert(BLI_array_is_zeroed(um, 1));
506 #ifdef USE_ARRAY_STORE_THREAD
507   /* changes this waits is low, but must have finished */
508   if (um_arraystore.task_pool) {
509     BLI_task_pool_work_and_wait(um_arraystore.task_pool);
510   }
511 #endif
512   /* make sure shape keys work */
513   um->me.key = key ? BKE_key_copy_nolib(key) : NULL;
514
515   /* BM_mesh_validate(em->bm); */ /* for troubleshooting */
516
517   BM_mesh_bm_to_me(
518       NULL,
519       em->bm,
520       &um->me,
521       (&(struct BMeshToMeshParams){
522           /* Undo code should not be manipulating 'G_MAIN->object' hooks/vertex-parent. */
523           .calc_object_remap = false,
524           .update_shapekey_indices = false,
525           .cd_mask_extra = {.vmask = CD_MASK_SHAPE_KEYINDEX},
526       }));
527
528   um->selectmode = em->selectmode;
529   um->shapenr = em->bm->shapenr;
530
531 #ifdef USE_ARRAY_STORE
532   {
533     /* We could be more clever here,
534      * the previous undo state may be from a separate mesh. */
535     const UndoMesh *um_ref = um_arraystore.local_links.last ?
536                                  ((LinkData *)um_arraystore.local_links.last)->data :
537                                  NULL;
538
539     /* add oursrlves */
540     BLI_addtail(&um_arraystore.local_links, BLI_genericNodeN(um));
541
542 #  ifdef USE_ARRAY_STORE_THREAD
543     if (um_arraystore.task_pool == NULL) {
544       TaskScheduler *scheduler = BLI_task_scheduler_get();
545       um_arraystore.task_pool = BLI_task_pool_create_background(scheduler, NULL);
546     }
547
548     struct UMArrayData *um_data = MEM_mallocN(sizeof(*um_data), __func__);
549     um_data->um = um;
550     um_data->um_ref = um_ref;
551
552     BLI_task_pool_push(
553         um_arraystore.task_pool, um_arraystore_compact_cb, um_data, true, TASK_PRIORITY_LOW);
554 #  else
555     um_arraystore_compact_with_info(um, um_ref);
556 #  endif
557   }
558 #endif
559
560   return um;
561 }
562
563 static void undomesh_to_editmesh(UndoMesh *um, BMEditMesh *em, Mesh *obmesh)
564 {
565   BMEditMesh *em_tmp;
566   Object *ob = em->ob;
567   BMesh *bm;
568   Key *key = obmesh->key;
569
570 #ifdef USE_ARRAY_STORE
571 #  ifdef USE_ARRAY_STORE_THREAD
572   /* changes this waits is low, but must have finished */
573   BLI_task_pool_work_and_wait(um_arraystore.task_pool);
574 #  endif
575
576 #  ifdef DEBUG_TIME
577   TIMEIT_START(mesh_undo_expand);
578 #  endif
579
580   um_arraystore_expand(um);
581
582 #  ifdef DEBUG_TIME
583   TIMEIT_END(mesh_undo_expand);
584 #  endif
585 #endif /* USE_ARRAY_STORE */
586
587   const BMAllocTemplate allocsize = BMALLOC_TEMPLATE_FROM_ME(&um->me);
588
589   em->bm->shapenr = um->shapenr;
590
591   EDBM_mesh_free(em);
592
593   bm = BM_mesh_create(&allocsize,
594                       &((struct BMeshCreateParams){
595                           .use_toolflags = true,
596                       }));
597
598   BM_mesh_bm_from_me(bm,
599                      &um->me,
600                      (&(struct BMeshFromMeshParams){
601                          .calc_face_normal = true,
602                          .active_shapekey = um->shapenr,
603                      }));
604
605   em_tmp = BKE_editmesh_create(bm, true);
606   *em = *em_tmp;
607
608   em->selectmode = um->selectmode;
609   bm->selectmode = um->selectmode;
610   em->ob = ob;
611
612   bm->spacearr_dirty = BM_SPACEARR_DIRTY_ALL;
613
614   /* T35170: Restore the active key on the RealMesh. Otherwise 'fake' offset propagation happens
615    *         if the active is a basis for any other. */
616   if (key && (key->type == KEY_RELATIVE)) {
617     /* Since we can't add, remove or reorder keyblocks in editmode, it's safe to assume
618      * shapenr from restored bmesh and keyblock indices are in sync. */
619     const int kb_act_idx = ob->shapenr - 1;
620
621     /* If it is, let's patch the current mesh key block to its restored value.
622      * Else, the offsets won't be computed and it won't matter. */
623     if (BKE_keyblock_is_basis(key, kb_act_idx)) {
624       KeyBlock *kb_act = BLI_findlink(&key->block, kb_act_idx);
625
626       if (kb_act->totelem != um->me.totvert) {
627         /* The current mesh has some extra/missing verts compared to the undo, adjust. */
628         MEM_SAFE_FREE(kb_act->data);
629         kb_act->data = MEM_mallocN((size_t)(key->elemsize * bm->totvert), __func__);
630         kb_act->totelem = um->me.totvert;
631       }
632
633       BKE_keyblock_update_from_mesh(&um->me, kb_act);
634     }
635   }
636
637   ob->shapenr = um->shapenr;
638
639   MEM_freeN(em_tmp);
640
641 #ifdef USE_ARRAY_STORE
642   um_arraystore_expand_clear(um);
643 #endif
644 }
645
646 static void undomesh_free_data(UndoMesh *um)
647 {
648   Mesh *me = &um->me;
649
650 #ifdef USE_ARRAY_STORE
651
652 #  ifdef USE_ARRAY_STORE_THREAD
653   /* changes this waits is low, but must have finished */
654   BLI_task_pool_work_and_wait(um_arraystore.task_pool);
655 #  endif
656
657   /* we need to expand so any allocations in custom-data are freed with the mesh */
658   um_arraystore_expand(um);
659
660   {
661     LinkData *link = BLI_findptr(&um_arraystore.local_links, um, offsetof(LinkData, data));
662     BLI_remlink(&um_arraystore.local_links, link);
663     MEM_freeN(link);
664   }
665   um_arraystore_free(um);
666 #endif
667
668   if (me->key) {
669     BKE_key_free(me->key);
670     MEM_freeN(me->key);
671   }
672
673   BKE_mesh_free(me);
674 }
675
676 static Object *editmesh_object_from_context(bContext *C)
677 {
678   Object *obedit = CTX_data_edit_object(C);
679   if (obedit && obedit->type == OB_MESH) {
680     Mesh *me = obedit->data;
681     if (me->edit_mesh != NULL) {
682       return obedit;
683     }
684   }
685   return NULL;
686 }
687
688 /** \} */
689
690 /* -------------------------------------------------------------------- */
691 /** \name Implements ED Undo System
692  *
693  * \note This is similar for all edit-mode types.
694  * \{ */
695
696 typedef struct MeshUndoStep_Elem {
697   struct MeshUndoStep_Elem *next, *prev;
698   UndoRefID_Object obedit_ref;
699   UndoMesh data;
700 } MeshUndoStep_Elem;
701
702 typedef struct MeshUndoStep {
703   UndoStep step;
704   MeshUndoStep_Elem *elems;
705   uint elems_len;
706 } MeshUndoStep;
707
708 static bool mesh_undosys_poll(bContext *C)
709 {
710   return editmesh_object_from_context(C) != NULL;
711 }
712
713 static bool mesh_undosys_step_encode(struct bContext *C, struct Main *bmain, UndoStep *us_p)
714 {
715   MeshUndoStep *us = (MeshUndoStep *)us_p;
716
717   /* Important not to use the 3D view when getting objects because all objects
718    * outside of this list will be moved out of edit-mode when reading back undo steps. */
719   ViewLayer *view_layer = CTX_data_view_layer(C);
720   uint objects_len = 0;
721   Object **objects = BKE_view_layer_array_from_objects_in_edit_mode_unique_data(
722       view_layer, NULL, &objects_len);
723
724   us->elems = MEM_callocN(sizeof(*us->elems) * objects_len, __func__);
725   us->elems_len = objects_len;
726
727   for (uint i = 0; i < objects_len; i++) {
728     Object *ob = objects[i];
729     MeshUndoStep_Elem *elem = &us->elems[i];
730
731     elem->obedit_ref.ptr = ob;
732     Mesh *me = elem->obedit_ref.ptr->data;
733     BMEditMesh *em = me->edit_mesh;
734     undomesh_from_editmesh(&elem->data, me->edit_mesh, me->key);
735     em->needs_flush_to_id = 1;
736     us->step.data_size += elem->data.undo_size;
737   }
738   MEM_freeN(objects);
739
740   bmain->is_memfile_undo_flush_needed = true;
741
742   return true;
743 }
744
745 static void mesh_undosys_step_decode(
746     struct bContext *C, struct Main *bmain, UndoStep *us_p, int UNUSED(dir), bool UNUSED(is_final))
747 {
748   MeshUndoStep *us = (MeshUndoStep *)us_p;
749
750   /* Load all our objects  into edit-mode, clear everything else. */
751   ED_undo_object_editmode_restore_helper(
752       C, &us->elems[0].obedit_ref.ptr, us->elems_len, sizeof(*us->elems));
753
754   BLI_assert(mesh_undosys_poll(C));
755
756   for (uint i = 0; i < us->elems_len; i++) {
757     MeshUndoStep_Elem *elem = &us->elems[i];
758     Object *obedit = elem->obedit_ref.ptr;
759     Mesh *me = obedit->data;
760     if (me->edit_mesh == NULL) {
761       /* Should never fail, may not crash but can give odd behavior. */
762       CLOG_ERROR(&LOG,
763                  "name='%s', failed to enter edit-mode for object '%s', undo state invalid",
764                  us_p->name,
765                  obedit->id.name);
766       continue;
767     }
768     BMEditMesh *em = me->edit_mesh;
769     undomesh_to_editmesh(&elem->data, em, obedit->data);
770     em->needs_flush_to_id = 1;
771     DEG_id_tag_update(&obedit->id, ID_RECALC_GEOMETRY);
772   }
773
774   /* The first element is always active */
775   ED_undo_object_set_active_or_warn(
776       CTX_data_view_layer(C), us->elems[0].obedit_ref.ptr, us_p->name, &LOG);
777
778   Scene *scene = CTX_data_scene(C);
779   scene->toolsettings->selectmode = us->elems[0].data.selectmode;
780
781   bmain->is_memfile_undo_flush_needed = true;
782
783   WM_event_add_notifier(C, NC_GEOM | ND_DATA, NULL);
784 }
785
786 static void mesh_undosys_step_free(UndoStep *us_p)
787 {
788   MeshUndoStep *us = (MeshUndoStep *)us_p;
789
790   for (uint i = 0; i < us->elems_len; i++) {
791     MeshUndoStep_Elem *elem = &us->elems[i];
792     undomesh_free_data(&elem->data);
793   }
794   MEM_freeN(us->elems);
795 }
796
797 static void mesh_undosys_foreach_ID_ref(UndoStep *us_p,
798                                         UndoTypeForEachIDRefFn foreach_ID_ref_fn,
799                                         void *user_data)
800 {
801   MeshUndoStep *us = (MeshUndoStep *)us_p;
802
803   for (uint i = 0; i < us->elems_len; i++) {
804     MeshUndoStep_Elem *elem = &us->elems[i];
805     foreach_ID_ref_fn(user_data, ((UndoRefID *)&elem->obedit_ref));
806   }
807 }
808
809 /* Export for ED_undo_sys. */
810 void ED_mesh_undosys_type(UndoType *ut)
811 {
812   ut->name = "Edit Mesh";
813   ut->poll = mesh_undosys_poll;
814   ut->step_encode = mesh_undosys_step_encode;
815   ut->step_decode = mesh_undosys_step_decode;
816   ut->step_free = mesh_undosys_step_free;
817
818   ut->step_foreach_ID_ref = mesh_undosys_foreach_ID_ref;
819
820   ut->use_context = true;
821
822   ut->step_size = sizeof(MeshUndoStep);
823 }
824
825 /** \} */