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         /* Scale In/Out */
548         prop = RNA_def_property(srna, "bbone_scalein", PROP_FLOAT, PROP_NONE);
549         RNA_def_property_float_sdna(prop, NULL, "scaleIn");
550         RNA_def_property_range(prop, 0.0f, 5.0f);
551         RNA_def_property_float_default(prop, 1.0f);
552         RNA_def_property_ui_text(prop, "Scale In", "Scale factor for start of the B-Bone, adjusts thickness (for tapering effects)");
553         RNA_DEF_CURVEBONE_UPDATE(prop, is_posebone);
554         
555         prop = RNA_def_property(srna, "bbone_scaleout", PROP_FLOAT, PROP_NONE);
556         RNA_def_property_float_sdna(prop, NULL, "scaleOut");
557         RNA_def_property_range(prop, 0.0f, 5.0f);
558         RNA_def_property_float_default(prop, 1.0f);
559         RNA_def_property_ui_text(prop, "Scale Out", "Scale factor for end of the B-Bone, adjusts thickness (for tapering effects)");
560         RNA_DEF_CURVEBONE_UPDATE(prop, is_posebone);
561         
562 #undef RNA_DEF_CURVEBONE_UPDATE
563 }
564
565 static void rna_def_bone_common(StructRNA *srna, int editbone)
566 {
567         PropertyRNA *prop;
568
569         /* strings */
570         prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
571         RNA_def_property_string_sdna(prop, NULL, "name");
572         RNA_def_property_ui_text(prop, "Name", "");
573         RNA_def_struct_name_property(srna, prop);
574         if (editbone) RNA_def_property_string_funcs(prop, NULL, NULL, "rna_EditBone_name_set");
575         else RNA_def_property_string_funcs(prop, NULL, NULL, "rna_Bone_name_set");
576         RNA_def_property_update(prop, 0, "rna_Bone_update_renamed");
577
578         /* flags */
579         prop = RNA_def_property(srna, "layers", PROP_BOOLEAN, PROP_LAYER_MEMBER);
580         RNA_def_property_boolean_sdna(prop, NULL, "layer", 1);
581         RNA_def_property_array(prop, 32);
582         if (editbone) RNA_def_property_boolean_funcs(prop, NULL, "rna_EditBone_layer_set");
583         else RNA_def_property_boolean_funcs(prop, NULL, "rna_Bone_layer_set");
584         RNA_def_property_ui_text(prop, "Layers", "Layers bone exists in");
585         RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
586
587         prop = RNA_def_property(srna, "use_connect", PROP_BOOLEAN, PROP_NONE);
588         RNA_def_property_boolean_sdna(prop, NULL, "flag", BONE_CONNECTED);
589         if (editbone) RNA_def_property_boolean_funcs(prop, NULL, "rna_EditBone_connected_set");
590         else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
591         RNA_def_property_ui_text(prop, "Connected", "When bone has a parent, bone's head is stuck to the parent's tail");
592         RNA_def_property_update(prop, 0, "rna_Armature_update_data");
593         
594         prop = RNA_def_property(srna, "use_inherit_rotation", PROP_BOOLEAN, PROP_NONE);
595         RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", BONE_HINGE);
596         RNA_def_property_ui_text(prop, "Inherit Rotation", "Bone inherits rotation or scale from parent bone");
597         RNA_def_property_update(prop, 0, "rna_Armature_update_data");
598         
599         prop = RNA_def_property(srna, "use_envelope_multiply", PROP_BOOLEAN, PROP_NONE);
600         RNA_def_property_boolean_sdna(prop, NULL, "flag", BONE_MULT_VG_ENV);
601         RNA_def_property_ui_text(prop, "Multiply Vertex Group with Envelope",
602                                  "When deforming bone, multiply effects of Vertex Group weights with Envelope influence");
603         RNA_def_property_update(prop, 0, "rna_Armature_update_data");
604         
605         prop = RNA_def_property(srna, "use_deform", PROP_BOOLEAN, PROP_NONE);
606         RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", BONE_NO_DEFORM);
607         RNA_def_property_ui_text(prop, "Deform", "Enable Bone to deform geometry");
608         RNA_def_property_update(prop, 0, "rna_Armature_update_data");
609         
610         prop = RNA_def_property(srna, "use_inherit_scale", PROP_BOOLEAN, PROP_NONE);
611         RNA_def_property_ui_text(prop, "Inherit Scale", "Bone inherits scaling from parent bone");
612         RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", BONE_NO_SCALE);
613         RNA_def_property_update(prop, 0, "rna_Armature_update_data");
614
615         prop = RNA_def_property(srna, "use_local_location", PROP_BOOLEAN, PROP_NONE);
616         RNA_def_property_ui_text(prop, "Local Location", "Bone location is set in local space");
617         RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", BONE_NO_LOCAL_LOCATION);
618         RNA_def_property_update(prop, 0, "rna_Armature_update_data");
619         
620         prop = RNA_def_property(srna, "use_relative_parent", PROP_BOOLEAN, PROP_NONE);
621         RNA_def_property_ui_text(prop, "Relative Parenting", "Object children will use relative transform, like deform");
622         RNA_def_property_boolean_sdna(prop, NULL, "flag", BONE_RELATIVE_PARENTING);
623         RNA_def_property_update(prop, 0, "rna_Armature_update_data");
624         
625         prop = RNA_def_property(srna, "show_wire", PROP_BOOLEAN, PROP_NONE);
626         RNA_def_property_boolean_sdna(prop, NULL, "flag", BONE_DRAWWIRE);
627         RNA_def_property_ui_text(prop, "Draw Wire",
628                                  "Bone is always drawn as Wireframe regardless of viewport draw mode "
629                                  "(useful for non-obstructive custom bone shapes)");
630         RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
631         
632         /* XXX: use_cyclic_offset is deprecated in 2.5. May/may not return */
633         prop = RNA_def_property(srna, "use_cyclic_offset", PROP_BOOLEAN, PROP_NONE);
634         RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", BONE_NO_CYCLICOFFSET);
635         RNA_def_property_ui_text(prop, "Cyclic Offset",
636                                  "When bone doesn't have a parent, it receives cyclic offset effects (Deprecated)");
637         //                         "When bone doesn't have a parent, it receives cyclic offset effects");
638         RNA_def_property_update(prop, 0, "rna_Armature_update_data");
639         
640         prop = RNA_def_property(srna, "hide_select", PROP_BOOLEAN, PROP_NONE);
641         RNA_def_property_boolean_sdna(prop, NULL, "flag", BONE_UNSELECTABLE);
642         RNA_def_property_ui_text(prop, "Selectable", "Bone is able to be selected");
643         RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
644
645         /* Number values */
646         /* envelope deform settings */
647         prop = RNA_def_property(srna, "envelope_distance", PROP_FLOAT, PROP_NONE);
648         RNA_def_property_float_sdna(prop, NULL, "dist");
649         RNA_def_property_range(prop, 0.0f, 1000.0f);
650         RNA_def_property_ui_text(prop, "Envelope Deform Distance", "Bone deformation distance (for Envelope deform only)");
651         RNA_def_property_update(prop, 0, "rna_Armature_update_data");
652         
653         prop = RNA_def_property(srna, "envelope_weight", PROP_FLOAT, PROP_NONE);
654         RNA_def_property_float_sdna(prop, NULL, "weight");
655         RNA_def_property_range(prop, 0.0f, 1000.0f);
656         RNA_def_property_ui_text(prop, "Envelope Deform Weight", "Bone deformation weight (for Envelope deform only)");
657         RNA_def_property_update(prop, 0, "rna_Armature_update_data");
658         
659         prop = RNA_def_property(srna, "head_radius", PROP_FLOAT, PROP_UNSIGNED);
660         if (editbone) RNA_def_property_update(prop, 0, "rna_Armature_editbone_transform_update");
661         else RNA_def_property_update(prop, 0, "rna_Armature_update_data");
662         RNA_def_property_float_sdna(prop, NULL, "rad_head");
663         /* XXX range is 0 to lim, where lim = 10000.0f * MAX2(1.0, view3d->grid); */
664         /*RNA_def_property_range(prop, 0, 1000); */
665         RNA_def_property_ui_range(prop, 0.01, 100, 0.1, 3);
666         RNA_def_property_ui_text(prop, "Envelope Head Radius", "Radius of head of bone (for Envelope deform only)");
667         
668         prop = RNA_def_property(srna, "tail_radius", PROP_FLOAT, PROP_UNSIGNED);
669         if (editbone) RNA_def_property_update(prop, 0, "rna_Armature_editbone_transform_update");
670         else RNA_def_property_update(prop, 0, "rna_Armature_update_data");
671         RNA_def_property_float_sdna(prop, NULL, "rad_tail");
672         /* XXX range is 0 to lim, where lim = 10000.0f * MAX2(1.0, view3d->grid); */
673         /*RNA_def_property_range(prop, 0, 1000); */
674         RNA_def_property_ui_range(prop, 0.01, 100, 0.1, 3);
675         RNA_def_property_ui_text(prop, "Envelope Tail Radius", "Radius of tail of bone (for Envelope deform only)");
676         
677         /* b-bones deform settings */
678         prop = RNA_def_property(srna, "bbone_segments", PROP_INT, PROP_NONE);
679         RNA_def_property_int_sdna(prop, NULL, "segments");
680         RNA_def_property_range(prop, 1, 32);
681         RNA_def_property_ui_text(prop, "B-Bone Segments", "Number of subdivisions of bone (for B-Bones only)");
682         RNA_def_property_update(prop, 0, "rna_Armature_update_data");
683         
684         prop = RNA_def_property(srna, "bbone_in", PROP_FLOAT, PROP_NONE);
685         RNA_def_property_float_sdna(prop, NULL, "ease1");
686         RNA_def_property_range(prop, 0.0f, 2.0f);
687         RNA_def_property_ui_text(prop, "B-Bone Ease In", "Length of first Bezier Handle (for B-Bones only)");
688         RNA_def_property_update(prop, 0, "rna_Armature_update_data");
689         
690         prop = RNA_def_property(srna, "bbone_out", PROP_FLOAT, PROP_NONE);
691         RNA_def_property_float_sdna(prop, NULL, "ease2");
692         RNA_def_property_range(prop, 0.0f, 2.0f);
693         RNA_def_property_ui_text(prop, "B-Bone Ease Out", "Length of second Bezier Handle (for B-Bones only)");
694         RNA_def_property_update(prop, 0, "rna_Armature_update_data");
695
696         prop = RNA_def_property(srna, "bbone_x", PROP_FLOAT, PROP_NONE);
697         RNA_def_property_float_sdna(prop, NULL, "xwidth");
698         RNA_def_property_range(prop, 0.0f, 1000.0f);
699         RNA_def_property_ui_text(prop, "B-Bone Display X Width", "B-Bone X size");
700         RNA_def_property_update(prop, 0, "rna_Armature_update_data");
701         
702         prop = RNA_def_property(srna, "bbone_z", PROP_FLOAT, PROP_NONE);
703         RNA_def_property_float_sdna(prop, NULL, "zwidth");
704         RNA_def_property_range(prop, 0.0f, 1000.0f);
705         RNA_def_property_ui_text(prop, "B-Bone Display Z Width", "B-Bone Z size");
706         RNA_def_property_update(prop, 0, "rna_Armature_update_data");
707 }
708
709 /* err... bones should not be directly edited (only editbones should be...) */
710 static void rna_def_bone(BlenderRNA *brna)
711 {
712         StructRNA *srna;
713         PropertyRNA *prop;
714         
715         srna = RNA_def_struct(brna, "Bone", NULL);
716         RNA_def_struct_ui_text(srna, "Bone", "Bone in an Armature data-block");
717         RNA_def_struct_ui_icon(srna, ICON_BONE_DATA);
718         RNA_def_struct_path_func(srna, "rna_Bone_path");
719         RNA_def_struct_idprops_func(srna, "rna_Bone_idprops");
720         
721         /* pointers/collections */
722         /* parent (pointer) */
723         prop = RNA_def_property(srna, "parent", PROP_POINTER, PROP_NONE);
724         RNA_def_property_struct_type(prop, "Bone");
725         RNA_def_property_pointer_sdna(prop, NULL, "parent");
726         RNA_def_property_ui_text(prop, "Parent", "Parent bone (in same Armature)");
727         RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
728         
729         /* children (collection) */
730         prop = RNA_def_property(srna, "children", PROP_COLLECTION, PROP_NONE);
731         RNA_def_property_collection_sdna(prop, NULL, "childbase", NULL);
732         RNA_def_property_struct_type(prop, "Bone");
733         RNA_def_property_ui_text(prop, "Children", "Bones which are children of this bone");
734
735         rna_def_bone_common(srna, 0);
736         rna_def_bone_curved_common(srna, 0);
737
738         /* XXX should we define this in PoseChannel wrapping code instead?
739          *     But PoseChannels directly get some of their flags from here... */
740         prop = RNA_def_property(srna, "hide", PROP_BOOLEAN, PROP_NONE);
741         RNA_def_property_boolean_sdna(prop, NULL, "flag", BONE_HIDDEN_P);
742         RNA_def_property_ui_text(prop, "Hide",
743                                  "Bone is not visible when it is not in Edit Mode (i.e. in Object or Pose Modes)");
744         RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
745
746         prop = RNA_def_property(srna, "select", PROP_BOOLEAN, PROP_NONE);
747         RNA_def_property_boolean_sdna(prop, NULL, "flag", BONE_SELECTED);
748         RNA_def_property_ui_text(prop, "Select", "");
749         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE); /* XXX: review whether this could be used for interesting effects... */
750         RNA_def_property_update(prop, 0, "rna_Bone_select_update");
751         
752         prop = RNA_def_property(srna, "select_head", PROP_BOOLEAN, PROP_NONE);
753         RNA_def_property_boolean_sdna(prop, NULL, "flag", BONE_ROOTSEL);
754         RNA_def_property_ui_text(prop, "Select Head", "");
755         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
756         RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
757         
758         prop = RNA_def_property(srna, "select_tail", PROP_BOOLEAN, PROP_NONE);
759         RNA_def_property_boolean_sdna(prop, NULL, "flag", BONE_TIPSEL);
760         RNA_def_property_ui_text(prop, "Select Tail", "");
761         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
762         RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
763
764         /* XXX better matrix descriptions possible (Arystan) */
765         prop = RNA_def_property(srna, "matrix", PROP_FLOAT, PROP_MATRIX);
766         RNA_def_property_float_sdna(prop, NULL, "bone_mat");
767         RNA_def_property_multi_array(prop, 2, rna_matrix_dimsize_3x3);
768         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
769         RNA_def_property_ui_text(prop, "Bone Matrix", "3x3 bone matrix");
770
771         prop = RNA_def_property(srna, "matrix_local", PROP_FLOAT, PROP_MATRIX);
772         RNA_def_property_float_sdna(prop, NULL, "arm_mat");
773         RNA_def_property_multi_array(prop, 2, rna_matrix_dimsize_4x4);
774         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
775         RNA_def_property_ui_text(prop, "Bone Armature-Relative Matrix", "4x4 bone matrix relative to armature");
776
777         prop = RNA_def_property(srna, "tail", PROP_FLOAT, PROP_TRANSLATION);
778         RNA_def_property_float_sdna(prop, NULL, "tail");
779         RNA_def_property_array(prop, 3);
780         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
781         RNA_def_property_ui_text(prop, "Tail", "Location of tail end of the bone");
782         RNA_def_property_ui_range(prop, -FLT_MAX, FLT_MAX, 1, RNA_TRANSLATION_PREC_DEFAULT);
783
784         prop = RNA_def_property(srna, "tail_local", PROP_FLOAT, PROP_TRANSLATION);
785         RNA_def_property_float_sdna(prop, NULL, "arm_tail");
786         RNA_def_property_array(prop, 3);
787         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
788         RNA_def_property_ui_text(prop, "Armature-Relative Tail", "Location of tail end of the bone relative to armature");
789         RNA_def_property_ui_range(prop, -FLT_MAX, FLT_MAX, 1, RNA_TRANSLATION_PREC_DEFAULT);
790
791         prop = RNA_def_property(srna, "head", PROP_FLOAT, PROP_TRANSLATION);
792         RNA_def_property_float_sdna(prop, NULL, "head");
793         RNA_def_property_array(prop, 3);
794         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
795         RNA_def_property_ui_text(prop, "Head", "Location of head end of the bone relative to its parent");
796         RNA_def_property_ui_range(prop, -FLT_MAX, FLT_MAX, 1, RNA_TRANSLATION_PREC_DEFAULT);
797
798         prop = RNA_def_property(srna, "head_local", PROP_FLOAT, PROP_TRANSLATION);
799         RNA_def_property_float_sdna(prop, NULL, "arm_head");
800         RNA_def_property_array(prop, 3);
801         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
802         RNA_def_property_ui_text(prop, "Armature-Relative Head", "Location of head end of the bone relative to armature");
803         RNA_def_property_ui_range(prop, -FLT_MAX, FLT_MAX, 1, RNA_TRANSLATION_PREC_DEFAULT);
804
805         RNA_api_bone(srna);
806 }
807
808 static void rna_def_edit_bone(BlenderRNA *brna)
809 {
810         StructRNA *srna;
811         PropertyRNA *prop;
812         
813         srna = RNA_def_struct(brna, "EditBone", NULL);
814         RNA_def_struct_sdna(srna, "EditBone");
815         RNA_def_struct_idprops_func(srna, "rna_EditBone_idprops");
816         RNA_def_struct_ui_text(srna, "Edit Bone", "Editmode bone in an Armature data-block");
817         RNA_def_struct_ui_icon(srna, ICON_BONE_DATA);
818         
819         RNA_define_verify_sdna(0); /* not in sdna */
820
821         prop = RNA_def_property(srna, "parent", PROP_POINTER, PROP_NONE);
822         RNA_def_property_struct_type(prop, "EditBone");
823         RNA_def_property_pointer_funcs(prop, "rna_EditBone_parent_get", "rna_EditBone_parent_set", NULL, NULL);
824         RNA_def_property_flag(prop, PROP_EDITABLE);
825         RNA_def_property_ui_text(prop, "Parent", "Parent edit bone (in same Armature)");
826         RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
827         
828         prop = RNA_def_property(srna, "roll", PROP_FLOAT, PROP_ANGLE);
829         RNA_def_property_float_sdna(prop, NULL, "roll");
830         RNA_def_property_ui_range(prop, -M_PI * 2, M_PI * 2, 10, 2);
831         RNA_def_property_ui_text(prop, "Roll", "Bone rotation around head-tail axis");
832         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
833         RNA_def_property_update(prop, 0, "rna_Armature_editbone_transform_update");
834
835         prop = RNA_def_property(srna, "head", PROP_FLOAT, PROP_TRANSLATION);
836         RNA_def_property_float_sdna(prop, NULL, "head");
837         RNA_def_property_array(prop, 3);
838         RNA_def_property_ui_text(prop, "Head", "Location of head end of the bone");
839         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
840         RNA_def_property_update(prop, 0, "rna_Armature_editbone_transform_update");
841
842         prop = RNA_def_property(srna, "tail", PROP_FLOAT, PROP_TRANSLATION);
843         RNA_def_property_float_sdna(prop, NULL, "tail");
844         RNA_def_property_array(prop, 3);
845         RNA_def_property_ui_text(prop, "Tail", "Location of tail end of the bone");
846         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
847         RNA_def_property_update(prop, 0, "rna_Armature_editbone_transform_update");
848
849         rna_def_bone_common(srna, 1);
850         rna_def_bone_curved_common(srna, 0);
851
852         prop = RNA_def_property(srna, "hide", PROP_BOOLEAN, PROP_NONE);
853         RNA_def_property_boolean_sdna(prop, NULL, "flag", BONE_HIDDEN_A);
854         RNA_def_property_ui_text(prop, "Hide", "Bone is not visible when in Edit Mode");
855         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
856         RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
857
858         prop = RNA_def_property(srna, "lock", PROP_BOOLEAN, PROP_NONE);
859         RNA_def_property_boolean_sdna(prop, NULL, "flag", BONE_EDITMODE_LOCKED);
860         RNA_def_property_ui_text(prop, "Lock", "Bone is not able to be transformed when in Edit Mode");
861         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
862         RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
863
864         prop = RNA_def_property(srna, "select", PROP_BOOLEAN, PROP_NONE);
865         RNA_def_property_boolean_sdna(prop, NULL, "flag", BONE_SELECTED);
866         RNA_def_property_ui_text(prop, "Select", "");
867         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
868         RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
869
870         prop = RNA_def_property(srna, "select_head", PROP_BOOLEAN, PROP_NONE);
871         RNA_def_property_boolean_sdna(prop, NULL, "flag", BONE_ROOTSEL);
872         RNA_def_property_ui_text(prop, "Head Select", "");
873         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
874         RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
875         
876         prop = RNA_def_property(srna, "select_tail", PROP_BOOLEAN, PROP_NONE);
877         RNA_def_property_boolean_sdna(prop, NULL, "flag", BONE_TIPSEL);
878         RNA_def_property_ui_text(prop, "Tail Select", "");
879         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
880         RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
881
882         /* calculated and read only, not actual data access */
883         prop = RNA_def_property(srna, "matrix", PROP_FLOAT, PROP_MATRIX);
884         /*RNA_def_property_float_sdna(prop, NULL, "");  *//* doesnt access any real data */
885         RNA_def_property_multi_array(prop, 2, rna_matrix_dimsize_4x4);
886         //RNA_def_property_clear_flag(prop, PROP_EDITABLE);
887         RNA_def_property_flag(prop, PROP_THICK_WRAP); /* no reference to original data */
888         RNA_def_property_ui_text(prop, "Editbone Matrix",
889                                  "Matrix combining loc/rot of the bone (head position, direction and roll), "
890                                  "in armature space (WARNING: does not include/support bone's length/size)");
891         RNA_def_property_float_funcs(prop, "rna_EditBone_matrix_get", "rna_EditBone_matrix_set", NULL);
892
893         RNA_api_armature_edit_bone(srna);
894
895         RNA_define_verify_sdna(1);
896 }
897
898
899 /* armature.bones.* */
900 static void rna_def_armature_bones(BlenderRNA *brna, PropertyRNA *cprop)
901 {
902         StructRNA *srna;
903         PropertyRNA *prop;
904
905 /*      FunctionRNA *func; */
906 /*      PropertyRNA *parm; */
907
908         RNA_def_property_srna(cprop, "ArmatureBones");
909         srna = RNA_def_struct(brna, "ArmatureBones", NULL);
910         RNA_def_struct_sdna(srna, "bArmature");
911         RNA_def_struct_ui_text(srna, "Armature Bones", "Collection of armature bones");
912
913
914         prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
915         RNA_def_property_struct_type(prop, "Bone");
916         RNA_def_property_pointer_sdna(prop, NULL, "act_bone");
917         RNA_def_property_flag(prop, PROP_EDITABLE);
918         RNA_def_property_ui_text(prop, "Active Bone", "Armature's active bone");
919         RNA_def_property_pointer_funcs(prop, NULL, "rna_Armature_act_bone_set", NULL, NULL);
920
921         /* todo, redraw */
922 /*              RNA_def_property_collection_active(prop, prop_act); */
923 }
924
925 /* armature.bones.* */
926 static void rna_def_armature_edit_bones(BlenderRNA *brna, PropertyRNA *cprop)
927 {
928         StructRNA *srna;
929         PropertyRNA *prop;
930
931         FunctionRNA *func;
932         PropertyRNA *parm;
933
934         RNA_def_property_srna(cprop, "ArmatureEditBones");
935         srna = RNA_def_struct(brna, "ArmatureEditBones", NULL);
936         RNA_def_struct_sdna(srna, "bArmature");
937         RNA_def_struct_ui_text(srna, "Armature EditBones", "Collection of armature edit bones");
938
939         prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
940         RNA_def_property_struct_type(prop, "EditBone");
941         RNA_def_property_pointer_sdna(prop, NULL, "act_edbone");
942         RNA_def_property_flag(prop, PROP_EDITABLE);
943         RNA_def_property_ui_text(prop, "Active EditBone", "Armatures active edit bone");
944         /*RNA_def_property_update(prop, 0, "rna_Armature_act_editbone_update"); */
945         RNA_def_property_pointer_funcs(prop, NULL, "rna_Armature_act_edit_bone_set", NULL, NULL);
946
947         /* todo, redraw */
948 /*              RNA_def_property_collection_active(prop, prop_act); */
949
950         /* add target */
951         func = RNA_def_function(srna, "new", "rna_Armature_edit_bone_new");
952         RNA_def_function_flag(func, FUNC_USE_REPORTS);
953         RNA_def_function_ui_description(func, "Add a new bone");
954         parm = RNA_def_string(func, "name", "Object", 0, "", "New name for the bone");
955         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
956         /* return type */
957         parm = RNA_def_pointer(func, "bone", "EditBone", "", "Newly created edit bone");
958         RNA_def_function_return(func, parm);
959
960         /* remove target */
961         func = RNA_def_function(srna, "remove", "rna_Armature_edit_bone_remove");
962         RNA_def_function_flag(func, FUNC_USE_REPORTS);
963         RNA_def_function_ui_description(func, "Remove an existing bone from the armature");
964         /* target to remove*/
965         parm = RNA_def_pointer(func, "bone", "EditBone", "", "EditBone to remove");
966         RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED | PARM_RNAPTR);
967         RNA_def_parameter_clear_flags(parm, PROP_THICK_WRAP, 0);
968 }
969
970 static void rna_def_armature(BlenderRNA *brna)
971 {
972         StructRNA *srna;
973         PropertyRNA *prop;
974
975         FunctionRNA *func;
976         PropertyRNA *parm;
977
978         static EnumPropertyItem prop_drawtype_items[] = {
979                 {ARM_OCTA, "OCTAHEDRAL", 0, "Octahedral", "Display bones as octahedral shape (default)"},
980                 {ARM_LINE, "STICK", 0, "Stick", "Display bones as simple 2D lines with dots"},
981                 {ARM_B_BONE, "BBONE", 0, "B-Bone", "Display bones as boxes, showing subdivision and B-Splines"},
982                 {ARM_ENVELOPE, "ENVELOPE", 0, "Envelope",
983                                "Display bones as extruded spheres, showing deformation influence volume"},
984                 {ARM_WIRE, "WIRE", 0, "Wire", "Display bones as thin wires, showing subdivision and B-Splines"},
985                 {0, NULL, 0, NULL, NULL}
986         };
987         static EnumPropertyItem prop_vdeformer[] = {
988                 {ARM_VDEF_BLENDER, "BLENDER", 0, "Blender", "Use Blender's armature vertex deformation"},
989                 {ARM_VDEF_BGE_CPU, "BGE_CPU", 0, "BGE", "Use vertex deformation code optimized for the BGE"},
990                 {0, NULL, 0, NULL, NULL}
991         };
992         static EnumPropertyItem prop_ghost_type_items[] = {
993                 {ARM_GHOST_CUR, "CURRENT_FRAME", 0, "Around Frame",
994                                 "Display Ghosts of poses within a fixed number of frames around the current frame"},
995                 {ARM_GHOST_RANGE, "RANGE", 0, "In Range", "Display Ghosts of poses within specified range"},
996                 {ARM_GHOST_KEYS, "KEYS", 0, "On Keyframes", "Display Ghosts of poses on Keyframes"},
997                 {0, NULL, 0, NULL, NULL}
998         };
999         static const EnumPropertyItem prop_pose_position_items[] = {
1000                 {0, "POSE", 0, "Pose Position", "Show armature in posed state"},
1001                 {ARM_RESTPOS, "REST", 0, "Rest Position", "Show Armature in binding pose state (no posing possible)"},
1002                 {0, NULL, 0, NULL, NULL}
1003         };
1004         
1005         srna = RNA_def_struct(brna, "Armature", "ID");
1006         RNA_def_struct_ui_text(srna, "Armature",
1007                                "Armature data-block containing a hierarchy of bones, usually used for rigging characters");
1008         RNA_def_struct_ui_icon(srna, ICON_ARMATURE_DATA);
1009         RNA_def_struct_sdna(srna, "bArmature");
1010
1011         func = RNA_def_function(srna, "transform", "rna_Armature_transform");
1012         RNA_def_function_ui_description(func, "Transform armature bones by a matrix");
1013         parm = RNA_def_float_matrix(func, "matrix", 4, 4, NULL, 0.0f, 0.0f, "", "Matrix", 0.0f, 0.0f);
1014         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
1015
1016         /* Animation Data */
1017         rna_def_animdata_common(srna);
1018         
1019         /* Collections */
1020         prop = RNA_def_property(srna, "bones", PROP_COLLECTION, PROP_NONE);
1021         RNA_def_property_collection_sdna(prop, NULL, "bonebase", NULL);
1022         RNA_def_property_collection_funcs(prop, NULL, "rna_Armature_bones_next", NULL, NULL, NULL, NULL, NULL, NULL);
1023         RNA_def_property_struct_type(prop, "Bone");
1024         RNA_def_property_ui_text(prop, "Bones", "");
1025         rna_def_armature_bones(brna, prop);
1026
1027         prop = RNA_def_property(srna, "edit_bones", PROP_COLLECTION, PROP_NONE);
1028         RNA_def_property_collection_sdna(prop, NULL, "edbo", NULL);
1029         RNA_def_property_struct_type(prop, "EditBone");
1030         RNA_def_property_ui_text(prop, "Edit Bones", "");
1031         rna_def_armature_edit_bones(brna, prop);
1032
1033         /* Enum values */
1034         prop = RNA_def_property(srna, "pose_position", PROP_ENUM, PROP_NONE);
1035         RNA_def_property_enum_bitflag_sdna(prop, NULL, "flag");
1036         RNA_def_property_enum_items(prop, prop_pose_position_items);
1037         RNA_def_property_ui_text(prop, "Pose Position", "Show armature in binding pose or final posed state");
1038         RNA_def_property_update(prop, 0, "rna_Armature_update_data");
1039         RNA_def_property_flag(prop, PROP_LIB_EXCEPTION);
1040         
1041         prop = RNA_def_property(srna, "draw_type", PROP_ENUM, PROP_NONE);
1042         RNA_def_property_enum_sdna(prop, NULL, "drawtype");
1043         RNA_def_property_enum_items(prop, prop_drawtype_items);
1044         RNA_def_property_ui_text(prop, "Draw Type", "");
1045         RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
1046         RNA_def_property_flag(prop, PROP_LIB_EXCEPTION);
1047
1048         prop = RNA_def_property(srna, "deform_method", PROP_ENUM, PROP_NONE);
1049         RNA_def_property_enum_sdna(prop, NULL, "gevertdeformer");
1050         RNA_def_property_enum_items(prop, prop_vdeformer);
1051         RNA_def_property_ui_text(prop, "Vertex Deformer", "Vertex Deformer Method (Game Engine only)");
1052         RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
1053         RNA_def_property_flag(prop, PROP_LIB_EXCEPTION);
1054         
1055 /* XXX deprecated ....... old animviz for armatures only */
1056         prop = RNA_def_property(srna, "ghost_type", PROP_ENUM, PROP_NONE);
1057         RNA_def_property_enum_sdna(prop, NULL, "ghosttype");
1058         RNA_def_property_enum_items(prop, prop_ghost_type_items);
1059         RNA_def_property_ui_text(prop, "Ghost Type", "Method of Onion-skinning for active Action");
1060         RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
1061         RNA_def_property_flag(prop, PROP_LIB_EXCEPTION);
1062 /* XXX deprecated ....... old animviz for armatures only         */
1063
1064         /* Boolean values */
1065         /* layer */
1066         prop = RNA_def_property(srna, "layers", PROP_BOOLEAN, PROP_LAYER_MEMBER);
1067         RNA_def_property_boolean_sdna(prop, NULL, "layer", 1);
1068         RNA_def_property_array(prop, 32);
1069         RNA_def_property_ui_text(prop, "Visible Layers", "Armature layer visibility");
1070         RNA_def_property_boolean_funcs(prop, NULL, "rna_Armature_layer_set");
1071         RNA_def_property_update(prop, NC_OBJECT | ND_POSE, "rna_Armature_update_layers");
1072         RNA_def_property_flag(prop, PROP_LIB_EXCEPTION);
1073         
1074         /* layer protection */
1075         prop = RNA_def_property(srna, "layers_protected", PROP_BOOLEAN, PROP_LAYER);
1076         RNA_def_property_boolean_sdna(prop, NULL, "layer_protected", 1);
1077         RNA_def_property_array(prop, 32);
1078         RNA_def_property_ui_text(prop, "Layer Proxy Protection",
1079                                  "Protected layers in Proxy Instances are restored to Proxy settings "
1080                                  "on file reload and undo");
1081         RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
1082                 
1083         /* flag */
1084         prop = RNA_def_property(srna, "show_axes", PROP_BOOLEAN, PROP_NONE);
1085         RNA_def_property_boolean_sdna(prop, NULL, "flag", ARM_DRAWAXES);
1086         RNA_def_property_ui_text(prop, "Draw Axes", "Draw bone axes");
1087         RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
1088         RNA_def_property_flag(prop, PROP_LIB_EXCEPTION);
1089         
1090         prop = RNA_def_property(srna, "show_names", PROP_BOOLEAN, PROP_NONE);
1091         RNA_def_property_boolean_sdna(prop, NULL, "flag", ARM_DRAWNAMES);
1092         RNA_def_property_ui_text(prop, "Draw Names", "Draw bone names");
1093         RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
1094         RNA_def_property_flag(prop, PROP_LIB_EXCEPTION);
1095         
1096         prop = RNA_def_property(srna, "use_deform_delay", PROP_BOOLEAN, PROP_NONE);
1097         RNA_def_property_boolean_sdna(prop, NULL, "flag", ARM_DELAYDEFORM);
1098         RNA_def_property_ui_text(prop, "Delay Deform", "Don't deform children when manipulating bones in Pose Mode");
1099         RNA_def_property_update(prop, 0, "rna_Armature_update_data");
1100         
1101         prop = RNA_def_property(srna, "use_mirror_x", PROP_BOOLEAN, PROP_NONE);
1102         RNA_def_property_boolean_sdna(prop, NULL, "flag", ARM_MIRROR_EDIT);
1103         RNA_def_property_ui_text(prop, "X-Axis Mirror", "Apply changes to matching bone on opposite side of X-Axis");
1104         RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
1105         RNA_def_property_flag(prop, PROP_LIB_EXCEPTION);
1106         
1107         prop = RNA_def_property(srna, "use_auto_ik", PROP_BOOLEAN, PROP_NONE);
1108         RNA_def_property_boolean_sdna(prop, NULL, "flag", ARM_AUTO_IK);
1109         RNA_def_property_ui_text(prop, "Auto IK", "Add temporary IK constraints while grabbing bones in Pose Mode");
1110         RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
1111         RNA_def_property_flag(prop, PROP_LIB_EXCEPTION);
1112         
1113         prop = RNA_def_property(srna, "show_bone_custom_shapes", PROP_BOOLEAN, PROP_NONE);
1114         RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", ARM_NO_CUSTOM);
1115         RNA_def_property_ui_text(prop, "Draw Custom Bone Shapes", "Draw bones with their custom shapes");
1116         RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
1117         
1118         prop = RNA_def_property(srna, "show_group_colors", PROP_BOOLEAN, PROP_NONE);
1119         RNA_def_property_boolean_sdna(prop, NULL, "flag", ARM_COL_CUSTOM);
1120         RNA_def_property_ui_text(prop, "Draw Bone Group Colors", "Draw bone group colors");
1121         RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
1122         
1123 /* XXX deprecated ....... old animviz for armatures only */
1124         prop = RNA_def_property(srna, "show_only_ghost_selected", PROP_BOOLEAN, PROP_NONE);
1125         RNA_def_property_boolean_sdna(prop, NULL, "flag", ARM_GHOST_ONLYSEL);
1126         RNA_def_property_ui_text(prop, "Draw Ghosts on Selected Bones Only", "");
1127         RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
1128         RNA_def_property_flag(prop, PROP_LIB_EXCEPTION);
1129 /* XXX deprecated ....... old animviz for armatures only */
1130
1131         /* Number fields */
1132 /* XXX deprecated ....... old animviz for armatures only */
1133         /* ghost/onionskining settings */
1134         prop = RNA_def_property(srna, "ghost_step", PROP_INT, PROP_NONE);
1135         RNA_def_property_int_sdna(prop, NULL, "ghostep");
1136         RNA_def_property_range(prop, 0, 30);
1137         RNA_def_property_ui_text(prop, "Ghosting Step",
1138                                  "Number of frame steps on either side of current frame to show as ghosts "
1139                                  "(only for 'Around Current Frame' Onion-skinning method)");
1140         RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
1141         RNA_def_property_flag(prop, PROP_LIB_EXCEPTION);
1142         
1143         prop = RNA_def_property(srna, "ghost_size", PROP_INT, PROP_NONE);
1144         RNA_def_property_int_sdna(prop, NULL, "ghostsize");
1145         RNA_def_property_range(prop, 1, 20);
1146         RNA_def_property_ui_text(prop, "Ghosting Frame Step",
1147                                  "Frame step for Ghosts (not for 'On Keyframes' Onion-skinning method)");
1148         RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
1149         RNA_def_property_flag(prop, PROP_LIB_EXCEPTION);
1150         
1151         prop = RNA_def_property(srna, "ghost_frame_start", PROP_INT, PROP_TIME);
1152         RNA_def_property_int_sdna(prop, NULL, "ghostsf");
1153         RNA_def_property_int_funcs(prop, NULL, "rna_Armature_ghost_start_frame_set", NULL);
1154         RNA_def_property_ui_text(prop, "Ghosting Start Frame",
1155                                  "Starting frame of range of Ghosts to display (not for "
1156                                  "'Around Current Frame' Onion-skinning method)");
1157         RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
1158         RNA_def_property_flag(prop, PROP_LIB_EXCEPTION);
1159         
1160         prop = RNA_def_property(srna, "ghost_frame_end", PROP_INT, PROP_TIME);
1161         RNA_def_property_int_sdna(prop, NULL, "ghostef");
1162         RNA_def_property_int_funcs(prop, NULL, "rna_Armature_ghost_end_frame_set", NULL);
1163         RNA_def_property_ui_text(prop, "Ghosting End Frame",
1164                                  "End frame of range of Ghosts to display "
1165                                  "(not for 'Around Current Frame' Onion-skinning method)");
1166         RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
1167         RNA_def_property_flag(prop, PROP_LIB_EXCEPTION);
1168 /* XXX deprecated ....... old animviz for armatures only */
1169
1170
1171         prop = RNA_def_property(srna, "is_editmode", PROP_BOOLEAN, PROP_NONE);
1172         RNA_def_property_boolean_funcs(prop, "rna_Armature_is_editmode_get", NULL);
1173         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1174         RNA_def_property_ui_text(prop, "Is Editmode", "True when used in editmode");
1175 }
1176
1177 void RNA_def_armature(BlenderRNA *brna)
1178 {
1179         rna_def_armature(brna);
1180         rna_def_bone(brna);
1181         rna_def_edit_bone(brna);
1182 }
1183
1184 #endif