Blender  V3.3
editlattice_undo.c
Go to the documentation of this file.
1 /* SPDX-License-Identifier: GPL-2.0-or-later
2  * Copyright 2001-2002 NaN Holding BV. All rights reserved. */
3 
8 #include <math.h>
9 #include <stdlib.h>
10 #include <string.h>
11 
12 #include "MEM_guardedalloc.h"
13 
14 #include "CLG_log.h"
15 
16 #include "BLI_array_utils.h"
17 #include "BLI_utildefines.h"
18 
19 #include "DNA_curve_types.h"
20 #include "DNA_lattice_types.h"
21 #include "DNA_meshdata_types.h"
22 #include "DNA_object_types.h"
23 #include "DNA_scene_types.h"
24 
25 #include "BKE_context.h"
26 #include "BKE_deform.h"
27 #include "BKE_layer.h"
28 #include "BKE_main.h"
29 #include "BKE_object.h"
30 #include "BKE_undo_system.h"
31 
32 #include "DEG_depsgraph.h"
33 
34 #include "ED_lattice.h"
35 #include "ED_object.h"
36 #include "ED_undo.h"
37 #include "ED_util.h"
38 
39 #include "WM_api.h"
40 #include "WM_types.h"
41 
42 #include "lattice_intern.h"
43 
45 static CLG_LogRef LOG = {"ed.undo.lattice"};
46 
47 /* -------------------------------------------------------------------- */
51 /* TODO(Campbell): this could contain an entire 'Lattice' struct. */
52 typedef struct UndoLattice {
55  char typeu, typev, typew;
56  float fu, fv, fw;
57  float du, dv, dw;
59  size_t undo_size;
61 
62 static void undolatt_to_editlatt(UndoLattice *ult, EditLatt *editlatt)
63 {
64  const int len_src = ult->pntsu * ult->pntsv * ult->pntsw;
65  const int len_dst = editlatt->latt->pntsu * editlatt->latt->pntsv * editlatt->latt->pntsw;
66  if (len_src != len_dst) {
67  MEM_freeN(editlatt->latt->def);
68  editlatt->latt->def = MEM_dupallocN(ult->def);
69  }
70  else {
71  memcpy(editlatt->latt->def, ult->def, sizeof(BPoint) * len_src);
72  }
73 
74  /* Even for the same amount of points we dont just copy memory for MDeformVert, relations to
75  * MDeformWeight might have changed. */
76  if (editlatt->latt->dvert && ult->dvert) {
77  BKE_defvert_array_free(editlatt->latt->dvert, len_dst);
78  editlatt->latt->dvert = MEM_mallocN(sizeof(MDeformVert) * len_src, "Lattice MDeformVert");
79  BKE_defvert_array_copy(editlatt->latt->dvert, ult->dvert, len_src);
80  }
81 
82  editlatt->latt->pntsu = ult->pntsu;
83  editlatt->latt->pntsv = ult->pntsv;
84  editlatt->latt->pntsw = ult->pntsw;
85  editlatt->latt->actbp = ult->actbp;
86 
87  editlatt->latt->typeu = ult->typeu;
88  editlatt->latt->typev = ult->typev;
89  editlatt->latt->typew = ult->typew;
90 
91  editlatt->latt->fu = ult->fu;
92  editlatt->latt->fv = ult->fv;
93  editlatt->latt->fw = ult->fw;
94  editlatt->latt->du = ult->du;
95  editlatt->latt->dv = ult->dv;
96  editlatt->latt->dw = ult->dw;
97 }
98 
99 static void *undolatt_from_editlatt(UndoLattice *ult, EditLatt *editlatt)
100 {
102 
103  ult->def = MEM_dupallocN(editlatt->latt->def);
104  ult->pntsu = editlatt->latt->pntsu;
105  ult->pntsv = editlatt->latt->pntsv;
106  ult->pntsw = editlatt->latt->pntsw;
107  ult->actbp = editlatt->latt->actbp;
108 
109  ult->typeu = editlatt->latt->typeu;
110  ult->typev = editlatt->latt->typev;
111  ult->typew = editlatt->latt->typew;
112 
113  ult->fu = editlatt->latt->fu;
114  ult->fv = editlatt->latt->fv;
115  ult->fw = editlatt->latt->fw;
116  ult->du = editlatt->latt->du;
117  ult->dv = editlatt->latt->dv;
118  ult->dw = editlatt->latt->dw;
119 
120  if (editlatt->latt->dvert) {
121  const int tot = ult->pntsu * ult->pntsv * ult->pntsw;
122  ult->dvert = MEM_mallocN(sizeof(MDeformVert) * tot, "Undo Lattice MDeformVert");
123  BKE_defvert_array_copy(ult->dvert, editlatt->latt->dvert, tot);
124  ult->undo_size += sizeof(*ult->dvert) * tot;
125  }
126 
127  ult->undo_size += sizeof(*ult->def) * ult->pntsu * ult->pntsv * ult->pntsw;
128 
129  return ult;
130 }
131 
133 {
134  if (ult->def) {
135  MEM_freeN(ult->def);
136  }
137  if (ult->dvert) {
138  BKE_defvert_array_free(ult->dvert, ult->pntsu * ult->pntsv * ult->pntsw);
139  ult->dvert = NULL;
140  }
141 }
142 
143 #if 0
144 static int validate_undoLatt(void *data, void *edata)
145 {
146  UndoLattice *ult = (UndoLattice *)data;
147  EditLatt *editlatt = (EditLatt *)edata;
148 
149  return (ult->pntsu == editlatt->latt->pntsu && ult->pntsv == editlatt->latt->pntsv &&
150  ult->pntsw == editlatt->latt->pntsw);
151 }
152 #endif
153 
155 {
156  ViewLayer *view_layer = CTX_data_view_layer(C);
157  Object *obedit = OBEDIT_FROM_VIEW_LAYER(view_layer);
158  if (obedit && obedit->type == OB_LATTICE) {
159  Lattice *lt = obedit->data;
160  if (lt->editlatt != NULL) {
161  return obedit;
162  }
163  }
164 
165  return NULL;
166 }
167 
170 /* -------------------------------------------------------------------- */
176 typedef struct LatticeUndoStep_Elem {
177  UndoRefID_Object obedit_ref;
180 
181 typedef struct LatticeUndoStep {
186 
188 {
190 }
191 
192 static bool lattice_undosys_step_encode(struct bContext *C, Main *bmain, UndoStep *us_p)
193 {
194  LatticeUndoStep *us = (LatticeUndoStep *)us_p;
195 
196  /* Important not to use the 3D view when getting objects because all objects
197  * outside of this list will be moved out of edit-mode when reading back undo steps. */
198  ViewLayer *view_layer = CTX_data_view_layer(C);
199  uint objects_len = 0;
200  Object **objects = ED_undo_editmode_objects_from_view_layer(view_layer, &objects_len);
201 
202  us->elems = MEM_callocN(sizeof(*us->elems) * objects_len, __func__);
203  us->elems_len = objects_len;
204 
205  for (uint i = 0; i < objects_len; i++) {
206  Object *ob = objects[i];
207  LatticeUndoStep_Elem *elem = &us->elems[i];
208 
209  elem->obedit_ref.ptr = ob;
210  Lattice *lt = ob->data;
211  undolatt_from_editlatt(&elem->data, lt->editlatt);
212  lt->editlatt->needs_flush_to_id = 1;
213  us->step.data_size += elem->data.undo_size;
214  }
215  MEM_freeN(objects);
216 
217  bmain->is_memfile_undo_flush_needed = true;
218 
219  return true;
220 }
221 
223  struct Main *bmain,
224  UndoStep *us_p,
225  const eUndoStepDir UNUSED(dir),
226  bool UNUSED(is_final))
227 {
228  LatticeUndoStep *us = (LatticeUndoStep *)us_p;
229 
231  C, &us->elems[0].obedit_ref.ptr, us->elems_len, sizeof(*us->elems));
232 
234 
235  for (uint i = 0; i < us->elems_len; i++) {
236  LatticeUndoStep_Elem *elem = &us->elems[i];
237  Object *obedit = elem->obedit_ref.ptr;
238  Lattice *lt = obedit->data;
239  if (lt->editlatt == NULL) {
240  /* Should never fail, may not crash but can give odd behavior. */
241  CLOG_ERROR(&LOG,
242  "name='%s', failed to enter edit-mode for object '%s', undo state invalid",
243  us_p->name,
244  obedit->id.name);
245  continue;
246  }
247  undolatt_to_editlatt(&elem->data, lt->editlatt);
248  lt->editlatt->needs_flush_to_id = 1;
250  }
251 
252  /* The first element is always active */
254  CTX_data_scene(C), CTX_data_view_layer(C), us->elems[0].obedit_ref.ptr, us_p->name, &LOG);
255 
256  /* Check after setting active. */
258 
259  bmain->is_memfile_undo_flush_needed = true;
260 
262 }
263 
265 {
266  LatticeUndoStep *us = (LatticeUndoStep *)us_p;
267 
268  for (uint i = 0; i < us->elems_len; i++) {
269  LatticeUndoStep_Elem *elem = &us->elems[i];
270  undolatt_free_data(&elem->data);
271  }
272  MEM_freeN(us->elems);
273 }
274 
276  UndoTypeForEachIDRefFn foreach_ID_ref_fn,
277  void *user_data)
278 {
279  LatticeUndoStep *us = (LatticeUndoStep *)us_p;
280 
281  for (uint i = 0; i < us->elems_len; i++) {
282  LatticeUndoStep_Elem *elem = &us->elems[i];
283  foreach_ID_ref_fn(user_data, ((UndoRefID *)&elem->obedit_ref));
284  }
285 }
286 
288 {
289  ut->name = "Edit Lattice";
294 
296 
298 
299  ut->step_size = sizeof(LatticeUndoStep);
300 }
301 
struct Scene * CTX_data_scene(const bContext *C)
Definition: context.c:1090
struct ViewLayer * CTX_data_view_layer(const bContext *C)
Definition: context.c:1100
support for deformation groups and hooks.
void BKE_defvert_array_free(struct MDeformVert *dvert, int totvert)
Definition: deform.c:996
void BKE_defvert_array_copy(struct MDeformVert *dst, const struct MDeformVert *src, int totvert)
General operations, lookup, etc. for blender objects.
bool BKE_object_is_in_editmode(const struct Object *ob)
@ UNDOTYPE_FLAG_NEED_CONTEXT_FOR_ENCODE
eUndoStepDir
void(* UndoTypeForEachIDRefFn)(void *user_data, struct UndoRefID *id_ref)
Generic array manipulation API.
#define BLI_array_is_zeroed(arr, arr_len)
#define BLI_assert(a)
Definition: BLI_assert.h:46
unsigned int uint
Definition: BLI_sys_types.h:67
#define UNUSED(x)
#define CLOG_ERROR(clg_ref,...)
Definition: CLG_log.h:190
void DEG_id_tag_update(struct ID *id, int flag)
@ ID_RECALC_GEOMETRY
Definition: DNA_ID.h:791
Object is a sort of wrapper for general info.
@ OB_LATTICE
#define OBEDIT_FROM_VIEW_LAYER(view_layer)
void ED_undo_object_editmode_restore_helper(struct bContext *C, struct Object **object_array, uint object_array_len, uint object_array_stride)
Definition: ed_undo.c:817
void ED_undo_object_set_active_or_warn(struct Scene *scene, struct ViewLayer *view_layer, struct Object *ob, const char *info, struct CLG_LogRef *log)
Definition: ed_undo.c:800
struct Object ** ED_undo_editmode_objects_from_view_layer(struct ViewLayer *view_layer, uint *r_len)
Definition: ed_undo.c:888
Read Guarded memory(de)allocation.
#define C
Definition: RandGen.cpp:25
#define NC_GEOM
Definition: WM_types.h:343
#define ND_DATA
Definition: WM_types.h:456
void * user_data
struct LatticeUndoStep_Elem LatticeUndoStep_Elem
static void undolatt_to_editlatt(UndoLattice *ult, EditLatt *editlatt)
static bool lattice_undosys_poll(bContext *C)
static bool lattice_undosys_step_encode(struct bContext *C, Main *bmain, UndoStep *us_p)
static void lattice_undosys_step_free(UndoStep *us_p)
struct UndoLattice UndoLattice
void ED_lattice_undosys_type(UndoType *ut)
static void * undolatt_from_editlatt(UndoLattice *ult, EditLatt *editlatt)
static void undolatt_free_data(UndoLattice *ult)
static void lattice_undosys_foreach_ID_ref(UndoStep *us_p, UndoTypeForEachIDRefFn foreach_ID_ref_fn, void *user_data)
struct LatticeUndoStep LatticeUndoStep
static CLG_LogRef LOG
static Object * editlatt_object_from_context(bContext *C)
static void lattice_undosys_step_decode(struct bContext *C, struct Main *bmain, UndoStep *us_p, const eUndoStepDir UNUSED(dir), bool UNUSED(is_final))
void(* MEM_freeN)(void *vmemh)
Definition: mallocn.c:27
void *(* MEM_dupallocN)(const void *vmemh)
Definition: mallocn.c:28
void *(* MEM_callocN)(size_t len, const char *str)
Definition: mallocn.c:31
void *(* MEM_mallocN)(size_t len, const char *str)
Definition: mallocn.c:33
char needs_flush_to_id
struct Lattice * latt
char name[66]
Definition: DNA_ID.h:378
UndoRefID_Object obedit_ref
LatticeUndoStep_Elem * elems
struct MDeformVert * dvert
struct EditLatt * editlatt
struct BPoint * def
Definition: BKE_main.h:121
char is_memfile_undo_flush_needed
Definition: BKE_main.h:145
void * data
MDeformVert * dvert
size_t data_size
char name[64]
size_t step_size
void(* step_decode)(struct bContext *C, struct Main *bmain, UndoStep *us, eUndoStepDir dir, bool is_final)
bool(* step_encode)(struct bContext *C, struct Main *bmain, UndoStep *us)
void(* step_foreach_ID_ref)(UndoStep *us, UndoTypeForEachIDRefFn foreach_ID_ref_fn, void *user_data)
const char * name
void(* step_free)(UndoStep *us)
bool(* poll)(struct bContext *C)
void WM_event_add_notifier(const bContext *C, uint type, void *reference)