Cleanup: style, use braces for editors
[blender.git] / source / blender / editors / object / object_shapekey.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 edobj
22  */
23
24 #include <math.h>
25 #include <string.h>
26
27 #ifndef WIN32
28 #  include <unistd.h>
29 #else
30 #  include <io.h>
31 #endif
32
33 #include "MEM_guardedalloc.h"
34
35 #include "BLI_blenlib.h"
36 #include "BLI_math.h"
37 #include "BLI_utildefines.h"
38
39 #include "DNA_curve_types.h"
40 #include "DNA_key_types.h"
41 #include "DNA_lattice_types.h"
42 #include "DNA_mesh_types.h"
43 #include "DNA_meshdata_types.h"
44 #include "DNA_object_types.h"
45
46 #include "BKE_context.h"
47 #include "BKE_curve.h"
48 #include "BKE_key.h"
49 #include "BKE_lattice.h"
50 #include "BKE_main.h"
51 #include "BKE_object.h"
52
53 #include "DEG_depsgraph.h"
54 #include "DEG_depsgraph_build.h"
55
56 #include "BLI_sys_types.h"  // for intptr_t support
57
58 #include "ED_object.h"
59 #include "ED_mesh.h"
60
61 #include "RNA_access.h"
62 #include "RNA_define.h"
63
64 #include "WM_api.h"
65 #include "WM_types.h"
66
67 #include "object_intern.h"
68
69 /*********************** add shape key ***********************/
70
71 static void ED_object_shape_key_add(bContext *C, Object *ob, const bool from_mix)
72 {
73   Main *bmain = CTX_data_main(C);
74   KeyBlock *kb;
75   if ((kb = BKE_object_shapekey_insert(bmain, ob, NULL, from_mix))) {
76     Key *key = BKE_key_from_object(ob);
77     /* for absolute shape keys, new keys may not be added last */
78     ob->shapenr = BLI_findindex(&key->block, kb) + 1;
79
80     WM_event_add_notifier(C, NC_OBJECT | ND_DRAW, ob);
81   }
82 }
83
84 /*********************** remove shape key ***********************/
85
86 static bool object_shapekey_remove(Main *bmain, Object *ob)
87 {
88   KeyBlock *kb;
89   Key *key = BKE_key_from_object(ob);
90
91   if (key == NULL) {
92     return false;
93   }
94
95   kb = BLI_findlink(&key->block, ob->shapenr - 1);
96   if (kb) {
97     return BKE_object_shapekey_remove(bmain, ob, kb);
98   }
99
100   return false;
101 }
102
103 static bool object_shape_key_mirror(
104     bContext *C, Object *ob, int *r_totmirr, int *r_totfail, bool use_topology)
105 {
106   KeyBlock *kb;
107   Key *key;
108   int totmirr = 0, totfail = 0;
109
110   *r_totmirr = *r_totfail = 0;
111
112   key = BKE_key_from_object(ob);
113   if (key == NULL) {
114     return 0;
115   }
116
117   kb = BLI_findlink(&key->block, ob->shapenr - 1);
118
119   if (kb) {
120     char *tag_elem = MEM_callocN(sizeof(char) * kb->totelem, "shape_key_mirror");
121
122     if (ob->type == OB_MESH) {
123       Mesh *me = ob->data;
124       MVert *mv;
125       int i1, i2;
126       float *fp1, *fp2;
127       float tvec[3];
128
129       ED_mesh_mirror_spatial_table(ob, NULL, NULL, NULL, 's');
130
131       for (i1 = 0, mv = me->mvert; i1 < me->totvert; i1++, mv++) {
132         i2 = mesh_get_x_mirror_vert(ob, NULL, i1, use_topology);
133         if (i2 == i1) {
134           fp1 = ((float *)kb->data) + i1 * 3;
135           fp1[0] = -fp1[0];
136           tag_elem[i1] = 1;
137           totmirr++;
138         }
139         else if (i2 != -1) {
140           if (tag_elem[i1] == 0 && tag_elem[i2] == 0) {
141             fp1 = ((float *)kb->data) + i1 * 3;
142             fp2 = ((float *)kb->data) + i2 * 3;
143
144             copy_v3_v3(tvec, fp1);
145             copy_v3_v3(fp1, fp2);
146             copy_v3_v3(fp2, tvec);
147
148             /* flip x axis */
149             fp1[0] = -fp1[0];
150             fp2[0] = -fp2[0];
151             totmirr++;
152           }
153           tag_elem[i1] = tag_elem[i2] = 1;
154         }
155         else {
156           totfail++;
157         }
158       }
159
160       ED_mesh_mirror_spatial_table(ob, NULL, NULL, NULL, 'e');
161     }
162     else if (ob->type == OB_LATTICE) {
163       Lattice *lt = ob->data;
164       int i1, i2;
165       float *fp1, *fp2;
166       int u, v, w;
167       /* half but found up odd value */
168       const int pntsu_half = (lt->pntsu / 2) + (lt->pntsu % 2);
169
170       /* currently editmode isn't supported by mesh so
171        * ignore here for now too */
172
173       /* if (lt->editlatt) lt = lt->editlatt->latt; */
174
175       for (w = 0; w < lt->pntsw; w++) {
176         for (v = 0; v < lt->pntsv; v++) {
177           for (u = 0; u < pntsu_half; u++) {
178             int u_inv = (lt->pntsu - 1) - u;
179             float tvec[3];
180             if (u == u_inv) {
181               i1 = BKE_lattice_index_from_uvw(lt, u, v, w);
182               fp1 = ((float *)kb->data) + i1 * 3;
183               fp1[0] = -fp1[0];
184               totmirr++;
185             }
186             else {
187               i1 = BKE_lattice_index_from_uvw(lt, u, v, w);
188               i2 = BKE_lattice_index_from_uvw(lt, u_inv, v, w);
189
190               fp1 = ((float *)kb->data) + i1 * 3;
191               fp2 = ((float *)kb->data) + i2 * 3;
192
193               copy_v3_v3(tvec, fp1);
194               copy_v3_v3(fp1, fp2);
195               copy_v3_v3(fp2, tvec);
196               fp1[0] = -fp1[0];
197               fp2[0] = -fp2[0];
198               totmirr++;
199             }
200           }
201         }
202       }
203     }
204
205     MEM_freeN(tag_elem);
206   }
207
208   *r_totmirr = totmirr;
209   *r_totfail = totfail;
210
211   DEG_id_tag_update(&ob->id, ID_RECALC_GEOMETRY);
212   WM_event_add_notifier(C, NC_OBJECT | ND_DRAW, ob);
213
214   return 1;
215 }
216
217 /********************** shape key operators *********************/
218
219 static bool shape_key_mode_poll(bContext *C)
220 {
221   Object *ob = ED_object_context(C);
222   ID *data = (ob) ? ob->data : NULL;
223   return (ob && !ID_IS_LINKED(ob) && data && !ID_IS_LINKED(data) && ob->mode != OB_MODE_EDIT);
224 }
225
226 static bool shape_key_mode_exists_poll(bContext *C)
227 {
228   Object *ob = ED_object_context(C);
229   ID *data = (ob) ? ob->data : NULL;
230
231   /* same as shape_key_mode_poll */
232   return (ob && !ID_IS_LINKED(ob) && data && !ID_IS_LINKED(data) && ob->mode != OB_MODE_EDIT) &&
233          /* check a keyblock exists */
234          (BKE_keyblock_from_object(ob) != NULL);
235 }
236
237 static bool shape_key_move_poll(bContext *C)
238 {
239   /* Same as shape_key_mode_exists_poll above, but ensure we have at least two shapes! */
240   Object *ob = ED_object_context(C);
241   ID *data = (ob) ? ob->data : NULL;
242   Key *key = BKE_key_from_object(ob);
243
244   return (ob && !ID_IS_LINKED(ob) && data && !ID_IS_LINKED(data) && ob->mode != OB_MODE_EDIT &&
245           key && key->totkey > 1);
246 }
247
248 static bool shape_key_poll(bContext *C)
249 {
250   Object *ob = ED_object_context(C);
251   ID *data = (ob) ? ob->data : NULL;
252   return (ob && !ID_IS_LINKED(ob) && data && !ID_IS_LINKED(data));
253 }
254
255 static int shape_key_add_exec(bContext *C, wmOperator *op)
256 {
257   Object *ob = ED_object_context(C);
258   const bool from_mix = RNA_boolean_get(op->ptr, "from_mix");
259
260   ED_object_shape_key_add(C, ob, from_mix);
261
262   DEG_id_tag_update(&ob->id, ID_RECALC_GEOMETRY);
263   DEG_relations_tag_update(CTX_data_main(C));
264
265   return OPERATOR_FINISHED;
266 }
267
268 void OBJECT_OT_shape_key_add(wmOperatorType *ot)
269 {
270   /* identifiers */
271   ot->name = "Add Shape Key";
272   ot->idname = "OBJECT_OT_shape_key_add";
273   ot->description = "Add shape key to the object";
274
275   /* api callbacks */
276   ot->poll = shape_key_mode_poll;
277   ot->exec = shape_key_add_exec;
278
279   /* flags */
280   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
281
282   /* properties */
283   RNA_def_boolean(ot->srna,
284                   "from_mix",
285                   true,
286                   "From Mix",
287                   "Create the new shape key from the existing mix of keys");
288 }
289
290 static int shape_key_remove_exec(bContext *C, wmOperator *op)
291 {
292   Main *bmain = CTX_data_main(C);
293   Object *ob = ED_object_context(C);
294   bool changed = false;
295
296   if (RNA_boolean_get(op->ptr, "all")) {
297     changed = BKE_object_shapekey_free(bmain, ob);
298   }
299   else {
300     changed = object_shapekey_remove(bmain, ob);
301   }
302
303   if (changed) {
304     DEG_id_tag_update(&ob->id, ID_RECALC_GEOMETRY);
305     DEG_relations_tag_update(CTX_data_main(C));
306     WM_event_add_notifier(C, NC_OBJECT | ND_DRAW, ob);
307
308     return OPERATOR_FINISHED;
309   }
310   else {
311     return OPERATOR_CANCELLED;
312   }
313 }
314
315 void OBJECT_OT_shape_key_remove(wmOperatorType *ot)
316 {
317   /* identifiers */
318   ot->name = "Remove Shape Key";
319   ot->idname = "OBJECT_OT_shape_key_remove";
320   ot->description = "Remove shape key from the object";
321
322   /* api callbacks */
323   ot->poll = shape_key_mode_exists_poll;
324   ot->exec = shape_key_remove_exec;
325
326   /* flags */
327   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
328
329   /* properties */
330   RNA_def_boolean(ot->srna, "all", 0, "All", "Remove all shape keys");
331 }
332
333 static int shape_key_clear_exec(bContext *C, wmOperator *UNUSED(op))
334 {
335   Object *ob = ED_object_context(C);
336   Key *key = BKE_key_from_object(ob);
337   KeyBlock *kb = BKE_keyblock_from_object(ob);
338
339   if (!key || !kb) {
340     return OPERATOR_CANCELLED;
341   }
342
343   for (kb = key->block.first; kb; kb = kb->next) {
344     kb->curval = 0.0f;
345   }
346
347   DEG_id_tag_update(&ob->id, ID_RECALC_GEOMETRY);
348   WM_event_add_notifier(C, NC_OBJECT | ND_DRAW, ob);
349
350   return OPERATOR_FINISHED;
351 }
352
353 void OBJECT_OT_shape_key_clear(wmOperatorType *ot)
354 {
355   /* identifiers */
356   ot->name = "Clear Shape Keys";
357   ot->description = "Clear weights for all shape keys";
358   ot->idname = "OBJECT_OT_shape_key_clear";
359
360   /* api callbacks */
361   ot->poll = shape_key_poll;
362   ot->exec = shape_key_clear_exec;
363
364   /* flags */
365   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
366 }
367
368 /* starting point and step size could be optional */
369 static int shape_key_retime_exec(bContext *C, wmOperator *UNUSED(op))
370 {
371   Object *ob = ED_object_context(C);
372   Key *key = BKE_key_from_object(ob);
373   KeyBlock *kb = BKE_keyblock_from_object(ob);
374   float cfra = 0.0f;
375
376   if (!key || !kb) {
377     return OPERATOR_CANCELLED;
378   }
379
380   for (kb = key->block.first; kb; kb = kb->next) {
381     kb->pos = cfra;
382     cfra += 0.1f;
383   }
384
385   DEG_id_tag_update(&ob->id, ID_RECALC_GEOMETRY);
386   WM_event_add_notifier(C, NC_OBJECT | ND_DRAW, ob);
387
388   return OPERATOR_FINISHED;
389 }
390
391 void OBJECT_OT_shape_key_retime(wmOperatorType *ot)
392 {
393   /* identifiers */
394   ot->name = "Re-Time Shape Keys";
395   ot->description = "Resets the timing for absolute shape keys";
396   ot->idname = "OBJECT_OT_shape_key_retime";
397
398   /* api callbacks */
399   ot->poll = shape_key_poll;
400   ot->exec = shape_key_retime_exec;
401
402   /* flags */
403   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
404 }
405
406 static int shape_key_mirror_exec(bContext *C, wmOperator *op)
407 {
408   Object *ob = ED_object_context(C);
409   int totmirr = 0, totfail = 0;
410   bool use_topology = RNA_boolean_get(op->ptr, "use_topology");
411
412   if (!object_shape_key_mirror(C, ob, &totmirr, &totfail, use_topology)) {
413     return OPERATOR_CANCELLED;
414   }
415
416   ED_mesh_report_mirror(op, totmirr, totfail);
417
418   return OPERATOR_FINISHED;
419 }
420
421 void OBJECT_OT_shape_key_mirror(wmOperatorType *ot)
422 {
423   /* identifiers */
424   ot->name = "Mirror Shape Key";
425   ot->idname = "OBJECT_OT_shape_key_mirror";
426   ot->description = "Mirror the current shape key along the local X axis";
427
428   /* api callbacks */
429   ot->poll = shape_key_mode_poll;
430   ot->exec = shape_key_mirror_exec;
431
432   /* flags */
433   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
434
435   /* properties */
436   RNA_def_boolean(
437       ot->srna,
438       "use_topology",
439       0,
440       "Topology Mirror",
441       "Use topology based mirroring (for when both sides of mesh have matching, unique topology)");
442 }
443
444 enum {
445   KB_MOVE_TOP = -2,
446   KB_MOVE_UP = -1,
447   KB_MOVE_DOWN = 1,
448   KB_MOVE_BOTTOM = 2,
449 };
450
451 static int shape_key_move_exec(bContext *C, wmOperator *op)
452 {
453   Object *ob = ED_object_context(C);
454
455   Key *key = BKE_key_from_object(ob);
456   const int type = RNA_enum_get(op->ptr, "type");
457   const int totkey = key->totkey;
458   const int act_index = ob->shapenr - 1;
459   int new_index;
460
461   switch (type) {
462     case KB_MOVE_TOP:
463       /* Replace the ref key only if we're at the top already (only for relative keys) */
464       new_index = (ELEM(act_index, 0, 1) || key->type == KEY_NORMAL) ? 0 : 1;
465       break;
466     case KB_MOVE_BOTTOM:
467       new_index = totkey - 1;
468       break;
469     case KB_MOVE_UP:
470     case KB_MOVE_DOWN:
471     default:
472       new_index = (totkey + act_index + type) % totkey;
473       break;
474   }
475
476   if (!BKE_keyblock_move(ob, act_index, new_index)) {
477     return OPERATOR_CANCELLED;
478   }
479
480   DEG_id_tag_update(&ob->id, ID_RECALC_GEOMETRY);
481   WM_event_add_notifier(C, NC_OBJECT | ND_DRAW, ob);
482
483   return OPERATOR_FINISHED;
484 }
485
486 void OBJECT_OT_shape_key_move(wmOperatorType *ot)
487 {
488   static const EnumPropertyItem slot_move[] = {
489       {KB_MOVE_TOP, "TOP", 0, "Top", "Top of the list"},
490       {KB_MOVE_UP, "UP", 0, "Up", ""},
491       {KB_MOVE_DOWN, "DOWN", 0, "Down", ""},
492       {KB_MOVE_BOTTOM, "BOTTOM", 0, "Bottom", "Bottom of the list"},
493       {0, NULL, 0, NULL, NULL}};
494
495   /* identifiers */
496   ot->name = "Move Shape Key";
497   ot->idname = "OBJECT_OT_shape_key_move";
498   ot->description = "Move the active shape key up/down in the list";
499
500   /* api callbacks */
501   ot->poll = shape_key_move_poll;
502   ot->exec = shape_key_move_exec;
503
504   /* flags */
505   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
506
507   RNA_def_enum(ot->srna, "type", slot_move, 0, "Type", "");
508 }