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