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