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