083967d5d417c2d92f4ed2ecbb3d02866c39e103
[blender.git] / source / blender / editors / armature / armature_naming.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  * Operators and API's for renaming bones both in and out of Edit Mode
19  */
20
21 /** \file
22  * \ingroup edarmature
23  */
24
25 #include <string.h>
26
27 #include "MEM_guardedalloc.h"
28
29 #include "DNA_armature_types.h"
30 #include "DNA_constraint_types.h"
31 #include "DNA_object_types.h"
32 #include "DNA_gpencil_types.h"
33 #include "DNA_gpencil_modifier_types.h"
34
35 #include "BLI_blenlib.h"
36 #include "BLI_ghash.h"
37 #include "BLI_string_utils.h"
38 #include "BLI_utildefines.h"
39
40 #include "BLT_translation.h"
41
42 #include "BKE_animsys.h"
43 #include "BKE_action.h"
44 #include "BKE_armature.h"
45 #include "BKE_constraint.h"
46 #include "BKE_context.h"
47 #include "BKE_deform.h"
48 #include "BKE_layer.h"
49 #include "BKE_main.h"
50 #include "BKE_modifier.h"
51 #include "BKE_gpencil_modifier.h"
52
53 #include "DEG_depsgraph.h"
54
55 #include "RNA_access.h"
56 #include "RNA_define.h"
57
58 #include "WM_api.h"
59 #include "WM_types.h"
60
61 #include "ED_armature.h"
62 #include "ED_screen.h"
63
64 #include "armature_intern.h"
65
66 /* This file contains functions/API's for renaming bones and/or working with them */
67
68 /* ************************************************** */
69 /* EditBone Names */
70
71 /* note: there's a unique_bone_name() too! */
72 static bool editbone_unique_check(void *arg, const char *name)
73 {
74   struct {
75     ListBase *lb;
76     void *bone;
77   } *data = arg;
78   EditBone *dupli = ED_armature_ebone_find_name(data->lb, name);
79   return dupli && dupli != data->bone;
80 }
81
82 void ED_armature_ebone_unique_name(ListBase *edbo, char *name, EditBone *bone)
83 {
84   struct {
85     ListBase *lb;
86     void *bone;
87   } data;
88   data.lb = edbo;
89   data.bone = bone;
90
91   BLI_uniquename_cb(editbone_unique_check, &data, DATA_("Bone"), '.', name, sizeof(bone->name));
92 }
93
94 /* ************************************************** */
95 /* Bone Renaming - API */
96
97 static bool bone_unique_check(void *arg, const char *name)
98 {
99   return BKE_armature_find_bone_name((bArmature *)arg, name) != NULL;
100 }
101
102 static void unique_bone_name(bArmature *arm, char *name)
103 {
104   BLI_uniquename_cb(
105       bone_unique_check, (void *)arm, DATA_("Bone"), '.', name, sizeof(((Bone *)NULL)->name));
106 }
107
108 /* helper call for armature_bone_rename */
109 static void constraint_bone_name_fix(Object *ob,
110                                      ListBase *conlist,
111                                      const char *oldname,
112                                      const char *newname)
113 {
114   bConstraint *curcon;
115   bConstraintTarget *ct;
116
117   for (curcon = conlist->first; curcon; curcon = curcon->next) {
118     const bConstraintTypeInfo *cti = BKE_constraint_typeinfo_get(curcon);
119     ListBase targets = {NULL, NULL};
120
121     /* constraint targets */
122     if (cti && cti->get_constraint_targets) {
123       cti->get_constraint_targets(curcon, &targets);
124
125       for (ct = targets.first; ct; ct = ct->next) {
126         if (ct->tar == ob) {
127           if (STREQ(ct->subtarget, oldname)) {
128             BLI_strncpy(ct->subtarget, newname, MAXBONENAME);
129           }
130         }
131       }
132
133       if (cti->flush_constraint_targets) {
134         cti->flush_constraint_targets(curcon, &targets, 0);
135       }
136     }
137
138     /* action constraints */
139     if (curcon->type == CONSTRAINT_TYPE_ACTION) {
140       bActionConstraint *actcon = (bActionConstraint *)curcon->data;
141       BKE_action_fix_paths_rename(&ob->id, actcon->act, "pose.bones", oldname, newname, 0, 0, 1);
142     }
143   }
144 }
145
146 /* called by UI for renaming a bone */
147 /* warning: make sure the original bone was not renamed yet! */
148 /* seems messy, but that's what you get with not using pointers but channel names :) */
149 void ED_armature_bone_rename(Main *bmain,
150                              bArmature *arm,
151                              const char *oldnamep,
152                              const char *newnamep)
153 {
154   Object *ob;
155   char newname[MAXBONENAME];
156   char oldname[MAXBONENAME];
157
158   /* names better differ! */
159   if (!STREQLEN(oldnamep, newnamep, MAXBONENAME)) {
160
161     /* we alter newname string... so make copy */
162     BLI_strncpy(newname, newnamep, MAXBONENAME);
163     /* we use oldname for search... so make copy */
164     BLI_strncpy(oldname, oldnamep, MAXBONENAME);
165
166     /* now check if we're in editmode, we need to find the unique name */
167     if (arm->edbo) {
168       EditBone *eBone = ED_armature_ebone_find_name(arm->edbo, oldname);
169
170       if (eBone) {
171         ED_armature_ebone_unique_name(arm->edbo, newname, NULL);
172         BLI_strncpy(eBone->name, newname, MAXBONENAME);
173       }
174       else {
175         return;
176       }
177     }
178     else {
179       Bone *bone = BKE_armature_find_bone_name(arm, oldname);
180
181       if (bone) {
182         unique_bone_name(arm, newname);
183         BLI_strncpy(bone->name, newname, MAXBONENAME);
184       }
185       else {
186         return;
187       }
188     }
189
190     /* force copy on write to update database */
191     DEG_id_tag_update(&arm->id, ID_RECALC_COPY_ON_WRITE);
192
193     /* do entire dbase - objects */
194     for (ob = bmain->objects.first; ob; ob = ob->id.next) {
195       ModifierData *md;
196
197       /* we have the object using the armature */
198       if (arm == ob->data) {
199         Object *cob;
200
201         /* Rename the pose channel, if it exists */
202         if (ob->pose) {
203           bPoseChannel *pchan = BKE_pose_channel_find_name(ob->pose, oldname);
204           if (pchan) {
205             GHash *gh = ob->pose->chanhash;
206
207             /* remove the old hash entry, and replace with the new name */
208             if (gh) {
209               BLI_assert(BLI_ghash_haskey(gh, pchan->name));
210               BLI_ghash_remove(gh, pchan->name, NULL, NULL);
211             }
212
213             BLI_strncpy(pchan->name, newname, MAXBONENAME);
214
215             if (gh) {
216               BLI_ghash_insert(gh, pchan->name, pchan);
217             }
218           }
219
220           BLI_assert(BKE_pose_channels_is_valid(ob->pose) == true);
221         }
222
223         /* Update any object constraints to use the new bone name */
224         for (cob = bmain->objects.first; cob; cob = cob->id.next) {
225           if (cob->constraints.first) {
226             constraint_bone_name_fix(ob, &cob->constraints, oldname, newname);
227           }
228           if (cob->pose) {
229             bPoseChannel *pchan;
230             for (pchan = cob->pose->chanbase.first; pchan; pchan = pchan->next) {
231               constraint_bone_name_fix(ob, &pchan->constraints, oldname, newname);
232             }
233           }
234         }
235       }
236
237       /* See if an object is parented to this armature */
238       if (ob->parent && (ob->parent->data == arm)) {
239         if (ob->partype == PARBONE) {
240           /* bone name in object */
241           if (STREQ(ob->parsubstr, oldname)) {
242             BLI_strncpy(ob->parsubstr, newname, MAXBONENAME);
243           }
244         }
245       }
246
247       if (modifiers_usesArmature(ob, arm)) {
248         bDeformGroup *dg = defgroup_find_name(ob, oldname);
249         if (dg) {
250           BLI_strncpy(dg->name, newname, MAXBONENAME);
251         }
252       }
253
254       /* fix modifiers that might be using this name */
255       for (md = ob->modifiers.first; md; md = md->next) {
256         switch (md->type) {
257           case eModifierType_Hook: {
258             HookModifierData *hmd = (HookModifierData *)md;
259
260             if (hmd->object && (hmd->object->data == arm)) {
261               if (STREQ(hmd->subtarget, oldname)) {
262                 BLI_strncpy(hmd->subtarget, newname, MAXBONENAME);
263               }
264             }
265             break;
266           }
267           case eModifierType_UVWarp: {
268             UVWarpModifierData *umd = (UVWarpModifierData *)md;
269
270             if (umd->object_src && (umd->object_src->data == arm)) {
271               if (STREQ(umd->bone_src, oldname)) {
272                 BLI_strncpy(umd->bone_src, newname, MAXBONENAME);
273               }
274             }
275             if (umd->object_dst && (umd->object_dst->data == arm)) {
276               if (STREQ(umd->bone_dst, oldname)) {
277                 BLI_strncpy(umd->bone_dst, newname, MAXBONENAME);
278               }
279             }
280             break;
281           }
282           default:
283             break;
284         }
285       }
286
287       /* fix grease pencil modifiers and vertex groups */
288       if (ob->type == OB_GPENCIL) {
289
290         bGPdata *gpd = (bGPdata *)ob->data;
291         for (bGPDlayer *gpl = gpd->layers.first; gpl; gpl = gpl->next) {
292           if ((gpl->parent != NULL) && (gpl->parent->data == arm)) {
293             if (STREQ(gpl->parsubstr, oldname)) {
294               BLI_strncpy(gpl->parsubstr, newname, MAXBONENAME);
295             }
296           }
297         }
298
299         for (GpencilModifierData *gp_md = ob->greasepencil_modifiers.first; gp_md;
300              gp_md = gp_md->next) {
301           switch (gp_md->type) {
302             case eGpencilModifierType_Armature: {
303               ArmatureGpencilModifierData *mmd = (ArmatureGpencilModifierData *)gp_md;
304               if (mmd->object && mmd->object->data == arm) {
305                 bDeformGroup *dg = defgroup_find_name(ob, oldname);
306                 if (dg) {
307                   BLI_strncpy(dg->name, newname, MAXBONENAME);
308                 }
309               }
310               break;
311             }
312             case eGpencilModifierType_Hook: {
313               HookGpencilModifierData *hgp_md = (HookGpencilModifierData *)gp_md;
314               if (hgp_md->object && (hgp_md->object->data == arm)) {
315                 if (STREQ(hgp_md->subtarget, oldname)) {
316                   BLI_strncpy(hgp_md->subtarget, newname, MAXBONENAME);
317                 }
318               }
319               break;
320             }
321             default:
322               break;
323           }
324         }
325       }
326       DEG_id_tag_update(&ob->id, ID_RECALC_COPY_ON_WRITE);
327     }
328
329     /* Fix all animdata that may refer to this bone -
330      * we can't just do the ones attached to objects,
331      * since other ID-blocks may have drivers referring to this bone T29822. */
332
333     /* XXX: the ID here is for armatures,
334      * but most bone drivers are actually on the object instead. */
335     {
336
337       BKE_animdata_fix_paths_rename_all(&arm->id, "pose.bones", oldname, newname);
338     }
339
340     /* correct view locking */
341     {
342       bScreen *screen;
343       for (screen = bmain->screens.first; screen; screen = screen->id.next) {
344         ScrArea *sa;
345         /* add regions */
346         for (sa = screen->areabase.first; sa; sa = sa->next) {
347           SpaceLink *sl;
348           for (sl = sa->spacedata.first; sl; sl = sl->next) {
349             if (sl->spacetype == SPACE_VIEW3D) {
350               View3D *v3d = (View3D *)sl;
351               if (v3d->ob_centre && v3d->ob_centre->data == arm) {
352                 if (STREQ(v3d->ob_centre_bone, oldname)) {
353                   BLI_strncpy(v3d->ob_centre_bone, newname, MAXBONENAME);
354                 }
355               }
356             }
357           }
358         }
359       }
360     }
361   }
362 }
363
364 typedef struct BoneFlipNameData {
365   struct BoneFlipNameData *next, *prev;
366   char *name;
367   char name_flip[MAXBONENAME];
368 } BoneFlipNameData;
369
370 /**
371  * Renames (by flipping) all selected bones at once.
372  *
373  * This way if we are flipping related bones (e.g., Bone.L, Bone.R) at the same time
374  * all the bones are safely renamed, without conflicting with each other.
375  *
376  * \param arm: Armature the bones belong to
377  * \param bones_names: List of BoneConflict elems.
378  * \param do_strip_numbers: if set, try to get rid of dot-numbers at end of bone names.
379  */
380 void ED_armature_bones_flip_names(Main *bmain,
381                                   bArmature *arm,
382                                   ListBase *bones_names,
383                                   const bool do_strip_numbers)
384 {
385   ListBase bones_names_conflicts = {NULL};
386   BoneFlipNameData *bfn;
387
388   /* First pass: generate flip names, and blindly rename.
389    * If rename did not yield expected result,
390    * store both bone's name and expected flipped one into temp list for second pass. */
391   for (LinkData *link = bones_names->first; link; link = link->next) {
392     char name_flip[MAXBONENAME];
393     char *name = link->data;
394
395     /* WARNING: if do_strip_numbers is set, expect completely mismatched names in cases like
396      * Bone.R, Bone.R.001, Bone.R.002, etc. */
397     BLI_string_flip_side_name(name_flip, name, do_strip_numbers, sizeof(name_flip));
398
399     ED_armature_bone_rename(bmain, arm, name, name_flip);
400
401     if (!STREQ(name, name_flip)) {
402       bfn = alloca(sizeof(BoneFlipNameData));
403       bfn->name = name;
404       BLI_strncpy(bfn->name_flip, name_flip, sizeof(bfn->name_flip));
405       BLI_addtail(&bones_names_conflicts, bfn);
406     }
407   }
408
409   /* Second pass to handle the bones that have naming conflicts with other bones.
410    * Note that if the other bone was not selected, its name was not flipped,
411    * so conflict remains and that second rename simply generates a new numbered alternative name.
412    */
413   for (bfn = bones_names_conflicts.first; bfn; bfn = bfn->next) {
414     ED_armature_bone_rename(bmain, arm, bfn->name, bfn->name_flip);
415   }
416 }
417
418 /* ************************************************** */
419 /* Bone Renaming - EditMode */
420
421 static int armature_flip_names_exec(bContext *C, wmOperator *op)
422 {
423   Main *bmain = CTX_data_main(C);
424   ViewLayer *view_layer = CTX_data_view_layer(C);
425   Object *ob_active = CTX_data_edit_object(C);
426
427   const bool do_strip_numbers = RNA_boolean_get(op->ptr, "do_strip_numbers");
428
429   uint objects_len = 0;
430   Object **objects = BKE_view_layer_array_from_objects_in_edit_mode_unique_data(
431       view_layer, CTX_wm_view3d(C), &objects_len);
432   for (uint ob_index = 0; ob_index < objects_len; ob_index++) {
433     Object *ob = objects[ob_index];
434     bArmature *arm = ob->data;
435
436     /* Paranoia check. */
437     if (ob_active->pose == NULL) {
438       continue;
439     }
440
441     ListBase bones_names = {NULL};
442
443     for (EditBone *ebone = arm->edbo->first; ebone; ebone = ebone->next) {
444       if (EBONE_VISIBLE(arm, ebone)) {
445         if (ebone->flag & BONE_SELECTED) {
446           BLI_addtail(&bones_names, BLI_genericNodeN(ebone->name));
447
448           if (arm->flag & ARM_MIRROR_EDIT) {
449             EditBone *flipbone = ED_armature_ebone_get_mirrored(arm->edbo, ebone);
450             if ((flipbone) && !(flipbone->flag & BONE_SELECTED)) {
451               BLI_addtail(&bones_names, BLI_genericNodeN(flipbone->name));
452             }
453           }
454         }
455       }
456     }
457
458     if (BLI_listbase_is_empty(&bones_names)) {
459       continue;
460     }
461
462     ED_armature_bones_flip_names(bmain, arm, &bones_names, do_strip_numbers);
463
464     BLI_freelistN(&bones_names);
465
466     /* since we renamed stuff... */
467     DEG_id_tag_update(&ob->id, ID_RECALC_GEOMETRY);
468
469     /* copied from #rna_Bone_update_renamed */
470     /* redraw view */
471     WM_event_add_notifier(C, NC_GEOM | ND_DATA, ob->data);
472
473     /* update animation channels */
474     WM_event_add_notifier(C, NC_ANIMATION | ND_ANIMCHAN, ob->data);
475   }
476   MEM_freeN(objects);
477
478   return OPERATOR_FINISHED;
479 }
480
481 void ARMATURE_OT_flip_names(wmOperatorType *ot)
482 {
483   /* identifiers */
484   ot->name = "Flip Names";
485   ot->idname = "ARMATURE_OT_flip_names";
486   ot->description = "Flips (and corrects) the axis suffixes of the names of selected bones";
487
488   /* api callbacks */
489   ot->exec = armature_flip_names_exec;
490   ot->poll = ED_operator_editarmature;
491
492   /* flags */
493   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
494
495   RNA_def_boolean(ot->srna,
496                   "do_strip_numbers",
497                   false,
498                   "Strip Numbers",
499                   "Try to remove right-most dot-number from flipped names "
500                   "(WARNING: may result in incoherent naming in some cases)");
501 }
502
503 static int armature_autoside_names_exec(bContext *C, wmOperator *op)
504 {
505   ViewLayer *view_layer = CTX_data_view_layer(C);
506   Main *bmain = CTX_data_main(C);
507   char newname[MAXBONENAME];
508   const short axis = RNA_enum_get(op->ptr, "type");
509   bool changed_multi = false;
510
511   uint objects_len = 0;
512   Object **objects = BKE_view_layer_array_from_objects_in_edit_mode_unique_data(
513       view_layer, CTX_wm_view3d(C), &objects_len);
514   for (uint ob_index = 0; ob_index < objects_len; ob_index++) {
515     Object *ob = objects[ob_index];
516     bArmature *arm = ob->data;
517     bool changed = false;
518
519     /* Paranoia checks. */
520     if (ELEM(NULL, ob, ob->pose)) {
521       continue;
522     }
523
524     for (EditBone *ebone = arm->edbo->first; ebone; ebone = ebone->next) {
525       if (EBONE_EDITABLE(ebone)) {
526
527         /* We first need to do the flipped bone, then the original one.
528          * Otherwise we can't find the flipped one because of the bone name change. */
529         if (arm->flag & ARM_MIRROR_EDIT) {
530           EditBone *flipbone = ED_armature_ebone_get_mirrored(arm->edbo, ebone);
531           if ((flipbone) && !(flipbone->flag & BONE_SELECTED)) {
532             BLI_strncpy(newname, flipbone->name, sizeof(newname));
533             if (bone_autoside_name(newname, 1, axis, flipbone->head[axis], flipbone->tail[axis])) {
534               ED_armature_bone_rename(bmain, arm, flipbone->name, newname);
535               changed = true;
536             }
537           }
538         }
539
540         BLI_strncpy(newname, ebone->name, sizeof(newname));
541         if (bone_autoside_name(newname, 1, axis, ebone->head[axis], ebone->tail[axis])) {
542           ED_armature_bone_rename(bmain, arm, ebone->name, newname);
543           changed = true;
544         }
545       }
546     }
547
548     if (!changed) {
549       continue;
550     }
551
552     changed_multi = true;
553
554     /* Since we renamed stuff... */
555     DEG_id_tag_update(&ob->id, ID_RECALC_GEOMETRY);
556
557     /* Note, notifier might evolve. */
558     WM_event_add_notifier(C, NC_OBJECT | ND_POSE, ob);
559   }
560   MEM_freeN(objects);
561   return changed_multi ? OPERATOR_FINISHED : OPERATOR_CANCELLED;
562 }
563
564 void ARMATURE_OT_autoside_names(wmOperatorType *ot)
565 {
566   static const EnumPropertyItem axis_items[] = {
567       {0, "XAXIS", 0, "X-Axis", "Left/Right"},
568       {1, "YAXIS", 0, "Y-Axis", "Front/Back"},
569       {2, "ZAXIS", 0, "Z-Axis", "Top/Bottom"},
570       {0, NULL, 0, NULL, NULL},
571   };
572
573   /* identifiers */
574   ot->name = "AutoName by Axis";
575   ot->idname = "ARMATURE_OT_autoside_names";
576   ot->description =
577       "Automatically renames the selected bones according to which side of the target axis they "
578       "fall on";
579
580   /* api callbacks */
581   ot->invoke = WM_menu_invoke;
582   ot->exec = armature_autoside_names_exec;
583   ot->poll = ED_operator_editarmature;
584
585   /* flags */
586   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
587
588   /* settings */
589   ot->prop = RNA_def_enum(ot->srna, "type", axis_items, 0, "Axis", "Axis tag names with");
590 }