CMake: add WITH_LINKER_LLD option for unix platforms
[blender-staging.git] / source / blender / editors / armature / editarmature_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  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
17  * All rights reserved.
18  */
19
20 /** \file
21  * \ingroup edarmature
22  */
23
24 #include "MEM_guardedalloc.h"
25
26 #include "CLG_log.h"
27
28 #include "DNA_armature_types.h"
29 #include "DNA_object_types.h"
30
31 #include "BLI_array_utils.h"
32 #include "BLI_listbase.h"
33
34 #include "BKE_context.h"
35 #include "BKE_layer.h"
36 #include "BKE_main.h"
37 #include "BKE_undo_system.h"
38
39 #include "DEG_depsgraph.h"
40
41 #include "ED_armature.h"
42 #include "ED_object.h"
43 #include "ED_undo.h"
44 #include "ED_util.h"
45
46 #include "WM_api.h"
47 #include "WM_types.h"
48
49 /** We only need this locally. */
50 static CLG_LogRef LOG = {"ed.undo.armature"};
51
52 /* -------------------------------------------------------------------- */
53 /** \name Undo Conversion
54  * \{ */
55
56 typedef struct UndoArmature {
57   EditBone *act_edbone;
58   ListBase lb;
59   size_t undo_size;
60 } UndoArmature;
61
62 static void undoarm_to_editarm(UndoArmature *uarm, bArmature *arm)
63 {
64   EditBone *ebone;
65
66   ED_armature_ebone_listbase_free(arm->edbo);
67   ED_armature_ebone_listbase_copy(arm->edbo, &uarm->lb);
68
69   /* active bone */
70   if (uarm->act_edbone) {
71     ebone = uarm->act_edbone;
72     arm->act_edbone = ebone->temp.ebone;
73   }
74   else {
75     arm->act_edbone = NULL;
76   }
77
78   ED_armature_ebone_listbase_temp_clear(arm->edbo);
79 }
80
81 static void *undoarm_from_editarm(UndoArmature *uarm, bArmature *arm)
82 {
83   BLI_assert(BLI_array_is_zeroed(uarm, 1));
84
85   /* TODO: include size of ID-properties. */
86   uarm->undo_size = 0;
87
88   ED_armature_ebone_listbase_copy(&uarm->lb, arm->edbo);
89
90   /* active bone */
91   if (arm->act_edbone) {
92     EditBone *ebone = arm->act_edbone;
93     uarm->act_edbone = ebone->temp.ebone;
94   }
95
96   ED_armature_ebone_listbase_temp_clear(&uarm->lb);
97
98   LISTBASE_FOREACH (EditBone *, ebone, &uarm->lb) {
99     uarm->undo_size += sizeof(EditBone);
100   }
101
102   return uarm;
103 }
104
105 static void undoarm_free_data(UndoArmature *uarm)
106 {
107   ED_armature_ebone_listbase_free(&uarm->lb);
108 }
109
110 static Object *editarm_object_from_context(bContext *C)
111 {
112   ViewLayer *view_layer = CTX_data_view_layer(C);
113   Object *obedit = OBEDIT_FROM_VIEW_LAYER(view_layer);
114   if (obedit && obedit->type == OB_ARMATURE) {
115     bArmature *arm = obedit->data;
116     if (arm->edbo != NULL) {
117       return obedit;
118     }
119   }
120   return NULL;
121 }
122
123 /** \} */
124
125 /* -------------------------------------------------------------------- */
126 /** \name Implements ED Undo System
127  *
128  * \note This is similar for all edit-mode types.
129  * \{ */
130
131 typedef struct ArmatureUndoStep_Elem {
132   struct ArmatureUndoStep_Elem *next, *prev;
133   UndoRefID_Object obedit_ref;
134   UndoArmature data;
135 } ArmatureUndoStep_Elem;
136
137 typedef struct ArmatureUndoStep {
138   UndoStep step;
139   ArmatureUndoStep_Elem *elems;
140   uint elems_len;
141 } ArmatureUndoStep;
142
143 static bool armature_undosys_poll(bContext *C)
144 {
145   return editarm_object_from_context(C) != NULL;
146 }
147
148 static bool armature_undosys_step_encode(struct bContext *C, struct Main *bmain, UndoStep *us_p)
149 {
150   ArmatureUndoStep *us = (ArmatureUndoStep *)us_p;
151
152   /* Important not to use the 3D view when getting objects because all objects
153    * outside of this list will be moved out of edit-mode when reading back undo steps. */
154   ViewLayer *view_layer = CTX_data_view_layer(C);
155   uint objects_len = 0;
156   Object **objects = ED_undo_editmode_objects_from_view_layer(view_layer, &objects_len);
157
158   us->elems = MEM_callocN(sizeof(*us->elems) * objects_len, __func__);
159   us->elems_len = objects_len;
160
161   for (uint i = 0; i < objects_len; i++) {
162     Object *ob = objects[i];
163     ArmatureUndoStep_Elem *elem = &us->elems[i];
164
165     elem->obedit_ref.ptr = ob;
166     bArmature *arm = elem->obedit_ref.ptr->data;
167     undoarm_from_editarm(&elem->data, arm);
168     arm->needs_flush_to_id = 1;
169     us->step.data_size += elem->data.undo_size;
170   }
171   MEM_freeN(objects);
172
173   bmain->is_memfile_undo_flush_needed = true;
174
175   return true;
176 }
177
178 static void armature_undosys_step_decode(
179     struct bContext *C, struct Main *bmain, UndoStep *us_p, int UNUSED(dir), bool UNUSED(is_final))
180 {
181   ArmatureUndoStep *us = (ArmatureUndoStep *)us_p;
182
183   /* Load all our objects  into edit-mode, clear everything else. */
184   ED_undo_object_editmode_restore_helper(
185       C, &us->elems[0].obedit_ref.ptr, us->elems_len, sizeof(*us->elems));
186
187   BLI_assert(armature_undosys_poll(C));
188
189   for (uint i = 0; i < us->elems_len; i++) {
190     ArmatureUndoStep_Elem *elem = &us->elems[i];
191     Object *obedit = elem->obedit_ref.ptr;
192     bArmature *arm = obedit->data;
193     if (arm->edbo == NULL) {
194       /* Should never fail, may not crash but can give odd behavior. */
195       CLOG_ERROR(&LOG,
196                  "name='%s', failed to enter edit-mode for object '%s', undo state invalid",
197                  us_p->name,
198                  obedit->id.name);
199       continue;
200     }
201     undoarm_to_editarm(&elem->data, arm);
202     arm->needs_flush_to_id = 1;
203     DEG_id_tag_update(&obedit->id, ID_RECALC_GEOMETRY);
204   }
205
206   /* The first element is always active */
207   ED_undo_object_set_active_or_warn(
208       CTX_data_view_layer(C), us->elems[0].obedit_ref.ptr, us_p->name, &LOG);
209
210   bmain->is_memfile_undo_flush_needed = true;
211
212   WM_event_add_notifier(C, NC_GEOM | ND_DATA, NULL);
213 }
214
215 static void armature_undosys_step_free(UndoStep *us_p)
216 {
217   ArmatureUndoStep *us = (ArmatureUndoStep *)us_p;
218
219   for (uint i = 0; i < us->elems_len; i++) {
220     ArmatureUndoStep_Elem *elem = &us->elems[i];
221     undoarm_free_data(&elem->data);
222   }
223   MEM_freeN(us->elems);
224 }
225
226 static void armature_undosys_foreach_ID_ref(UndoStep *us_p,
227                                             UndoTypeForEachIDRefFn foreach_ID_ref_fn,
228                                             void *user_data)
229 {
230   ArmatureUndoStep *us = (ArmatureUndoStep *)us_p;
231
232   for (uint i = 0; i < us->elems_len; i++) {
233     ArmatureUndoStep_Elem *elem = &us->elems[i];
234     foreach_ID_ref_fn(user_data, ((UndoRefID *)&elem->obedit_ref));
235   }
236 }
237
238 /* Export for ED_undo_sys. */
239 void ED_armature_undosys_type(UndoType *ut)
240 {
241   ut->name = "Edit Armature";
242   ut->poll = armature_undosys_poll;
243   ut->step_encode = armature_undosys_step_encode;
244   ut->step_decode = armature_undosys_step_decode;
245   ut->step_free = armature_undosys_step_free;
246
247   ut->step_foreach_ID_ref = armature_undosys_foreach_ID_ref;
248
249   ut->use_context = true;
250
251   ut->step_size = sizeof(ArmatureUndoStep);
252 }
253
254 /** \} */