Armature: implement universal hash table lookup of Bone objects by name.
[blender.git] / source / blender / makesrna / intern / rna_armature.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
17 /** \file
18  * \ingroup RNA
19  */
20
21 #include <stdlib.h>
22
23 #include "BLI_math.h"
24
25 #include "RNA_access.h"
26 #include "RNA_define.h"
27
28 #include "rna_internal.h"
29
30 #include "DNA_armature_types.h"
31 #include "DNA_object_types.h"
32 #include "DNA_scene_types.h"
33
34 #include "WM_api.h"
35 #include "WM_types.h"
36
37 #ifdef RNA_RUNTIME
38
39 #  include "BKE_action.h"
40 #  include "BKE_context.h"
41 #  include "BKE_global.h"
42 #  include "BKE_idprop.h"
43 #  include "BKE_main.h"
44
45 #  include "ED_armature.h"
46 #  include "BKE_armature.h"
47
48 #  include "DEG_depsgraph.h"
49 #  include "DEG_depsgraph_build.h"
50
51 static void rna_Armature_update_data(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
52 {
53   ID *id = ptr->id.data;
54
55   DEG_id_tag_update(id, 0);
56   WM_main_add_notifier(NC_GEOM | ND_DATA, id);
57   /*WM_main_add_notifier(NC_OBJECT|ND_POSE, NULL); */
58 }
59
60 static void rna_Armature_dependency_update(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr)
61 {
62   ID *id = ptr->id.data;
63
64   DEG_relations_tag_update(bmain);
65
66   DEG_id_tag_update(id, 0);
67   WM_main_add_notifier(NC_GEOM | ND_DATA, id);
68 }
69
70 static void rna_Armature_act_bone_set(PointerRNA *ptr, PointerRNA value)
71 {
72   bArmature *arm = (bArmature *)ptr->data;
73
74   if (value.id.data == NULL && value.data == NULL) {
75     arm->act_bone = NULL;
76   }
77   else {
78     if (value.id.data != arm) {
79       Object *ob = (Object *)value.id.data;
80
81       if (GS(ob->id.name) != ID_OB || (ob->data != arm)) {
82         printf("ERROR: armature set active bone - new active doesn't come from this armature\n");
83         return;
84       }
85     }
86
87     arm->act_bone = value.data;
88     arm->act_bone->flag |= BONE_SELECTED;
89   }
90 }
91
92 static void rna_Armature_act_edit_bone_set(PointerRNA *ptr, PointerRNA value)
93 {
94   bArmature *arm = (bArmature *)ptr->data;
95
96   if (value.id.data == NULL && value.data == NULL) {
97     arm->act_edbone = NULL;
98   }
99   else {
100     if (value.id.data != arm) {
101       /* raise an error! */
102     }
103     else {
104       arm->act_edbone = value.data;
105       ((EditBone *)arm->act_edbone)->flag |= BONE_SELECTED;
106     }
107   }
108 }
109
110 static EditBone *rna_Armature_edit_bone_new(bArmature *arm, ReportList *reports, const char *name)
111 {
112   if (arm->edbo == NULL) {
113     BKE_reportf(reports,
114                 RPT_ERROR,
115                 "Armature '%s' not in edit mode, cannot add an editbone",
116                 arm->id.name + 2);
117     return NULL;
118   }
119   return ED_armature_ebone_add(arm, name);
120 }
121
122 static void rna_Armature_edit_bone_remove(bArmature *arm,
123                                           ReportList *reports,
124                                           PointerRNA *ebone_ptr)
125 {
126   EditBone *ebone = ebone_ptr->data;
127   if (arm->edbo == NULL) {
128     BKE_reportf(reports,
129                 RPT_ERROR,
130                 "Armature '%s' not in edit mode, cannot remove an editbone",
131                 arm->id.name + 2);
132     return;
133   }
134
135   if (BLI_findindex(arm->edbo, ebone) == -1) {
136     BKE_reportf(reports,
137                 RPT_ERROR,
138                 "Armature '%s' does not contain bone '%s'",
139                 arm->id.name + 2,
140                 ebone->name);
141     return;
142   }
143
144   ED_armature_ebone_remove(arm, ebone);
145   RNA_POINTER_INVALIDATE(ebone_ptr);
146 }
147
148 static void rna_Armature_update_layers(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr)
149 {
150   bArmature *arm = ptr->id.data;
151   Object *ob;
152
153   /* proxy lib exception, store it here so we can restore layers on file
154    * load, since it would otherwise get lost due to being linked data */
155   for (ob = bmain->objects.first; ob; ob = ob->id.next) {
156     if (ob->data == arm && ob->pose)
157       ob->pose->proxy_layer = arm->layer;
158   }
159
160   DEG_id_tag_update(&arm->id, ID_RECALC_COPY_ON_WRITE);
161   WM_main_add_notifier(NC_GEOM | ND_DATA, arm);
162 }
163
164 static void rna_Armature_redraw_data(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
165 {
166   ID *id = ptr->id.data;
167
168   DEG_id_tag_update(id, ID_RECALC_COPY_ON_WRITE);
169   WM_main_add_notifier(NC_GEOM | ND_DATA, id);
170 }
171
172 /* called whenever a bone is renamed */
173 static void rna_Bone_update_renamed(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
174 {
175   ID *id = ptr->id.data;
176
177   /* redraw view */
178   WM_main_add_notifier(NC_GEOM | ND_DATA, id);
179
180   /* update animation channels */
181   WM_main_add_notifier(NC_ANIMATION | ND_ANIMCHAN, id);
182 }
183
184 static void rna_Bone_select_update(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
185 {
186   ID *id = ptr->id.data;
187
188   /* 1) special updates for cases where rigs try to hook into armature drawing stuff
189    *    e.g. Mask Modifier - 'Armature' option
190    * 2) tag armature for copy-on-write, so that selection status (set by addons)
191    *    will update properly, like standard tools do already
192    */
193   if (id) {
194     if (GS(id->name) == ID_AR) {
195       bArmature *arm = (bArmature *)id;
196
197       if (arm->flag & ARM_HAS_VIZ_DEPS) {
198         DEG_id_tag_update(id, ID_RECALC_GEOMETRY);
199       }
200
201       DEG_id_tag_update(id, ID_RECALC_COPY_ON_WRITE);
202     }
203     else if (GS(id->name) == ID_OB) {
204       Object *ob = (Object *)id;
205       bArmature *arm = (bArmature *)ob->data;
206
207       if (arm->flag & ARM_HAS_VIZ_DEPS) {
208         DEG_id_tag_update(id, ID_RECALC_GEOMETRY);
209       }
210
211       DEG_id_tag_update(&arm->id, ID_RECALC_COPY_ON_WRITE);
212     }
213   }
214
215   WM_main_add_notifier(NC_GEOM | ND_DATA, id);
216
217   /* spaces that show animation data of the selected bone need updating */
218   WM_main_add_notifier(NC_ANIMATION | ND_ANIMCHAN, id);
219 }
220
221 static char *rna_Bone_path(PointerRNA *ptr)
222 {
223   ID *id = ptr->id.data;
224   Bone *bone = (Bone *)ptr->data;
225   char name_esc[sizeof(bone->name) * 2];
226
227   BLI_strescape(name_esc, bone->name, sizeof(name_esc));
228
229   /* special exception for trying to get the path where ID-block is Object
230    * - this will be assumed to be from a Pose Bone...
231    */
232   if (id) {
233     if (GS(id->name) == ID_OB) {
234       return BLI_sprintfN("pose.bones[\"%s\"].bone", name_esc);
235     }
236   }
237
238   /* from armature... */
239   return BLI_sprintfN("bones[\"%s\"]", name_esc);
240 }
241
242 static IDProperty *rna_Bone_idprops(PointerRNA *ptr, bool create)
243 {
244   Bone *bone = ptr->data;
245
246   if (create && !bone->prop) {
247     IDPropertyTemplate val = {0};
248     bone->prop = IDP_New(IDP_GROUP, &val, "RNA_Bone ID properties");
249   }
250
251   return bone->prop;
252 }
253
254 static IDProperty *rna_EditBone_idprops(PointerRNA *ptr, bool create)
255 {
256   EditBone *ebone = ptr->data;
257
258   if (create && !ebone->prop) {
259     IDPropertyTemplate val = {0};
260     ebone->prop = IDP_New(IDP_GROUP, &val, "RNA_EditBone ID properties");
261   }
262
263   return ebone->prop;
264 }
265
266 /* Update the layers_used variable after bones are moved between layer
267  * NOTE: Used to be done in drawing code in 2.7, but that won't work with
268  *       Copy-on-Write, as drawing uses evaluated copies.
269  */
270 static void rna_Armature_layer_used_refresh(bArmature *arm, ListBase *bones)
271 {
272   for (Bone *bone = bones->first; bone; bone = bone->next) {
273     arm->layer_used |= bone->layer;
274     rna_Armature_layer_used_refresh(arm, &bone->childbase);
275   }
276 }
277
278 static void rna_bone_layer_set(int *layer, const bool *values)
279 {
280   int i, tot = 0;
281
282   /* ensure we always have some layer selected */
283   for (i = 0; i < 32; i++)
284     if (values[i])
285       tot++;
286
287   if (tot == 0)
288     return;
289
290   for (i = 0; i < 32; i++) {
291     if (values[i])
292       *layer |= (1u << i);
293     else
294       *layer &= ~(1u << i);
295   }
296 }
297
298 static void rna_Bone_layer_set(PointerRNA *ptr, const bool *values)
299 {
300   bArmature *arm = (bArmature *)ptr->id.data;
301   Bone *bone = (Bone *)ptr->data;
302
303   rna_bone_layer_set(&bone->layer, values);
304
305   arm->layer_used = 0;
306   rna_Armature_layer_used_refresh(arm, &arm->bonebase);
307 }
308
309 static void rna_Armature_layer_set(PointerRNA *ptr, const bool *values)
310 {
311   bArmature *arm = (bArmature *)ptr->data;
312   int i, tot = 0;
313
314   /* ensure we always have some layer selected */
315   for (i = 0; i < 32; i++)
316     if (values[i])
317       tot++;
318
319   if (tot == 0)
320     return;
321
322   for (i = 0; i < 32; i++) {
323     if (values[i])
324       arm->layer |= (1u << i);
325     else
326       arm->layer &= ~(1u << i);
327   }
328 }
329
330 static void rna_EditBone_name_set(PointerRNA *ptr, const char *value)
331 {
332   bArmature *arm = (bArmature *)ptr->id.data;
333   EditBone *ebone = (EditBone *)ptr->data;
334   char oldname[sizeof(ebone->name)], newname[sizeof(ebone->name)];
335
336   /* need to be on the stack */
337   BLI_strncpy_utf8(newname, value, sizeof(ebone->name));
338   BLI_strncpy(oldname, ebone->name, sizeof(ebone->name));
339
340   BLI_assert(BKE_id_is_in_global_main(&arm->id));
341   ED_armature_bone_rename(G_MAIN, arm, oldname, newname);
342 }
343
344 static void rna_Bone_name_set(PointerRNA *ptr, const char *value)
345 {
346   bArmature *arm = (bArmature *)ptr->id.data;
347   Bone *bone = (Bone *)ptr->data;
348   char oldname[sizeof(bone->name)], newname[sizeof(bone->name)];
349
350   /* need to be on the stack */
351   BLI_strncpy_utf8(newname, value, sizeof(bone->name));
352   BLI_strncpy(oldname, bone->name, sizeof(bone->name));
353
354   BLI_assert(BKE_id_is_in_global_main(&arm->id));
355   ED_armature_bone_rename(G_MAIN, arm, oldname, newname);
356 }
357
358 static void rna_EditBone_layer_set(PointerRNA *ptr, const bool values[])
359 {
360   EditBone *data = (EditBone *)(ptr->data);
361   rna_bone_layer_set(&data->layer, values);
362 }
363
364 static void rna_EditBone_connected_check(EditBone *ebone)
365 {
366   if (ebone->parent) {
367     if (ebone->flag & BONE_CONNECTED) {
368       /* Attach this bone to its parent */
369       copy_v3_v3(ebone->head, ebone->parent->tail);
370
371       if (ebone->flag & BONE_ROOTSEL)
372         ebone->parent->flag |= BONE_TIPSEL;
373     }
374     else if (!(ebone->parent->flag & BONE_ROOTSEL)) {
375       ebone->parent->flag &= ~BONE_TIPSEL;
376     }
377   }
378 }
379
380 static void rna_EditBone_connected_set(PointerRNA *ptr, bool value)
381 {
382   EditBone *ebone = (EditBone *)(ptr->data);
383
384   if (value)
385     ebone->flag |= BONE_CONNECTED;
386   else
387     ebone->flag &= ~BONE_CONNECTED;
388
389   rna_EditBone_connected_check(ebone);
390 }
391
392 static PointerRNA rna_EditBone_parent_get(PointerRNA *ptr)
393 {
394   EditBone *data = (EditBone *)(ptr->data);
395   return rna_pointer_inherit_refine(ptr, &RNA_EditBone, data->parent);
396 }
397
398 static void rna_EditBone_parent_set(PointerRNA *ptr, PointerRNA value)
399 {
400   EditBone *ebone = (EditBone *)(ptr->data);
401   EditBone *pbone, *parbone = (EditBone *)value.data;
402
403   if (parbone == NULL) {
404     if (ebone->parent && !(ebone->parent->flag & BONE_ROOTSEL))
405       ebone->parent->flag &= ~BONE_TIPSEL;
406
407     ebone->parent = NULL;
408     ebone->flag &= ~BONE_CONNECTED;
409   }
410   else {
411     /* within same armature */
412     if (value.id.data != ptr->id.data)
413       return;
414
415     /* make sure this is a valid child */
416     if (parbone == ebone)
417       return;
418
419     for (pbone = parbone->parent; pbone; pbone = pbone->parent)
420       if (pbone == ebone)
421         return;
422
423     ebone->parent = parbone;
424     rna_EditBone_connected_check(ebone);
425   }
426 }
427
428 static void rna_EditBone_matrix_get(PointerRNA *ptr, float *values)
429 {
430   EditBone *ebone = (EditBone *)(ptr->data);
431   ED_armature_ebone_to_mat4(ebone, (float(*)[4])values);
432 }
433
434 static void rna_EditBone_matrix_set(PointerRNA *ptr, const float *values)
435 {
436   EditBone *ebone = (EditBone *)(ptr->data);
437   ED_armature_ebone_from_mat4(ebone, (float(*)[4])values);
438 }
439
440 static void rna_Bone_bbone_handle_update(Main *bmain, Scene *scene, PointerRNA *ptr)
441 {
442   bArmature *arm = (bArmature *)ptr->id.data;
443   Bone *bone = (Bone *)ptr->data;
444
445   /* Update all users of this armature after changing B-Bone handles. */
446   for (Object *obt = bmain->objects.first; obt; obt = obt->id.next) {
447     if (obt->data == arm && obt->pose) {
448       bPoseChannel *pchan = BKE_pose_channel_find_name(obt->pose, bone->name);
449
450       if (pchan && pchan->bone == bone) {
451         BKE_pchan_rebuild_bbone_handles(obt->pose, pchan);
452         DEG_id_tag_update(&obt->id, ID_RECALC_COPY_ON_WRITE);
453       }
454     }
455   }
456
457   rna_Armature_dependency_update(bmain, scene, ptr);
458 }
459
460 static PointerRNA rna_EditBone_bbone_prev_get(PointerRNA *ptr)
461 {
462   EditBone *data = (EditBone *)(ptr->data);
463   return rna_pointer_inherit_refine(ptr, &RNA_EditBone, data->bbone_prev);
464 }
465
466 static void rna_EditBone_bbone_prev_set(PointerRNA *ptr, PointerRNA value)
467 {
468   EditBone *ebone = (EditBone *)(ptr->data);
469   EditBone *hbone = (EditBone *)value.data;
470
471   /* Within the same armature? */
472   if (hbone == NULL || value.id.data == ptr->id.data) {
473     ebone->bbone_prev = hbone;
474   }
475 }
476
477 static void rna_Bone_bbone_prev_set(PointerRNA *ptr, PointerRNA value)
478 {
479   Bone *bone = (Bone *)ptr->data;
480   Bone *hbone = (Bone *)value.data;
481
482   /* Within the same armature? */
483   if (hbone == NULL || value.id.data == ptr->id.data) {
484     bone->bbone_prev = hbone;
485   }
486 }
487
488 static PointerRNA rna_EditBone_bbone_next_get(PointerRNA *ptr)
489 {
490   EditBone *data = (EditBone *)(ptr->data);
491   return rna_pointer_inherit_refine(ptr, &RNA_EditBone, data->bbone_next);
492 }
493
494 static void rna_EditBone_bbone_next_set(PointerRNA *ptr, PointerRNA value)
495 {
496   EditBone *ebone = (EditBone *)(ptr->data);
497   EditBone *hbone = (EditBone *)value.data;
498
499   /* Within the same armature? */
500   if (hbone == NULL || value.id.data == ptr->id.data) {
501     ebone->bbone_next = hbone;
502   }
503 }
504
505 static void rna_Bone_bbone_next_set(PointerRNA *ptr, PointerRNA value)
506 {
507   Bone *bone = (Bone *)ptr->data;
508   Bone *hbone = (Bone *)value.data;
509
510   /* Within the same armature? */
511   if (hbone == NULL || value.id.data == ptr->id.data) {
512     bone->bbone_next = hbone;
513   }
514 }
515
516 static void rna_Armature_editbone_transform_update(Main *bmain, Scene *scene, PointerRNA *ptr)
517 {
518   bArmature *arm = (bArmature *)ptr->id.data;
519   EditBone *ebone = (EditBone *)ptr->data;
520   EditBone *child, *eboflip;
521
522   /* update our parent */
523   if (ebone->parent && ebone->flag & BONE_CONNECTED)
524     copy_v3_v3(ebone->parent->tail, ebone->head);
525
526   /* update our children if necessary */
527   for (child = arm->edbo->first; child; child = child->next)
528     if (child->parent == ebone && (child->flag & BONE_CONNECTED))
529       copy_v3_v3(child->head, ebone->tail);
530
531   if (arm->flag & ARM_MIRROR_EDIT) {
532     eboflip = ED_armature_ebone_get_mirrored(arm->edbo, ebone);
533
534     if (eboflip) {
535       eboflip->roll = -ebone->roll;
536
537       eboflip->head[0] = -ebone->head[0];
538       eboflip->tail[0] = -ebone->tail[0];
539
540       /* update our parent */
541       if (eboflip->parent && eboflip->flag & BONE_CONNECTED)
542         copy_v3_v3(eboflip->parent->tail, eboflip->head);
543
544       /* update our children if necessary */
545       for (child = arm->edbo->first; child; child = child->next)
546         if (child->parent == eboflip && (child->flag & BONE_CONNECTED))
547           copy_v3_v3(child->head, eboflip->tail);
548     }
549   }
550
551   rna_Armature_update_data(bmain, scene, ptr);
552 }
553
554 static void rna_Armature_bones_next(CollectionPropertyIterator *iter)
555 {
556   ListBaseIterator *internal = &iter->internal.listbase;
557   Bone *bone = (Bone *)internal->link;
558
559   if (bone->childbase.first)
560     internal->link = (Link *)bone->childbase.first;
561   else if (bone->next)
562     internal->link = (Link *)bone->next;
563   else {
564     internal->link = NULL;
565
566     do {
567       bone = bone->parent;
568       if (bone && bone->next) {
569         internal->link = (Link *)bone->next;
570         break;
571       }
572     } while (bone);
573   }
574
575   iter->valid = (internal->link != NULL);
576 }
577
578 /* not essential, but much faster then the default lookup function */
579 static int rna_Armature_bones_lookup_string(PointerRNA *ptr, const char *key, PointerRNA *r_ptr)
580 {
581   bArmature *arm = (bArmature *)ptr->data;
582   Bone *bone = BKE_armature_find_bone_name(arm, key);
583   if (bone) {
584     RNA_pointer_create(ptr->id.data, &RNA_Bone, bone, r_ptr);
585     return true;
586   }
587   else {
588     return false;
589   }
590 }
591
592 static bool rna_Armature_is_editmode_get(PointerRNA *ptr)
593 {
594   bArmature *arm = (bArmature *)ptr->id.data;
595   return (arm->edbo != NULL);
596 }
597
598 static void rna_Armature_transform(struct bArmature *arm, Main *bmain, float *mat)
599 {
600   ED_armature_transform(bmain, arm, (float(*)[4])mat, true);
601 }
602
603 #else
604
605 /* Settings for curved bbone settings -
606  * The posemode values get applied over the top of the editmode ones. */
607 void rna_def_bone_curved_common(StructRNA *srna, bool is_posebone)
608 {
609 #  define RNA_DEF_CURVEBONE_UPDATE(prop, is_posebone) \
610     { \
611       if (is_posebone) \
612         RNA_def_property_update(prop, NC_OBJECT | ND_POSE, "rna_Pose_update"); \
613       else \
614         RNA_def_property_update(prop, 0, "rna_Armature_update_data"); \
615     } \
616     ((void)0)
617
618   PropertyRNA *prop;
619
620   /* Roll In/Out */
621   prop = RNA_def_property(srna, "bbone_rollin", PROP_FLOAT, PROP_ANGLE);
622   RNA_def_property_float_sdna(prop, NULL, "roll1");
623   RNA_def_property_ui_range(prop, -M_PI * 2, M_PI * 2, 10, 2);
624   RNA_def_property_ui_text(
625       prop, "Roll In", "Roll offset for the start of the B-Bone, adjusts twist");
626   RNA_DEF_CURVEBONE_UPDATE(prop, is_posebone);
627
628   prop = RNA_def_property(srna, "bbone_rollout", PROP_FLOAT, PROP_ANGLE);
629   RNA_def_property_float_sdna(prop, NULL, "roll2");
630   RNA_def_property_ui_range(prop, -M_PI * 2, M_PI * 2, 10, 2);
631   RNA_def_property_ui_text(
632       prop, "Roll Out", "Roll offset for the end of the B-Bone, adjusts twist");
633   RNA_DEF_CURVEBONE_UPDATE(prop, is_posebone);
634
635   if (is_posebone == false) {
636     prop = RNA_def_property(srna, "use_endroll_as_inroll", PROP_BOOLEAN, PROP_NONE);
637     RNA_def_property_ui_text(
638         prop, "Inherit End Roll", "Use Roll Out of parent bone as Roll In of its children");
639     RNA_def_property_boolean_sdna(prop, NULL, "flag", BONE_ADD_PARENT_END_ROLL);
640     RNA_def_property_update(prop, 0, "rna_Armature_update_data");
641   }
642
643   /* Curve X/Y Offsets */
644   prop = RNA_def_property(srna, "bbone_curveinx", PROP_FLOAT, PROP_NONE);
645   RNA_def_property_float_sdna(prop, NULL, "curve_in_x");
646   RNA_def_property_ui_range(prop, -FLT_MAX, FLT_MAX, 1, RNA_TRANSLATION_PREC_DEFAULT);
647   RNA_def_property_ui_text(
648       prop, "In X", "X-axis handle offset for start of the B-Bone's curve, adjusts curvature");
649   RNA_DEF_CURVEBONE_UPDATE(prop, is_posebone);
650
651   prop = RNA_def_property(srna, "bbone_curveiny", PROP_FLOAT, PROP_NONE);
652   RNA_def_property_float_sdna(prop, NULL, "curve_in_y");
653   RNA_def_property_ui_range(prop, -FLT_MAX, FLT_MAX, 1, RNA_TRANSLATION_PREC_DEFAULT);
654   RNA_def_property_ui_text(
655       prop, "In Y", "Y-axis handle offset for start of the B-Bone's curve, adjusts curvature");
656   RNA_DEF_CURVEBONE_UPDATE(prop, is_posebone);
657
658   prop = RNA_def_property(srna, "bbone_curveoutx", PROP_FLOAT, PROP_NONE);
659   RNA_def_property_float_sdna(prop, NULL, "curve_out_x");
660   RNA_def_property_ui_range(prop, -FLT_MAX, FLT_MAX, 1, RNA_TRANSLATION_PREC_DEFAULT);
661   RNA_def_property_ui_text(
662       prop, "Out X", "X-axis handle offset for end of the B-Bone's curve, adjusts curvature");
663   RNA_DEF_CURVEBONE_UPDATE(prop, is_posebone);
664
665   prop = RNA_def_property(srna, "bbone_curveouty", PROP_FLOAT, PROP_NONE);
666   RNA_def_property_float_sdna(prop, NULL, "curve_out_y");
667   RNA_def_property_ui_range(prop, -FLT_MAX, FLT_MAX, 1, RNA_TRANSLATION_PREC_DEFAULT);
668   RNA_def_property_ui_text(
669       prop, "Out Y", "Y-axis handle offset for end of the B-Bone's curve, adjusts curvature");
670   RNA_DEF_CURVEBONE_UPDATE(prop, is_posebone);
671
672   /* Ease In/Out */
673   prop = RNA_def_property(srna, "bbone_easein", PROP_FLOAT, PROP_NONE);
674   RNA_def_property_float_sdna(prop, NULL, "ease1");
675   RNA_def_property_ui_range(prop, -5.0f, 5.0f, 1, 3);
676   RNA_def_property_float_default(prop, 1.0f);
677   RNA_def_property_ui_text(prop, "Ease In", "Length of first Bezier Handle (for B-Bones only)");
678   RNA_DEF_CURVEBONE_UPDATE(prop, is_posebone);
679
680   prop = RNA_def_property(srna, "bbone_easeout", PROP_FLOAT, PROP_NONE);
681   RNA_def_property_float_sdna(prop, NULL, "ease2");
682   RNA_def_property_ui_range(prop, -5.0f, 5.0f, 1, 3);
683   RNA_def_property_float_default(prop, 1.0f);
684   RNA_def_property_ui_text(prop, "Ease Out", "Length of second Bezier Handle (for B-Bones only)");
685   RNA_DEF_CURVEBONE_UPDATE(prop, is_posebone);
686
687   /* Scale In/Out */
688   prop = RNA_def_property(srna, "bbone_scaleinx", PROP_FLOAT, PROP_NONE);
689   RNA_def_property_float_sdna(prop, NULL, "scale_in_x");
690   RNA_def_property_flag(prop, PROP_PROPORTIONAL);
691   RNA_def_property_ui_range(prop, 0.0f, FLT_MAX, 1, 3);
692   RNA_def_property_float_default(prop, 1.0f);
693   RNA_def_property_ui_text(prop,
694                            "Scale In X",
695                            "X-axis scale factor for start of the B-Bone, "
696                            "adjusts thickness (for tapering effects)");
697   RNA_DEF_CURVEBONE_UPDATE(prop, is_posebone);
698
699   prop = RNA_def_property(srna, "bbone_scaleiny", PROP_FLOAT, PROP_NONE);
700   RNA_def_property_float_sdna(prop, NULL, "scale_in_y");
701   RNA_def_property_flag(prop, PROP_PROPORTIONAL);
702   RNA_def_property_ui_range(prop, 0.0f, FLT_MAX, 1, 3);
703   RNA_def_property_float_default(prop, 1.0f);
704   RNA_def_property_ui_text(prop,
705                            "Scale In Y",
706                            "Y-axis scale factor for start of the B-Bone, "
707                            "adjusts thickness (for tapering effects)");
708   RNA_DEF_CURVEBONE_UPDATE(prop, is_posebone);
709
710   prop = RNA_def_property(srna, "bbone_scaleoutx", PROP_FLOAT, PROP_NONE);
711   RNA_def_property_float_sdna(prop, NULL, "scale_out_x");
712   RNA_def_property_flag(prop, PROP_PROPORTIONAL);
713   RNA_def_property_ui_range(prop, 0.0f, FLT_MAX, 1, 3);
714   RNA_def_property_float_default(prop, 1.0f);
715   RNA_def_property_ui_text(prop,
716                            "Scale Out X",
717                            "X-axis scale factor for end of the B-Bone, "
718                            "adjusts thickness (for tapering effects)");
719   RNA_DEF_CURVEBONE_UPDATE(prop, is_posebone);
720
721   prop = RNA_def_property(srna, "bbone_scaleouty", PROP_FLOAT, PROP_NONE);
722   RNA_def_property_float_sdna(prop, NULL, "scale_out_y");
723   RNA_def_property_flag(prop, PROP_PROPORTIONAL);
724   RNA_def_property_ui_range(prop, 0.0f, FLT_MAX, 1, 3);
725   RNA_def_property_float_default(prop, 1.0f);
726   RNA_def_property_ui_text(prop,
727                            "Scale Out Y",
728                            "Y-axis scale factor for end of the B-Bone, "
729                            "adjusts thickness (for tapering effects)");
730   RNA_DEF_CURVEBONE_UPDATE(prop, is_posebone);
731
732 #  undef RNA_DEF_CURVEBONE_UPDATE
733 }
734
735 static void rna_def_bone_common(StructRNA *srna, int editbone)
736 {
737   static const EnumPropertyItem prop_bbone_handle_type[] = {
738       {BBONE_HANDLE_AUTO,
739        "AUTO",
740        0,
741        "Automatic",
742        "Use connected parent and children to compute the handle"},
743       {BBONE_HANDLE_ABSOLUTE,
744        "ABSOLUTE",
745        0,
746        "Absolute",
747        "Use the position of the specified bone to compute the handle"},
748       {BBONE_HANDLE_RELATIVE,
749        "RELATIVE",
750        0,
751        "Relative",
752        "Use the offset of the specified bone from rest pose to compute the handle"},
753       {BBONE_HANDLE_TANGENT,
754        "TANGENT",
755        0,
756        "Tangent",
757        "Use the orientation of the specified bone to compute the handle, ignoring the location"},
758       {0, NULL, 0, NULL, NULL},
759   };
760
761   PropertyRNA *prop;
762
763   /* strings */
764   prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
765   RNA_def_property_string_sdna(prop, NULL, "name");
766   RNA_def_property_ui_text(prop, "Name", "");
767   RNA_def_struct_name_property(srna, prop);
768   if (editbone) {
769     RNA_def_property_string_funcs(prop, NULL, NULL, "rna_EditBone_name_set");
770   }
771   else {
772     RNA_def_property_string_funcs(prop, NULL, NULL, "rna_Bone_name_set");
773   }
774   RNA_def_property_update(prop, 0, "rna_Bone_update_renamed");
775
776   /* flags */
777   prop = RNA_def_property(srna, "layers", PROP_BOOLEAN, PROP_LAYER_MEMBER);
778   RNA_def_property_boolean_sdna(prop, NULL, "layer", 1);
779   RNA_def_property_array(prop, 32);
780   if (editbone) {
781     RNA_def_property_boolean_funcs(prop, NULL, "rna_EditBone_layer_set");
782   }
783   else {
784     RNA_def_property_boolean_funcs(prop, NULL, "rna_Bone_layer_set");
785   }
786   RNA_def_property_ui_text(prop, "Layers", "Layers bone exists in");
787   RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
788
789   prop = RNA_def_property(srna, "use_connect", PROP_BOOLEAN, PROP_NONE);
790   RNA_def_property_boolean_sdna(prop, NULL, "flag", BONE_CONNECTED);
791   if (editbone) {
792     RNA_def_property_boolean_funcs(prop, NULL, "rna_EditBone_connected_set");
793   }
794   else {
795     RNA_def_property_clear_flag(prop, PROP_EDITABLE);
796   }
797   RNA_def_property_ui_text(
798       prop, "Connected", "When bone has a parent, bone's head is stuck to the parent's tail");
799   RNA_def_property_update(prop, 0, "rna_Armature_update_data");
800
801   prop = RNA_def_property(srna, "use_inherit_rotation", PROP_BOOLEAN, PROP_NONE);
802   RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", BONE_HINGE);
803   RNA_def_property_ui_text(
804       prop, "Inherit Rotation", "Bone inherits rotation or scale from parent bone");
805   RNA_def_property_update(prop, 0, "rna_Armature_update_data");
806
807   prop = RNA_def_property(srna, "use_envelope_multiply", PROP_BOOLEAN, PROP_NONE);
808   RNA_def_property_boolean_sdna(prop, NULL, "flag", BONE_MULT_VG_ENV);
809   RNA_def_property_ui_text(
810       prop,
811       "Multiply Vertex Group with Envelope",
812       "When deforming bone, multiply effects of Vertex Group weights with Envelope influence");
813   RNA_def_property_update(prop, 0, "rna_Armature_update_data");
814
815   prop = RNA_def_property(srna, "use_deform", PROP_BOOLEAN, PROP_NONE);
816   RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", BONE_NO_DEFORM);
817   RNA_def_property_ui_text(prop, "Deform", "Enable Bone to deform geometry");
818   RNA_def_property_update(prop, 0, "rna_Armature_update_data");
819
820   prop = RNA_def_property(srna, "use_inherit_scale", PROP_BOOLEAN, PROP_NONE);
821   RNA_def_property_ui_text(prop, "Inherit Scale", "Bone inherits scaling from parent bone");
822   RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", BONE_NO_SCALE);
823   RNA_def_property_update(prop, 0, "rna_Armature_update_data");
824
825   prop = RNA_def_property(srna, "use_local_location", PROP_BOOLEAN, PROP_NONE);
826   RNA_def_property_ui_text(prop, "Local Location", "Bone location is set in local space");
827   RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", BONE_NO_LOCAL_LOCATION);
828   RNA_def_property_update(prop, 0, "rna_Armature_update_data");
829
830   prop = RNA_def_property(srna, "use_relative_parent", PROP_BOOLEAN, PROP_NONE);
831   RNA_def_property_ui_text(
832       prop, "Relative Parenting", "Object children will use relative transform, like deform");
833   RNA_def_property_boolean_sdna(prop, NULL, "flag", BONE_RELATIVE_PARENTING);
834   RNA_def_property_update(prop, 0, "rna_Armature_update_data");
835
836   prop = RNA_def_property(srna, "show_wire", PROP_BOOLEAN, PROP_NONE);
837   RNA_def_property_boolean_sdna(prop, NULL, "flag", BONE_DRAWWIRE);
838   RNA_def_property_ui_text(prop,
839                            "Display Wire",
840                            "Bone is always drawn as Wireframe regardless of viewport draw mode "
841                            "(useful for non-obstructive custom bone shapes)");
842   RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
843
844   /* XXX: use_cyclic_offset is deprecated in 2.5. May/may not return */
845   prop = RNA_def_property(srna, "use_cyclic_offset", PROP_BOOLEAN, PROP_NONE);
846   RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", BONE_NO_CYCLICOFFSET);
847   RNA_def_property_ui_text(
848       prop,
849       "Cyclic Offset",
850       "When bone doesn't have a parent, it receives cyclic offset effects (Deprecated)");
851   //                         "When bone doesn't have a parent, it receives cyclic offset effects");
852   RNA_def_property_update(prop, 0, "rna_Armature_update_data");
853
854   prop = RNA_def_property(srna, "hide_select", PROP_BOOLEAN, PROP_NONE);
855   RNA_def_property_boolean_sdna(prop, NULL, "flag", BONE_UNSELECTABLE);
856   RNA_def_property_ui_text(prop, "Selectable", "Bone is able to be selected");
857   RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
858
859   /* Number values */
860   /* envelope deform settings */
861   prop = RNA_def_property(srna, "envelope_distance", PROP_FLOAT, PROP_DISTANCE);
862   RNA_def_property_float_sdna(prop, NULL, "dist");
863   RNA_def_property_range(prop, 0.0f, 1000.0f);
864   RNA_def_property_ui_text(
865       prop, "Envelope Deform Distance", "Bone deformation distance (for Envelope deform only)");
866   RNA_def_property_update(prop, 0, "rna_Armature_update_data");
867
868   prop = RNA_def_property(srna, "envelope_weight", PROP_FLOAT, PROP_NONE);
869   RNA_def_property_float_sdna(prop, NULL, "weight");
870   RNA_def_property_range(prop, 0.0f, 1000.0f);
871   RNA_def_property_ui_text(
872       prop, "Envelope Deform Weight", "Bone deformation weight (for Envelope deform only)");
873   RNA_def_property_update(prop, 0, "rna_Armature_update_data");
874
875   prop = RNA_def_property(srna, "head_radius", PROP_FLOAT, PROP_DISTANCE);
876   if (editbone) {
877     RNA_def_property_update(prop, 0, "rna_Armature_editbone_transform_update");
878   }
879   else {
880     RNA_def_property_update(prop, 0, "rna_Armature_update_data");
881   }
882   RNA_def_property_float_sdna(prop, NULL, "rad_head");
883   /* XXX range is 0 to lim, where lim = 10000.0f * MAX2(1.0, view3d->grid); */
884   /*RNA_def_property_range(prop, 0, 1000); */
885   RNA_def_property_ui_range(prop, 0.01, 100, 0.1, 3);
886   RNA_def_property_ui_text(
887       prop, "Envelope Head Radius", "Radius of head of bone (for Envelope deform only)");
888
889   prop = RNA_def_property(srna, "tail_radius", PROP_FLOAT, PROP_DISTANCE);
890   if (editbone) {
891     RNA_def_property_update(prop, 0, "rna_Armature_editbone_transform_update");
892   }
893   else {
894     RNA_def_property_update(prop, 0, "rna_Armature_update_data");
895   }
896   RNA_def_property_float_sdna(prop, NULL, "rad_tail");
897   /* XXX range is 0 to lim, where lim = 10000.0f * MAX2(1.0, view3d->grid); */
898   /*RNA_def_property_range(prop, 0, 1000); */
899   RNA_def_property_ui_range(prop, 0.01, 100, 0.1, 3);
900   RNA_def_property_ui_text(
901       prop, "Envelope Tail Radius", "Radius of tail of bone (for Envelope deform only)");
902
903   /* b-bones deform settings */
904   prop = RNA_def_property(srna, "bbone_segments", PROP_INT, PROP_NONE);
905   RNA_def_property_int_sdna(prop, NULL, "segments");
906   RNA_def_property_range(prop, 1, 32);
907   RNA_def_property_ui_text(
908       prop, "B-Bone Segments", "Number of subdivisions of bone (for B-Bones only)");
909   RNA_def_property_update(prop, 0, "rna_Armature_dependency_update");
910
911   prop = RNA_def_property(srna, "bbone_x", PROP_FLOAT, PROP_NONE);
912   RNA_def_property_float_sdna(prop, NULL, "xwidth");
913   RNA_def_property_range(prop, 0.0f, 1000.0f);
914   RNA_def_property_ui_text(prop, "B-Bone Display X Width", "B-Bone X size");
915   RNA_def_property_update(prop, 0, "rna_Armature_update_data");
916
917   prop = RNA_def_property(srna, "bbone_z", PROP_FLOAT, PROP_NONE);
918   RNA_def_property_float_sdna(prop, NULL, "zwidth");
919   RNA_def_property_range(prop, 0.0f, 1000.0f);
920   RNA_def_property_ui_text(prop, "B-Bone Display Z Width", "B-Bone Z size");
921   RNA_def_property_update(prop, 0, "rna_Armature_update_data");
922
923   prop = RNA_def_property(srna, "bbone_handle_type_start", PROP_ENUM, PROP_NONE);
924   RNA_def_property_enum_sdna(prop, NULL, "bbone_prev_type");
925   RNA_def_property_enum_items(prop, prop_bbone_handle_type);
926   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
927   RNA_def_property_ui_text(
928       prop, "B-Bone Start Handle Type", "Selects how the start handle of the B-Bone is computed");
929   RNA_def_property_update(prop, 0, "rna_Armature_dependency_update");
930
931   prop = RNA_def_property(srna, "bbone_custom_handle_start", PROP_POINTER, PROP_NONE);
932   RNA_def_property_pointer_sdna(prop, NULL, "bbone_prev");
933   RNA_def_property_struct_type(prop, editbone ? "EditBone" : "Bone");
934   if (editbone) {
935     RNA_def_property_pointer_funcs(
936         prop, "rna_EditBone_bbone_prev_get", "rna_EditBone_bbone_prev_set", NULL, NULL);
937     RNA_def_property_update(prop, 0, "rna_Armature_dependency_update");
938   }
939   else {
940     RNA_def_property_pointer_funcs(prop, NULL, "rna_Bone_bbone_prev_set", NULL, NULL);
941     RNA_def_property_update(prop, 0, "rna_Bone_bbone_handle_update");
942   }
943   RNA_def_property_flag(prop, PROP_EDITABLE | PROP_PTR_NO_OWNERSHIP);
944   RNA_def_property_ui_text(
945       prop, "B-Bone Start Handle", "Bone that serves as the start handle for the B-Bone curve");
946
947   prop = RNA_def_property(srna, "bbone_handle_type_end", PROP_ENUM, PROP_NONE);
948   RNA_def_property_enum_sdna(prop, NULL, "bbone_next_type");
949   RNA_def_property_enum_items(prop, prop_bbone_handle_type);
950   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
951   RNA_def_property_ui_text(
952       prop, "B-Bone End Handle Type", "Selects how the end handle of the B-Bone is computed");
953   RNA_def_property_update(prop, 0, "rna_Armature_dependency_update");
954
955   prop = RNA_def_property(srna, "bbone_custom_handle_end", PROP_POINTER, PROP_NONE);
956   RNA_def_property_pointer_sdna(prop, NULL, "bbone_next");
957   RNA_def_property_struct_type(prop, editbone ? "EditBone" : "Bone");
958   if (editbone) {
959     RNA_def_property_pointer_funcs(
960         prop, "rna_EditBone_bbone_next_get", "rna_EditBone_bbone_next_set", NULL, NULL);
961     RNA_def_property_update(prop, 0, "rna_Armature_dependency_update");
962   }
963   else {
964     RNA_def_property_pointer_funcs(prop, NULL, "rna_Bone_bbone_next_set", NULL, NULL);
965     RNA_def_property_update(prop, 0, "rna_Bone_bbone_handle_update");
966   }
967   RNA_def_property_flag(prop, PROP_EDITABLE | PROP_PTR_NO_OWNERSHIP);
968   RNA_def_property_ui_text(
969       prop, "B-Bone End Handle", "Bone that serves as the end handle for the B-Bone curve");
970 }
971
972 /* err... bones should not be directly edited (only editbones should be...) */
973 static void rna_def_bone(BlenderRNA *brna)
974 {
975   StructRNA *srna;
976   PropertyRNA *prop;
977
978   srna = RNA_def_struct(brna, "Bone", NULL);
979   RNA_def_struct_ui_text(srna, "Bone", "Bone in an Armature data-block");
980   RNA_def_struct_ui_icon(srna, ICON_BONE_DATA);
981   RNA_def_struct_path_func(srna, "rna_Bone_path");
982   RNA_def_struct_idprops_func(srna, "rna_Bone_idprops");
983
984   /* pointers/collections */
985   /* parent (pointer) */
986   prop = RNA_def_property(srna, "parent", PROP_POINTER, PROP_NONE);
987   RNA_def_property_struct_type(prop, "Bone");
988   RNA_def_property_pointer_sdna(prop, NULL, "parent");
989   RNA_def_property_flag(prop, PROP_PTR_NO_OWNERSHIP);
990   RNA_def_property_ui_text(prop, "Parent", "Parent bone (in same Armature)");
991   RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
992
993   /* children (collection) */
994   prop = RNA_def_property(srna, "children", PROP_COLLECTION, PROP_NONE);
995   RNA_def_property_collection_sdna(prop, NULL, "childbase", NULL);
996   RNA_def_property_struct_type(prop, "Bone");
997   RNA_def_property_flag(prop, PROP_PTR_NO_OWNERSHIP);
998   RNA_def_property_ui_text(prop, "Children", "Bones which are children of this bone");
999
1000   rna_def_bone_common(srna, 0);
1001   rna_def_bone_curved_common(srna, 0);
1002
1003   /* XXX should we define this in PoseChannel wrapping code instead?
1004    *     But PoseChannels directly get some of their flags from here... */
1005   prop = RNA_def_property(srna, "hide", PROP_BOOLEAN, PROP_NONE);
1006   RNA_def_property_boolean_sdna(prop, NULL, "flag", BONE_HIDDEN_P);
1007   RNA_def_property_ui_text(
1008       prop,
1009       "Hide",
1010       "Bone is not visible when it is not in Edit Mode (i.e. in Object or Pose Modes)");
1011   RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
1012
1013   prop = RNA_def_property(srna, "select", PROP_BOOLEAN, PROP_NONE);
1014   RNA_def_property_boolean_sdna(prop, NULL, "flag", BONE_SELECTED);
1015   RNA_def_property_ui_text(prop, "Select", "");
1016   RNA_def_property_clear_flag(
1017       prop,
1018       PROP_ANIMATABLE); /* XXX: review whether this could be used for interesting effects... */
1019   RNA_def_property_update(prop, 0, "rna_Bone_select_update");
1020
1021   prop = RNA_def_property(srna, "select_head", PROP_BOOLEAN, PROP_NONE);
1022   RNA_def_property_boolean_sdna(prop, NULL, "flag", BONE_ROOTSEL);
1023   RNA_def_property_ui_text(prop, "Select Head", "");
1024   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1025   RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
1026
1027   prop = RNA_def_property(srna, "select_tail", PROP_BOOLEAN, PROP_NONE);
1028   RNA_def_property_boolean_sdna(prop, NULL, "flag", BONE_TIPSEL);
1029   RNA_def_property_ui_text(prop, "Select Tail", "");
1030   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1031   RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
1032
1033   /* XXX better matrix descriptions possible (Arystan) */
1034   prop = RNA_def_property(srna, "matrix", PROP_FLOAT, PROP_MATRIX);
1035   RNA_def_property_float_sdna(prop, NULL, "bone_mat");
1036   RNA_def_property_multi_array(prop, 2, rna_matrix_dimsize_3x3);
1037   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1038   RNA_def_property_ui_text(prop, "Bone Matrix", "3x3 bone matrix");
1039
1040   prop = RNA_def_property(srna, "matrix_local", PROP_FLOAT, PROP_MATRIX);
1041   RNA_def_property_float_sdna(prop, NULL, "arm_mat");
1042   RNA_def_property_multi_array(prop, 2, rna_matrix_dimsize_4x4);
1043   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1044   RNA_def_property_ui_text(
1045       prop, "Bone Armature-Relative Matrix", "4x4 bone matrix relative to armature");
1046
1047   prop = RNA_def_property(srna, "tail", PROP_FLOAT, PROP_TRANSLATION);
1048   RNA_def_property_float_sdna(prop, NULL, "tail");
1049   RNA_def_property_array(prop, 3);
1050   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1051   RNA_def_property_ui_text(prop, "Tail", "Location of tail end of the bone");
1052   RNA_def_property_ui_range(prop, -FLT_MAX, FLT_MAX, 1, RNA_TRANSLATION_PREC_DEFAULT);
1053
1054   prop = RNA_def_property(srna, "tail_local", PROP_FLOAT, PROP_TRANSLATION);
1055   RNA_def_property_float_sdna(prop, NULL, "arm_tail");
1056   RNA_def_property_array(prop, 3);
1057   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1058   RNA_def_property_ui_text(
1059       prop, "Armature-Relative Tail", "Location of tail end of the bone relative to armature");
1060   RNA_def_property_ui_range(prop, -FLT_MAX, FLT_MAX, 1, RNA_TRANSLATION_PREC_DEFAULT);
1061
1062   prop = RNA_def_property(srna, "head", PROP_FLOAT, PROP_TRANSLATION);
1063   RNA_def_property_float_sdna(prop, NULL, "head");
1064   RNA_def_property_array(prop, 3);
1065   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1066   RNA_def_property_ui_text(
1067       prop, "Head", "Location of head end of the bone relative to its parent");
1068   RNA_def_property_ui_range(prop, -FLT_MAX, FLT_MAX, 1, RNA_TRANSLATION_PREC_DEFAULT);
1069
1070   prop = RNA_def_property(srna, "head_local", PROP_FLOAT, PROP_TRANSLATION);
1071   RNA_def_property_float_sdna(prop, NULL, "arm_head");
1072   RNA_def_property_array(prop, 3);
1073   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1074   RNA_def_property_ui_text(
1075       prop, "Armature-Relative Head", "Location of head end of the bone relative to armature");
1076   RNA_def_property_ui_range(prop, -FLT_MAX, FLT_MAX, 1, RNA_TRANSLATION_PREC_DEFAULT);
1077
1078   RNA_api_bone(srna);
1079 }
1080
1081 static void rna_def_edit_bone(BlenderRNA *brna)
1082 {
1083   StructRNA *srna;
1084   PropertyRNA *prop;
1085
1086   srna = RNA_def_struct(brna, "EditBone", NULL);
1087   RNA_def_struct_sdna(srna, "EditBone");
1088   RNA_def_struct_idprops_func(srna, "rna_EditBone_idprops");
1089   RNA_def_struct_ui_text(srna, "Edit Bone", "Editmode bone in an Armature data-block");
1090   RNA_def_struct_ui_icon(srna, ICON_BONE_DATA);
1091
1092   RNA_define_verify_sdna(0); /* not in sdna */
1093
1094   prop = RNA_def_property(srna, "parent", PROP_POINTER, PROP_NONE);
1095   RNA_def_property_struct_type(prop, "EditBone");
1096   RNA_def_property_pointer_funcs(
1097       prop, "rna_EditBone_parent_get", "rna_EditBone_parent_set", NULL, NULL);
1098   RNA_def_property_flag(prop, PROP_EDITABLE);
1099   RNA_def_property_ui_text(prop, "Parent", "Parent edit bone (in same Armature)");
1100   RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
1101
1102   prop = RNA_def_property(srna, "roll", PROP_FLOAT, PROP_ANGLE);
1103   RNA_def_property_float_sdna(prop, NULL, "roll");
1104   RNA_def_property_ui_range(prop, -M_PI * 2, M_PI * 2, 10, 2);
1105   RNA_def_property_ui_text(prop, "Roll", "Bone rotation around head-tail axis");
1106   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1107   RNA_def_property_update(prop, 0, "rna_Armature_editbone_transform_update");
1108
1109   prop = RNA_def_property(srna, "head", PROP_FLOAT, PROP_TRANSLATION);
1110   RNA_def_property_float_sdna(prop, NULL, "head");
1111   RNA_def_property_array(prop, 3);
1112   RNA_def_property_ui_text(prop, "Head", "Location of head end of the bone");
1113   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1114   RNA_def_property_update(prop, 0, "rna_Armature_editbone_transform_update");
1115
1116   prop = RNA_def_property(srna, "tail", PROP_FLOAT, PROP_TRANSLATION);
1117   RNA_def_property_float_sdna(prop, NULL, "tail");
1118   RNA_def_property_array(prop, 3);
1119   RNA_def_property_ui_text(prop, "Tail", "Location of tail end of the bone");
1120   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1121   RNA_def_property_update(prop, 0, "rna_Armature_editbone_transform_update");
1122
1123   rna_def_bone_common(srna, 1);
1124   rna_def_bone_curved_common(srna, 0);
1125
1126   prop = RNA_def_property(srna, "hide", PROP_BOOLEAN, PROP_NONE);
1127   RNA_def_property_boolean_sdna(prop, NULL, "flag", BONE_HIDDEN_A);
1128   RNA_def_property_ui_text(prop, "Hide", "Bone is not visible when in Edit Mode");
1129   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1130   RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
1131
1132   prop = RNA_def_property(srna, "lock", PROP_BOOLEAN, PROP_NONE);
1133   RNA_def_property_boolean_sdna(prop, NULL, "flag", BONE_EDITMODE_LOCKED);
1134   RNA_def_property_ui_text(prop, "Lock", "Bone is not able to be transformed when in Edit Mode");
1135   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1136   RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
1137
1138   prop = RNA_def_property(srna, "select", PROP_BOOLEAN, PROP_NONE);
1139   RNA_def_property_boolean_sdna(prop, NULL, "flag", BONE_SELECTED);
1140   RNA_def_property_ui_text(prop, "Select", "");
1141   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1142   RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
1143
1144   prop = RNA_def_property(srna, "select_head", PROP_BOOLEAN, PROP_NONE);
1145   RNA_def_property_boolean_sdna(prop, NULL, "flag", BONE_ROOTSEL);
1146   RNA_def_property_ui_text(prop, "Head Select", "");
1147   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1148   RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
1149
1150   prop = RNA_def_property(srna, "select_tail", PROP_BOOLEAN, PROP_NONE);
1151   RNA_def_property_boolean_sdna(prop, NULL, "flag", BONE_TIPSEL);
1152   RNA_def_property_ui_text(prop, "Tail Select", "");
1153   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1154   RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
1155
1156   /* calculated and read only, not actual data access */
1157   prop = RNA_def_property(srna, "matrix", PROP_FLOAT, PROP_MATRIX);
1158   /*RNA_def_property_float_sdna(prop, NULL, "");  */ /* doesn't access any real data */
1159   RNA_def_property_multi_array(prop, 2, rna_matrix_dimsize_4x4);
1160   // RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1161   RNA_def_property_flag(prop, PROP_THICK_WRAP); /* no reference to original data */
1162   RNA_def_property_ui_text(
1163       prop,
1164       "Editbone Matrix",
1165       "Matrix combining loc/rot of the bone (head position, direction and roll), "
1166       "in armature space (WARNING: does not include/support bone's length/size)");
1167   RNA_def_property_float_funcs(prop, "rna_EditBone_matrix_get", "rna_EditBone_matrix_set", NULL);
1168
1169   RNA_api_armature_edit_bone(srna);
1170
1171   RNA_define_verify_sdna(1);
1172 }
1173
1174 /* armature.bones.* */
1175 static void rna_def_armature_bones(BlenderRNA *brna, PropertyRNA *cprop)
1176 {
1177   StructRNA *srna;
1178   PropertyRNA *prop;
1179
1180   /*  FunctionRNA *func; */
1181   /*  PropertyRNA *parm; */
1182
1183   RNA_def_property_srna(cprop, "ArmatureBones");
1184   srna = RNA_def_struct(brna, "ArmatureBones", NULL);
1185   RNA_def_struct_sdna(srna, "bArmature");
1186   RNA_def_struct_ui_text(srna, "Armature Bones", "Collection of armature bones");
1187
1188   prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
1189   RNA_def_property_struct_type(prop, "Bone");
1190   RNA_def_property_pointer_sdna(prop, NULL, "act_bone");
1191   RNA_def_property_flag(prop, PROP_EDITABLE);
1192   RNA_def_property_ui_text(prop, "Active Bone", "Armature's active bone");
1193   RNA_def_property_pointer_funcs(prop, NULL, "rna_Armature_act_bone_set", NULL, NULL);
1194
1195   /* todo, redraw */
1196   /*      RNA_def_property_collection_active(prop, prop_act); */
1197 }
1198
1199 /* armature.bones.* */
1200 static void rna_def_armature_edit_bones(BlenderRNA *brna, PropertyRNA *cprop)
1201 {
1202   StructRNA *srna;
1203   PropertyRNA *prop;
1204
1205   FunctionRNA *func;
1206   PropertyRNA *parm;
1207
1208   RNA_def_property_srna(cprop, "ArmatureEditBones");
1209   srna = RNA_def_struct(brna, "ArmatureEditBones", NULL);
1210   RNA_def_struct_sdna(srna, "bArmature");
1211   RNA_def_struct_ui_text(srna, "Armature EditBones", "Collection of armature edit bones");
1212
1213   prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
1214   RNA_def_property_struct_type(prop, "EditBone");
1215   RNA_def_property_pointer_sdna(prop, NULL, "act_edbone");
1216   RNA_def_property_flag(prop, PROP_EDITABLE);
1217   RNA_def_property_ui_text(prop, "Active EditBone", "Armatures active edit bone");
1218   /*RNA_def_property_update(prop, 0, "rna_Armature_act_editbone_update"); */
1219   RNA_def_property_pointer_funcs(prop, NULL, "rna_Armature_act_edit_bone_set", NULL, NULL);
1220
1221   /* todo, redraw */
1222   /*      RNA_def_property_collection_active(prop, prop_act); */
1223
1224   /* add target */
1225   func = RNA_def_function(srna, "new", "rna_Armature_edit_bone_new");
1226   RNA_def_function_flag(func, FUNC_USE_REPORTS);
1227   RNA_def_function_ui_description(func, "Add a new bone");
1228   parm = RNA_def_string(func, "name", "Object", 0, "", "New name for the bone");
1229   RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
1230   /* return type */
1231   parm = RNA_def_pointer(func, "bone", "EditBone", "", "Newly created edit bone");
1232   RNA_def_function_return(func, parm);
1233
1234   /* remove target */
1235   func = RNA_def_function(srna, "remove", "rna_Armature_edit_bone_remove");
1236   RNA_def_function_flag(func, FUNC_USE_REPORTS);
1237   RNA_def_function_ui_description(func, "Remove an existing bone from the armature");
1238   /* target to remove*/
1239   parm = RNA_def_pointer(func, "bone", "EditBone", "", "EditBone to remove");
1240   RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED | PARM_RNAPTR);
1241   RNA_def_parameter_clear_flags(parm, PROP_THICK_WRAP, 0);
1242 }
1243
1244 static void rna_def_armature(BlenderRNA *brna)
1245 {
1246   StructRNA *srna;
1247   PropertyRNA *prop;
1248
1249   FunctionRNA *func;
1250   PropertyRNA *parm;
1251
1252   static const EnumPropertyItem prop_drawtype_items[] = {
1253       {ARM_OCTA, "OCTAHEDRAL", 0, "Octahedral", "Display bones as octahedral shape (default)"},
1254       {ARM_LINE, "STICK", 0, "Stick", "Display bones as simple 2D lines with dots"},
1255       {ARM_B_BONE,
1256        "BBONE",
1257        0,
1258        "B-Bone",
1259        "Display bones as boxes, showing subdivision and B-Splines"},
1260       {ARM_ENVELOPE,
1261        "ENVELOPE",
1262        0,
1263        "Envelope",
1264        "Display bones as extruded spheres, showing deformation influence volume"},
1265       {ARM_WIRE,
1266        "WIRE",
1267        0,
1268        "Wire",
1269        "Display bones as thin wires, showing subdivision and B-Splines"},
1270       {0, NULL, 0, NULL, NULL},
1271   };
1272   static const EnumPropertyItem prop_pose_position_items[] = {
1273       {0, "POSE", 0, "Pose Position", "Show armature in posed state"},
1274       {ARM_RESTPOS,
1275        "REST",
1276        0,
1277        "Rest Position",
1278        "Show Armature in binding pose state (no posing possible)"},
1279       {0, NULL, 0, NULL, NULL},
1280   };
1281
1282   srna = RNA_def_struct(brna, "Armature", "ID");
1283   RNA_def_struct_ui_text(
1284       srna,
1285       "Armature",
1286       "Armature data-block containing a hierarchy of bones, usually used for rigging characters");
1287   RNA_def_struct_ui_icon(srna, ICON_ARMATURE_DATA);
1288   RNA_def_struct_sdna(srna, "bArmature");
1289
1290   func = RNA_def_function(srna, "transform", "rna_Armature_transform");
1291   RNA_def_function_flag(func, FUNC_USE_MAIN);
1292   RNA_def_function_ui_description(func, "Transform armature bones by a matrix");
1293   parm = RNA_def_float_matrix(func, "matrix", 4, 4, NULL, 0.0f, 0.0f, "", "Matrix", 0.0f, 0.0f);
1294   RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
1295
1296   /* Animation Data */
1297   rna_def_animdata_common(srna);
1298
1299   /* Collections */
1300   prop = RNA_def_property(srna, "bones", PROP_COLLECTION, PROP_NONE);
1301   RNA_def_property_collection_sdna(prop, NULL, "bonebase", NULL);
1302   RNA_def_property_collection_funcs(prop,
1303                                     NULL,
1304                                     "rna_Armature_bones_next",
1305                                     NULL,
1306                                     NULL,
1307                                     NULL,
1308                                     NULL,
1309                                     "rna_Armature_bones_lookup_string",
1310                                     NULL);
1311   RNA_def_property_struct_type(prop, "Bone");
1312   RNA_def_property_ui_text(prop, "Bones", "");
1313   rna_def_armature_bones(brna, prop);
1314
1315   prop = RNA_def_property(srna, "edit_bones", PROP_COLLECTION, PROP_NONE);
1316   RNA_def_property_collection_sdna(prop, NULL, "edbo", NULL);
1317   RNA_def_property_struct_type(prop, "EditBone");
1318   RNA_def_property_ui_text(prop, "Edit Bones", "");
1319   rna_def_armature_edit_bones(brna, prop);
1320
1321   /* Enum values */
1322   prop = RNA_def_property(srna, "pose_position", PROP_ENUM, PROP_NONE);
1323   RNA_def_property_enum_bitflag_sdna(prop, NULL, "flag");
1324   RNA_def_property_enum_items(prop, prop_pose_position_items);
1325   RNA_def_property_ui_text(
1326       prop, "Pose Position", "Show armature in binding pose or final posed state");
1327   RNA_def_property_update(prop, 0, "rna_Armature_update_data");
1328   RNA_def_property_flag(prop, PROP_LIB_EXCEPTION);
1329
1330   prop = RNA_def_property(srna, "display_type", PROP_ENUM, PROP_NONE);
1331   RNA_def_property_enum_sdna(prop, NULL, "drawtype");
1332   RNA_def_property_enum_items(prop, prop_drawtype_items);
1333   RNA_def_property_ui_text(prop, "Display Type Type", "");
1334   RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
1335   RNA_def_property_flag(prop, PROP_LIB_EXCEPTION);
1336
1337   /* Boolean values */
1338   /* layer */
1339   prop = RNA_def_property(srna, "layers", PROP_BOOLEAN, PROP_LAYER_MEMBER);
1340   RNA_def_property_boolean_sdna(prop, NULL, "layer", 1);
1341   RNA_def_property_array(prop, 32);
1342   RNA_def_property_ui_text(prop, "Visible Layers", "Armature layer visibility");
1343   RNA_def_property_boolean_funcs(prop, NULL, "rna_Armature_layer_set");
1344   RNA_def_property_update(prop, NC_OBJECT | ND_POSE, "rna_Armature_update_layers");
1345   RNA_def_property_flag(prop, PROP_LIB_EXCEPTION);
1346
1347   /* layer protection */
1348   prop = RNA_def_property(srna, "layers_protected", PROP_BOOLEAN, PROP_LAYER);
1349   RNA_def_property_boolean_sdna(prop, NULL, "layer_protected", 1);
1350   RNA_def_property_array(prop, 32);
1351   RNA_def_property_ui_text(prop,
1352                            "Layer Proxy Protection",
1353                            "Protected layers in Proxy Instances are restored to Proxy settings "
1354                            "on file reload and undo");
1355   RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
1356
1357   /* flag */
1358   prop = RNA_def_property(srna, "show_axes", PROP_BOOLEAN, PROP_NONE);
1359   RNA_def_property_boolean_sdna(prop, NULL, "flag", ARM_DRAWAXES);
1360   RNA_def_property_ui_text(prop, "Display Axes", "Display bone axes");
1361   RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
1362   RNA_def_property_flag(prop, PROP_LIB_EXCEPTION);
1363
1364   prop = RNA_def_property(srna, "show_names", PROP_BOOLEAN, PROP_NONE);
1365   RNA_def_property_boolean_sdna(prop, NULL, "flag", ARM_DRAWNAMES);
1366   RNA_def_property_ui_text(prop, "Display Names", "Display bone names");
1367   RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
1368   RNA_def_property_flag(prop, PROP_LIB_EXCEPTION);
1369
1370   prop = RNA_def_property(srna, "use_deform_delay", PROP_BOOLEAN, PROP_NONE);
1371   RNA_def_property_boolean_sdna(prop, NULL, "flag", ARM_DELAYDEFORM);
1372   RNA_def_property_ui_text(
1373       prop, "Delay Deform", "Don't deform children when manipulating bones in Pose Mode");
1374   RNA_def_property_update(prop, 0, "rna_Armature_update_data");
1375
1376   prop = RNA_def_property(srna, "use_mirror_x", PROP_BOOLEAN, PROP_NONE);
1377   RNA_def_property_boolean_sdna(prop, NULL, "flag", ARM_MIRROR_EDIT);
1378   RNA_def_property_ui_text(
1379       prop, "X-Axis Mirror", "Apply changes to matching bone on opposite side of X-Axis");
1380   RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
1381   RNA_def_property_flag(prop, PROP_LIB_EXCEPTION);
1382
1383   prop = RNA_def_property(srna, "show_bone_custom_shapes", PROP_BOOLEAN, PROP_NONE);
1384   RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", ARM_NO_CUSTOM);
1385   RNA_def_property_ui_text(
1386       prop, "Display Custom Bone Shapes", "Display bones with their custom shapes");
1387   RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
1388
1389   prop = RNA_def_property(srna, "show_group_colors", PROP_BOOLEAN, PROP_NONE);
1390   RNA_def_property_boolean_sdna(prop, NULL, "flag", ARM_COL_CUSTOM);
1391   RNA_def_property_ui_text(prop, "Display Bone Group Colors", "Display bone group colors");
1392   RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
1393
1394   prop = RNA_def_property(srna, "is_editmode", PROP_BOOLEAN, PROP_NONE);
1395   RNA_def_property_boolean_funcs(prop, "rna_Armature_is_editmode_get", NULL);
1396   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1397   RNA_def_property_ui_text(prop, "Is Editmode", "True when used in editmode");
1398 }
1399
1400 void RNA_def_armature(BlenderRNA *brna)
1401 {
1402   rna_def_armature(brna);
1403   rna_def_bone(brna);
1404   rna_def_edit_bone(brna);
1405 }
1406
1407 #endif