Merge branch 'blender-v2.91-release'
[blender.git] / source / blender / editors / curve / editcurve_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 edcurve
19  */
20
21 #include "MEM_guardedalloc.h"
22
23 #include "CLG_log.h"
24
25 #include "DNA_anim_types.h"
26 #include "DNA_object_types.h"
27 #include "DNA_scene_types.h"
28
29 #include "BLI_array_utils.h"
30 #include "BLI_blenlib.h"
31 #include "BLI_ghash.h"
32
33 #include "BKE_anim_data.h"
34 #include "BKE_context.h"
35 #include "BKE_curve.h"
36 #include "BKE_fcurve.h"
37 #include "BKE_layer.h"
38 #include "BKE_main.h"
39 #include "BKE_undo_system.h"
40
41 #include "DEG_depsgraph.h"
42
43 #include "ED_curve.h"
44 #include "ED_undo.h"
45
46 #include "WM_api.h"
47 #include "WM_types.h"
48
49 #include "curve_intern.h"
50
51 /** We only need this locally. */
52 static CLG_LogRef LOG = {"ed.undo.curve"};
53
54 /* -------------------------------------------------------------------- */
55 /** \name Undo Conversion
56  * \{ */
57
58 typedef struct {
59   ListBase nubase;
60   int actvert;
61   GHash *undoIndex;
62   ListBase fcurves, drivers;
63   int actnu;
64   int flag;
65
66   /* Stored in the object, needed since users may change the active key while in edit-mode. */
67   struct {
68     short shapenr;
69   } obedit;
70
71   size_t undo_size;
72 } UndoCurve;
73
74 static void undocurve_to_editcurve(Main *bmain, UndoCurve *ucu, Curve *cu, short *r_shapenr)
75 {
76   ListBase *undobase = &ucu->nubase;
77   ListBase *editbase = BKE_curve_editNurbs_get(cu);
78   Nurb *nu, *newnu;
79   EditNurb *editnurb = cu->editnurb;
80   AnimData *ad = BKE_animdata_from_id(&cu->id);
81
82   BKE_nurbList_free(editbase);
83
84   if (ucu->undoIndex) {
85     BKE_curve_editNurb_keyIndex_free(&editnurb->keyindex);
86     editnurb->keyindex = ED_curve_keyindex_hash_duplicate(ucu->undoIndex);
87   }
88
89   if (ad) {
90     if (ad->action) {
91       BKE_fcurves_free(&ad->action->curves);
92       BKE_fcurves_copy(&ad->action->curves, &ucu->fcurves);
93     }
94
95     BKE_fcurves_free(&ad->drivers);
96     BKE_fcurves_copy(&ad->drivers, &ucu->drivers);
97   }
98
99   /* copy  */
100   for (nu = undobase->first; nu; nu = nu->next) {
101     newnu = BKE_nurb_duplicate(nu);
102
103     if (editnurb->keyindex) {
104       ED_curve_keyindex_update_nurb(editnurb, nu, newnu);
105     }
106
107     BLI_addtail(editbase, newnu);
108   }
109
110   cu->actvert = ucu->actvert;
111   cu->actnu = ucu->actnu;
112   cu->flag = ucu->flag;
113   *r_shapenr = ucu->obedit.shapenr;
114   ED_curve_updateAnimPaths(bmain, cu);
115 }
116
117 static void undocurve_from_editcurve(UndoCurve *ucu, Curve *cu, const short shapenr)
118 {
119   BLI_assert(BLI_array_is_zeroed(ucu, 1));
120   ListBase *nubase = BKE_curve_editNurbs_get(cu);
121   EditNurb *editnurb = cu->editnurb, tmpEditnurb;
122   Nurb *nu, *newnu;
123   AnimData *ad = BKE_animdata_from_id(&cu->id);
124
125   /* TODO: include size of fcurve & undoIndex */
126   // ucu->undo_size = 0;
127
128   if (editnurb->keyindex) {
129     ucu->undoIndex = ED_curve_keyindex_hash_duplicate(editnurb->keyindex);
130     tmpEditnurb.keyindex = ucu->undoIndex;
131   }
132
133   if (ad) {
134     if (ad->action) {
135       BKE_fcurves_copy(&ucu->fcurves, &ad->action->curves);
136     }
137
138     BKE_fcurves_copy(&ucu->drivers, &ad->drivers);
139   }
140
141   /* copy  */
142   for (nu = nubase->first; nu; nu = nu->next) {
143     newnu = BKE_nurb_duplicate(nu);
144
145     if (ucu->undoIndex) {
146       ED_curve_keyindex_update_nurb(&tmpEditnurb, nu, newnu);
147     }
148
149     BLI_addtail(&ucu->nubase, newnu);
150
151     ucu->undo_size += ((nu->bezt ? (sizeof(BezTriple) * nu->pntsu) : 0) +
152                        (nu->bp ? (sizeof(BPoint) * (nu->pntsu * nu->pntsv)) : 0) +
153                        (nu->knotsu ? (sizeof(float) * KNOTSU(nu)) : 0) +
154                        (nu->knotsv ? (sizeof(float) * KNOTSV(nu)) : 0) + sizeof(Nurb));
155   }
156
157   ucu->actvert = cu->actvert;
158   ucu->actnu = cu->actnu;
159   ucu->flag = cu->flag;
160
161   ucu->obedit.shapenr = shapenr;
162 }
163
164 static void undocurve_free_data(UndoCurve *uc)
165 {
166   BKE_nurbList_free(&uc->nubase);
167
168   BKE_curve_editNurb_keyIndex_free(&uc->undoIndex);
169
170   BKE_fcurves_free(&uc->fcurves);
171   BKE_fcurves_free(&uc->drivers);
172 }
173
174 static Object *editcurve_object_from_context(bContext *C)
175 {
176   Object *obedit = CTX_data_edit_object(C);
177   if (obedit && ELEM(obedit->type, OB_CURVE, OB_SURF)) {
178     Curve *cu = obedit->data;
179     if (BKE_curve_editNurbs_get(cu) != NULL) {
180       return obedit;
181     }
182   }
183   return NULL;
184 }
185
186 /** \} */
187
188 /* -------------------------------------------------------------------- */
189 /** \name Implements ED Undo System
190  *
191  * \note This is similar for all edit-mode types.
192  * \{ */
193
194 typedef struct CurveUndoStep_Elem {
195   UndoRefID_Object obedit_ref;
196   UndoCurve data;
197 } CurveUndoStep_Elem;
198
199 typedef struct CurveUndoStep {
200   UndoStep step;
201   CurveUndoStep_Elem *elems;
202   uint elems_len;
203 } CurveUndoStep;
204
205 static bool curve_undosys_poll(bContext *C)
206 {
207   Object *obedit = editcurve_object_from_context(C);
208   return (obedit != NULL);
209 }
210
211 static bool curve_undosys_step_encode(struct bContext *C, struct Main *bmain, UndoStep *us_p)
212 {
213   CurveUndoStep *us = (CurveUndoStep *)us_p;
214
215   /* Important not to use the 3D view when getting objects because all objects
216    * outside of this list will be moved out of edit-mode when reading back undo steps. */
217   ViewLayer *view_layer = CTX_data_view_layer(C);
218   uint objects_len = 0;
219   Object **objects = ED_undo_editmode_objects_from_view_layer(view_layer, &objects_len);
220
221   us->elems = MEM_callocN(sizeof(*us->elems) * objects_len, __func__);
222   us->elems_len = objects_len;
223
224   for (uint i = 0; i < objects_len; i++) {
225     Object *ob = objects[i];
226     Curve *cu = ob->data;
227     CurveUndoStep_Elem *elem = &us->elems[i];
228
229     elem->obedit_ref.ptr = ob;
230     undocurve_from_editcurve(&elem->data, ob->data, ob->shapenr);
231     cu->editnurb->needs_flush_to_id = 1;
232     us->step.data_size += elem->data.undo_size;
233   }
234   MEM_freeN(objects);
235
236   bmain->is_memfile_undo_flush_needed = true;
237
238   return true;
239 }
240
241 static void curve_undosys_step_decode(
242     struct bContext *C, struct Main *bmain, UndoStep *us_p, int UNUSED(dir), bool UNUSED(is_final))
243 {
244   CurveUndoStep *us = (CurveUndoStep *)us_p;
245
246   /* Load all our objects  into edit-mode, clear everything else. */
247   ED_undo_object_editmode_restore_helper(
248       C, &us->elems[0].obedit_ref.ptr, us->elems_len, sizeof(*us->elems));
249
250   BLI_assert(curve_undosys_poll(C));
251
252   for (uint i = 0; i < us->elems_len; i++) {
253     CurveUndoStep_Elem *elem = &us->elems[i];
254     Object *obedit = elem->obedit_ref.ptr;
255     Curve *cu = obedit->data;
256     if (cu->editnurb == NULL) {
257       /* Should never fail, may not crash but can give odd behavior. */
258       CLOG_ERROR(&LOG,
259                  "name='%s', failed to enter edit-mode for object '%s', undo state invalid",
260                  us_p->name,
261                  obedit->id.name);
262       continue;
263     }
264     undocurve_to_editcurve(bmain, &elem->data, obedit->data, &obedit->shapenr);
265     cu->editnurb->needs_flush_to_id = 1;
266     DEG_id_tag_update(&obedit->id, ID_RECALC_GEOMETRY);
267   }
268
269   /* The first element is always active */
270   ED_undo_object_set_active_or_warn(
271       CTX_data_view_layer(C), us->elems[0].obedit_ref.ptr, us_p->name, &LOG);
272
273   bmain->is_memfile_undo_flush_needed = true;
274
275   WM_event_add_notifier(C, NC_GEOM | ND_DATA, NULL);
276 }
277
278 static void curve_undosys_step_free(UndoStep *us_p)
279 {
280   CurveUndoStep *us = (CurveUndoStep *)us_p;
281
282   for (uint i = 0; i < us->elems_len; i++) {
283     CurveUndoStep_Elem *elem = &us->elems[i];
284     undocurve_free_data(&elem->data);
285   }
286   MEM_freeN(us->elems);
287 }
288
289 static void curve_undosys_foreach_ID_ref(UndoStep *us_p,
290                                          UndoTypeForEachIDRefFn foreach_ID_ref_fn,
291                                          void *user_data)
292 {
293   CurveUndoStep *us = (CurveUndoStep *)us_p;
294
295   for (uint i = 0; i < us->elems_len; i++) {
296     CurveUndoStep_Elem *elem = &us->elems[i];
297     foreach_ID_ref_fn(user_data, ((UndoRefID *)&elem->obedit_ref));
298   }
299 }
300
301 /* Export for ED_undo_sys. */
302 void ED_curve_undosys_type(UndoType *ut)
303 {
304   ut->name = "Edit Curve";
305   ut->poll = curve_undosys_poll;
306   ut->step_encode = curve_undosys_step_encode;
307   ut->step_decode = curve_undosys_step_decode;
308   ut->step_free = curve_undosys_step_free;
309
310   ut->step_foreach_ID_ref = curve_undosys_foreach_ID_ref;
311
312   ut->use_context = true;
313
314   ut->step_size = sizeof(CurveUndoStep);
315 }
316
317 /** \} */