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