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