2.5: Various Fixes
[blender.git] / source / blender / makesrna / intern / rna_armature.c
1 /**
2  * $Id$
3  *
4  * ***** BEGIN GPL LICENSE BLOCK *****
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * as published by the Free Software Foundation; either version 2
9  * of the License, or (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software Foundation,
18  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
19  *
20  * Contributor(s): Blender Foundation (2008), Joshua Leung
21  *
22  * ***** END GPL LICENSE BLOCK *****
23  */
24
25 #include <stdlib.h>
26
27 #include "RNA_define.h"
28 #include "RNA_types.h"
29
30 #include "rna_internal.h"
31
32 #include "DNA_armature_types.h"
33 #include "DNA_object_types.h"
34 #include "DNA_scene_types.h"
35
36 #include "WM_api.h"
37 #include "WM_types.h"
38
39 #ifdef RNA_RUNTIME
40
41 #include "BLI_arithb.h"
42
43 #include "BKE_context.h"
44 #include "BKE_depsgraph.h"
45 #include "BKE_main.h"
46
47 #include "ED_armature.h"
48
49 static void rna_Armature_update_data(bContext *C, PointerRNA *ptr)
50 {
51         Main *bmain= CTX_data_main(C);
52         Scene *scene= CTX_data_scene(C);
53         ID *id= ptr->id.data;
54         Object *ob;
55
56         for(ob=bmain->object.first; ob; ob= ob->id.next) {
57                 if(ob->data == id) {
58                         /* XXX this will loop over all objects again (slow) */
59                         DAG_object_flush_update(scene, ob, OB_RECALC_DATA);
60                         WM_event_add_notifier(C, NC_OBJECT|ND_GEOM_DATA, ob);
61                 }
62         }
63 }
64
65 static void rna_Armature_redraw_data(bContext *C, PointerRNA *ptr)
66 {
67         Main *bmain= CTX_data_main(C);
68         ID *id= ptr->id.data;
69         Object *ob;
70
71         for(ob=bmain->object.first; ob; ob= ob->id.next)
72                 if(ob->data == id)
73                         WM_event_add_notifier(C, NC_OBJECT|ND_GEOM_DATA, ob);
74 }
75
76 static void rna_bone_layer_set(short *layer, const int *values)
77 {
78         int i, tot= 0;
79
80         /* ensure we always have some layer selected */
81         for(i=0; i<16; i++)
82                 if(values[i])
83                         tot++;
84         
85         if(tot==0)
86                 return;
87
88         for(i=0; i<16; i++) {
89                 if(values[i]) *layer |= (1<<i);
90                 else *layer &= ~(1<<i);
91         }
92 }
93
94 static void rna_Bone_layer_set(PointerRNA *ptr, const int *values)
95 {
96         Bone *bone= (Bone*)ptr->data;
97         rna_bone_layer_set(&bone->layer, values);
98 }
99
100 static void rna_Armature_layer_set(PointerRNA *ptr, const int *values)
101 {
102         bArmature *arm= (bArmature*)ptr->data;
103         int i, tot= 0;
104
105         /* ensure we always have some layer selected */
106         for(i=0; i<20; i++)
107                 if(values[i])
108                         tot++;
109         
110         if(tot==0)
111                 return;
112
113         for(i=0; i<20; i++) {
114                 if(values[i]) arm->layer |= (1<<i);
115                 else arm->layer &= ~(1<<i);
116         }
117 }
118
119 static void rna_Armature_ghost_start_frame_set(PointerRNA *ptr, int value)
120 {
121         bArmature *data= (bArmature*)ptr->data;
122         CLAMP(value, 1, data->ghostef);
123         data->ghostsf= value;
124 }
125
126 static void rna_Armature_ghost_end_frame_set(PointerRNA *ptr, int value)
127 {
128         bArmature *data= (bArmature*)ptr->data;
129         CLAMP(value, data->ghostsf, (int)(MAXFRAMEF/2));
130         data->ghostef= value;
131 }
132
133 static void rna_Armature_path_start_frame_set(PointerRNA *ptr, int value)
134 {
135         bArmature *data= (bArmature*)ptr->data;
136         CLAMP(value, 1, data->pathef);
137         data->pathsf= value;
138 }
139
140 static void rna_Armature_path_end_frame_set(PointerRNA *ptr, int value)
141 {
142         bArmature *data= (bArmature*)ptr->data;
143         CLAMP(value, data->pathsf, (int)(MAXFRAMEF/2));
144         data->pathef= value;
145 }
146
147 static void rna_EditBone_name_set(PointerRNA *ptr, const char *value)
148 {
149         bArmature *arm= (bArmature*)ptr->id.data;
150         EditBone *ebone= (EditBone*)ptr->data;
151         char oldname[32], newname[32];
152         
153         /* need to be on the stack */
154         BLI_strncpy(newname, value, 32);
155         BLI_strncpy(oldname, ebone->name, 32);
156         
157         ED_armature_bone_rename(arm, oldname, newname);
158 }
159
160 static void rna_Bone_name_set(PointerRNA *ptr, const char *value)
161 {
162         bArmature *arm= (bArmature*)ptr->id.data;
163         Bone *bone= (Bone*)ptr->data;
164         char oldname[32], newname[32];
165         
166         /* need to be on the stack */
167         BLI_strncpy(newname, value, 32);
168         BLI_strncpy(oldname, bone->name, 32);
169         
170         ED_armature_bone_rename(arm, oldname, newname);
171 }
172
173 static void rna_EditBone_layer_get(PointerRNA *ptr, int values[16])
174 {
175         EditBone *data= (EditBone*)(ptr->data);
176         values[0]= ((data->layer & (1<<0)) != 0);
177         values[1]= ((data->layer & (1<<1)) != 0);
178         values[2]= ((data->layer & (1<<2)) != 0);
179         values[3]= ((data->layer & (1<<3)) != 0);
180         values[4]= ((data->layer & (1<<4)) != 0);
181         values[5]= ((data->layer & (1<<5)) != 0);
182         values[6]= ((data->layer & (1<<6)) != 0);
183         values[7]= ((data->layer & (1<<7)) != 0);
184         values[8]= ((data->layer & (1<<8)) != 0);
185         values[9]= ((data->layer & (1<<9)) != 0);
186         values[10]= ((data->layer & (1<<10)) != 0);
187         values[11]= ((data->layer & (1<<11)) != 0);
188         values[12]= ((data->layer & (1<<12)) != 0);
189         values[13]= ((data->layer & (1<<13)) != 0);
190         values[14]= ((data->layer & (1<<14)) != 0);
191         values[15]= ((data->layer & (1<<15)) != 0);
192 }
193
194 static void rna_EditBone_layer_set(PointerRNA *ptr, const int values[16])
195 {
196         EditBone *data= (EditBone*)(ptr->data);
197         rna_bone_layer_set(&data->layer, values);
198 }
199
200 static void rna_EditBone_connected_check(EditBone *ebone)
201 {
202         if(ebone->parent) {
203                 if(ebone->flag & BONE_CONNECTED) {
204                         /* Attach this bone to its parent */
205                         VECCOPY(ebone->head, ebone->parent->tail);
206
207                         if(ebone->flag & BONE_ROOTSEL)
208                                 ebone->parent->flag |= BONE_TIPSEL;
209                 }
210                 else if(!(ebone->parent->flag & BONE_ROOTSEL)) {
211                         ebone->parent->flag &= ~BONE_TIPSEL;
212                 }
213         }
214 }
215
216 static void rna_EditBone_connected_set(PointerRNA *ptr, int value)
217 {
218         EditBone *ebone= (EditBone*)(ptr->data);
219
220         if(value) ebone->flag |= BONE_CONNECTED;
221         else ebone->flag &= ~BONE_CONNECTED;
222
223         rna_EditBone_connected_check(ebone);
224 }
225
226 static PointerRNA rna_EditBone_parent_get(PointerRNA *ptr)
227 {
228         EditBone *data= (EditBone*)(ptr->data);
229         return rna_pointer_inherit_refine(ptr, &RNA_EditBone, data->parent);
230 }
231
232 static void rna_EditBone_parent_set(PointerRNA *ptr, PointerRNA value)
233 {
234         EditBone *ebone= (EditBone*)(ptr->data);
235         EditBone *pbone, *parbone= (EditBone*)value.data;
236
237         /* within same armature */
238         if(value.id.data != ptr->id.data)
239                 return;
240
241         if(parbone == NULL) {
242                 if(ebone->parent && !(ebone->parent->flag & BONE_ROOTSEL))
243                         ebone->parent->flag &= ~BONE_TIPSEL;
244
245                 ebone->parent = NULL;
246                 ebone->flag &= ~BONE_CONNECTED;
247         }
248         else {
249                 /* make sure this is a valid child */
250                 if(parbone == ebone)
251                         return;
252                         
253                 for(pbone= parbone->parent; pbone; pbone=pbone->parent)
254                         if(pbone == ebone)
255                                 return;
256
257                 ebone->parent = parbone;
258                 rna_EditBone_connected_check(ebone);
259         }
260 }
261
262 static void rna_Armature_editbone_transform_update(bContext *C, PointerRNA *ptr)
263 {
264         bArmature *arm= (bArmature*)ptr->id.data;
265         EditBone *ebone= (EditBone*)ptr->data;
266         EditBone *child, *eboflip;
267         
268         /* update our parent */
269         if(ebone->parent && ebone->flag & BONE_CONNECTED)
270                 VECCOPY(ebone->parent->tail, ebone->head)
271
272         /* update our children if necessary */
273         for(child = arm->edbo->first; child; child=child->next)
274                 if(child->parent == ebone && (child->flag & BONE_CONNECTED))
275                         VECCOPY(child->head, ebone->tail);
276
277         if(arm->flag & ARM_MIRROR_EDIT) {
278                 eboflip= ED_armature_bone_get_mirrored(arm->edbo, ebone);
279
280                 if(eboflip) {
281                         eboflip->roll= -ebone->roll;
282
283                         eboflip->head[0]= -ebone->head[0];
284                         eboflip->tail[0]= -ebone->tail[0];
285                         
286                         /* update our parent */
287                         if(eboflip->parent && eboflip->flag & BONE_CONNECTED)
288                                 VECCOPY(eboflip->parent->tail, eboflip->head);
289                         
290                         /* update our children if necessary */
291                         for(child = arm->edbo->first; child; child=child->next)
292                                 if(child->parent == eboflip && (child->flag & BONE_CONNECTED))
293                                         VECCOPY (child->head, eboflip->tail);
294                 }
295         }
296
297         rna_Armature_update_data(C, ptr);
298 }
299
300 static void rna_Armature_bones_next(CollectionPropertyIterator *iter)
301 {
302         ListBaseIterator *internal= iter->internal;
303         Bone *bone= (Bone*)internal->link;
304
305         if(bone->childbase.first)
306                 internal->link= (Link*)bone->childbase.first;
307         else if(bone->next)
308                 internal->link= (Link*)bone->next;
309         else {
310                 internal->link= NULL;
311
312                 do {
313                         bone= bone->parent;
314                         if(bone && bone->next) {
315                                 internal->link= (Link*)bone->next;
316                                 break;
317                         }
318                 } while(bone);
319         }
320
321         iter->valid= (internal->link != NULL);
322 }
323
324 #else
325
326 static void rna_def_bone_common(StructRNA *srna, int editbone)
327 {
328         PropertyRNA *prop;
329
330         /* strings */
331         prop= RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
332         RNA_def_property_string_sdna(prop, NULL, "name");
333         RNA_def_property_ui_text(prop, "Name", "");
334         RNA_def_struct_name_property(srna, prop);
335         if(editbone) RNA_def_property_string_funcs(prop, NULL, NULL, "rna_EditBone_name_set");
336         else RNA_def_property_string_funcs(prop, NULL, NULL, "rna_Bone_name_set");
337         RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
338
339         /* flags */
340         prop= RNA_def_property(srna, "layer", PROP_BOOLEAN, PROP_NONE);
341         RNA_def_property_boolean_sdna(prop, NULL, "layer", 1);
342         RNA_def_property_array(prop, 16);
343         if(editbone) RNA_def_property_boolean_funcs(prop, "rna_EditBone_layer_get", "rna_EditBone_layer_set");
344         else RNA_def_property_boolean_funcs(prop, NULL, "rna_Bone_layer_set");
345         RNA_def_property_ui_text(prop, "Layers", "Layers bone exists in");
346         RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
347
348         prop= RNA_def_property(srna, "connected", PROP_BOOLEAN, PROP_NONE);
349         RNA_def_property_boolean_sdna(prop, NULL, "flag", BONE_CONNECTED);
350         if(editbone) RNA_def_property_boolean_funcs(prop, NULL, "rna_EditBone_connected_set");
351         else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
352         RNA_def_property_ui_text(prop, "Connected", "When bone has a parent, bone's head is struck to the parent's tail.");
353         RNA_def_property_update(prop, 0, "rna_Armature_update_data");
354         
355         prop= RNA_def_property(srna, "active", PROP_BOOLEAN, PROP_NONE);
356         RNA_def_property_boolean_sdna(prop, NULL, "flag", BONE_ACTIVE);
357         RNA_def_property_ui_text(prop, "Active", "Bone was the last bone clicked on (most operations are applied to only this bone)");
358         RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
359         
360         prop= RNA_def_property(srna, "hinge", PROP_BOOLEAN, PROP_NONE);
361         RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", BONE_HINGE);
362         RNA_def_property_ui_text(prop, "Inherit Rotation", "Bone doesn't inherit rotation or scale from parent bone.");
363         RNA_def_property_update(prop, 0, "rna_Armature_update_data");
364         
365         prop= RNA_def_property(srna, "multiply_vertexgroup_with_envelope", PROP_BOOLEAN, PROP_NONE);
366         RNA_def_property_boolean_sdna(prop, NULL, "flag", BONE_MULT_VG_ENV);
367         RNA_def_property_ui_text(prop, "Multiply Vertex Group with Envelope", "When deforming bone, multiply effects of Vertex Group weights with Envelope influence.");
368         RNA_def_property_update(prop, 0, "rna_Armature_update_data");
369         
370         prop= RNA_def_property(srna, "deform", PROP_BOOLEAN, PROP_NONE);
371         RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", BONE_NO_DEFORM);
372         RNA_def_property_ui_text(prop, "Deform", "Bone does not deform any geometry.");
373         RNA_def_property_update(prop, 0, "rna_Armature_update_data");
374         
375         prop= RNA_def_property(srna, "inherit_scale", PROP_BOOLEAN, PROP_NONE);
376         RNA_def_property_ui_text(prop, "Inherit Scale", "Bone inherits scaling from parent bone.");
377         RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", BONE_NO_SCALE);
378         RNA_def_property_update(prop, 0, "rna_Armature_update_data");
379         
380         prop= RNA_def_property(srna, "draw_wire", PROP_BOOLEAN, PROP_NONE);
381         RNA_def_property_boolean_sdna(prop, NULL, "flag", BONE_DRAWWIRE);
382         RNA_def_property_ui_text(prop, "Draw Wire", "Bone is always drawn as Wireframe regardless of viewport draw mode. Useful for non-obstructive custom bone shapes.");
383         RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
384         
385         prop= RNA_def_property(srna, "cyclic_offset", PROP_BOOLEAN, PROP_NONE);
386         RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", BONE_NO_CYCLICOFFSET);
387         RNA_def_property_ui_text(prop, "Cyclic Offset", "When bone doesn't have a parent, it receives cyclic offset effects.");
388         RNA_def_property_update(prop, 0, "rna_Armature_update_data");
389
390         /* Number values */
391                 /* envelope deform settings */
392         prop= RNA_def_property(srna, "envelope_distance", PROP_FLOAT, PROP_NONE);
393         RNA_def_property_float_sdna(prop, NULL, "dist");
394         RNA_def_property_range(prop, 0.0f, 1000.0f);
395         RNA_def_property_ui_text(prop, "Envelope Deform Distance", "Bone deformation distance (for Envelope deform only).");
396         RNA_def_property_update(prop, 0, "rna_Armature_update_data");
397         
398         prop= RNA_def_property(srna, "envelope_weight", PROP_FLOAT, PROP_NONE);
399         RNA_def_property_float_sdna(prop, NULL, "weight");
400         RNA_def_property_range(prop, 0.0f, 1000.0f);
401         RNA_def_property_ui_text(prop, "Envelope Deform Weight", "Bone deformation weight (for Envelope deform only).");
402         RNA_def_property_update(prop, 0, "rna_Armature_update_data");
403         
404         prop= RNA_def_property(srna, "head_radius", PROP_FLOAT, PROP_NONE);
405         if(editbone) RNA_def_property_update(prop, 0, "rna_Armature_editbone_transform_update");
406         RNA_def_property_float_sdna(prop, NULL, "rad_head");
407         //RNA_def_property_range(prop, 0, 1000);  // XXX range is 0 to lim, where lim= 10000.0f*MAX2(1.0, view3d->grid);
408         RNA_def_property_ui_text(prop, "Envelope Head Radius", "Radius of head of bone (for Envelope deform only).");
409         
410         prop= RNA_def_property(srna, "tail_radius", PROP_FLOAT, PROP_NONE);
411         if(editbone) RNA_def_property_update(prop, 0, "rna_Armature_editbone_transform_update");
412         RNA_def_property_float_sdna(prop, NULL, "rad_tail");
413         //RNA_def_property_range(prop, 0, 1000);  // XXX range is 0 to lim, where lim= 10000.0f*MAX2(1.0, view3d->grid);
414         RNA_def_property_ui_text(prop, "Envelope Tail Radius", "Radius of tail of bone (for Envelope deform only).");
415         
416                 /* b-bones deform settings */
417         prop= RNA_def_property(srna, "bbone_segments", PROP_INT, PROP_NONE);
418         RNA_def_property_int_sdna(prop, NULL, "segments");
419         RNA_def_property_range(prop, 1, 32);
420         RNA_def_property_ui_text(prop, "B-Bone Segments", "Number of subdivisions of bone (for B-Bones only).");
421         RNA_def_property_update(prop, 0, "rna_Armature_update_data");
422         
423         prop= RNA_def_property(srna, "bbone_in", PROP_FLOAT, PROP_NONE);
424         RNA_def_property_float_sdna(prop, NULL, "ease1");
425         RNA_def_property_range(prop, 0.0f, 2.0f);
426         RNA_def_property_ui_text(prop, "B-Bone Ease In", "Length of first Bezier Handle (for B-Bones only).");
427         RNA_def_property_update(prop, 0, "rna_Armature_update_data");
428         
429         prop= RNA_def_property(srna, "bbone_out", PROP_FLOAT, PROP_NONE);
430         RNA_def_property_float_sdna(prop, NULL, "ease2");
431         RNA_def_property_range(prop, 0.0f, 2.0f);
432         RNA_def_property_ui_text(prop, "B-Bone Ease Out", "Length of second Bezier Handle (for B-Bones only).");
433         RNA_def_property_update(prop, 0, "rna_Armature_update_data");
434 }
435
436 // err... bones should not be directly edited (only editbones should be...)
437 static void rna_def_bone(BlenderRNA *brna)
438 {
439         StructRNA *srna;
440         PropertyRNA *prop;
441         
442         srna= RNA_def_struct(brna, "Bone", NULL);
443         RNA_def_struct_ui_text(srna, "Bone", "Bone in an Armature datablock.");
444         RNA_def_struct_ui_icon(srna, ICON_BONE_DATA);
445         
446         /* pointers/collections */
447                 /* parent (pointer) */
448         prop= RNA_def_property(srna, "parent", PROP_POINTER, PROP_NONE);
449         RNA_def_property_struct_type(prop, "Bone");
450         RNA_def_property_pointer_sdna(prop, NULL, "parent");
451         RNA_def_property_ui_text(prop, "Parent", "Parent bone (in same Armature).");
452         RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
453         
454                 /* children (collection) */
455         prop= RNA_def_property(srna, "children", PROP_COLLECTION, PROP_NONE);
456         RNA_def_property_collection_sdna(prop, NULL, "childbase", NULL);
457         RNA_def_property_struct_type(prop, "Bone");
458         RNA_def_property_ui_text(prop, "Children", "Bones which are children of this bone");
459
460         rna_def_bone_common(srna, 0);
461
462                 // XXX should we define this in PoseChannel wrapping code instead? but PoseChannels directly get some of their flags from here...
463         prop= RNA_def_property(srna, "hidden", PROP_BOOLEAN, PROP_NONE);
464         RNA_def_property_boolean_sdna(prop, NULL, "flag", BONE_HIDDEN_P);
465         RNA_def_property_ui_text(prop, "Hidden", "Bone is not visible when it is not in Edit Mode (i.e. in Object or Pose Modes).");
466         RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
467
468         prop= RNA_def_property(srna, "selected", PROP_BOOLEAN, PROP_NONE);
469         RNA_def_property_boolean_sdna(prop, NULL, "flag", BONE_SELECTED);
470         RNA_def_property_ui_text(prop, "Selected", "");
471         RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
472 }
473
474 static void rna_def_edit_bone(BlenderRNA *brna)
475 {
476         StructRNA *srna;
477         PropertyRNA *prop;
478         
479         srna= RNA_def_struct(brna, "EditBone", NULL);
480         RNA_def_struct_sdna(srna, "EditBone");
481         RNA_def_struct_ui_text(srna, "Edit Bone", "Editmode bone in an Armature datablock.");
482         RNA_def_struct_ui_icon(srna, ICON_BONE_DATA);
483         
484         RNA_define_verify_sdna(0); // not in sdna
485
486         prop= RNA_def_property(srna, "parent", PROP_POINTER, PROP_NONE);
487         RNA_def_property_struct_type(prop, "EditBone");
488         RNA_def_property_pointer_funcs(prop, "rna_EditBone_parent_get", "rna_EditBone_parent_set", NULL);
489         RNA_def_property_flag(prop, PROP_EDITABLE);
490         RNA_def_property_ui_text(prop, "Parent", "Parent edit bone (in same Armature).");
491         RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
492         
493         prop= RNA_def_property(srna, "roll", PROP_FLOAT, PROP_NONE);
494         RNA_def_property_float_sdna(prop, NULL, "roll");
495         RNA_def_property_ui_text(prop, "Roll", "Bone rotation around head-tail axis.");
496         RNA_def_property_update(prop, 0, "rna_Armature_editbone_transform_update");
497
498         prop= RNA_def_property(srna, "head", PROP_FLOAT, PROP_VECTOR);
499         RNA_def_property_float_sdna(prop, NULL, "head");
500         RNA_def_property_array(prop, 3);
501         RNA_def_property_ui_text(prop, "Head", "Location of head end of the bone.");
502         RNA_def_property_update(prop, 0, "rna_Armature_editbone_transform_update");
503
504         prop= RNA_def_property(srna, "tail", PROP_FLOAT, PROP_VECTOR);
505         RNA_def_property_float_sdna(prop, NULL, "tail");
506         RNA_def_property_array(prop, 3);
507         RNA_def_property_ui_text(prop, "Tail", "Location of tail end of the bone.");
508         RNA_def_property_update(prop, 0, "rna_Armature_editbone_transform_update");
509
510         rna_def_bone_common(srna, 1);
511
512         prop= RNA_def_property(srna, "hidden", PROP_BOOLEAN, PROP_NONE);
513         RNA_def_property_boolean_sdna(prop, NULL, "flag", BONE_HIDDEN_A);
514         RNA_def_property_ui_text(prop, "Hidden", "Bone is not visible when in Edit Mode");
515         RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
516
517         prop= RNA_def_property(srna, "locked", PROP_BOOLEAN, PROP_NONE);
518         RNA_def_property_boolean_sdna(prop, NULL, "flag", BONE_EDITMODE_LOCKED);
519         RNA_def_property_ui_text(prop, "Locked", "Bone is not able to be transformed when in Edit Mode.");
520         RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
521
522         prop= RNA_def_property(srna, "head_selected", PROP_BOOLEAN, PROP_NONE);
523         RNA_def_property_boolean_sdna(prop, NULL, "flag", BONE_ROOTSEL);
524         RNA_def_property_ui_text(prop, "Head Selected", "");
525         RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
526         
527         prop= RNA_def_property(srna, "tail_selected", PROP_BOOLEAN, PROP_NONE);
528         RNA_def_property_boolean_sdna(prop, NULL, "flag", BONE_TIPSEL);
529         RNA_def_property_ui_text(prop, "Tail Selected", "");
530         RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
531
532         RNA_define_verify_sdna(1);
533 }
534
535 void rna_def_armature(BlenderRNA *brna)
536 {
537         StructRNA *srna;
538         PropertyRNA *prop;
539         
540         static EnumPropertyItem prop_drawtype_items[] = {
541                 {ARM_OCTA, "OCTAHEDRAL", 0, "Octahedral", "Draw bones as octahedral shape (default)."},
542                 {ARM_LINE, "STICK", 0, "Stick", "Draw bones as simple 2D lines with dots."},
543                 {ARM_B_BONE, "BBONE", 0, "B-Bone", "Draw bones as boxes, showing subdivision and B-Splines"},
544                 {ARM_ENVELOPE, "ENVELOPE", 0, "Envelope", "Draw bones as extruded spheres, showing defomation influence volume."},
545                 {0, NULL, 0, NULL, NULL}};
546         static EnumPropertyItem prop_ghost_type_items[] = {
547                 {ARM_GHOST_CUR, "CURRENT_FRAME", 0, "Around Current Frame", "Draw Ghosts of poses within a fixed number of frames around the current frame."},
548                 {ARM_GHOST_RANGE, "RANGE", 0, "In Range", "Draw Ghosts of poses within specified range."},
549                 {ARM_GHOST_KEYS, "KEYS", 0, "On Keyframes", "Draw Ghosts of poses on Keyframes."},
550                 {0, NULL, 0, NULL, NULL}};
551         
552         srna= RNA_def_struct(brna, "Armature", "ID");
553         RNA_def_struct_ui_text(srna, "Armature", "Armature datablock containing a hierarchy of bones, usually used for rigging characters.");
554         RNA_def_struct_ui_icon(srna, ICON_ARMATURE_DATA);
555         
556         RNA_def_struct_sdna(srna, "bArmature");
557         
558         /* Collections */
559         prop= RNA_def_property(srna, "bones", PROP_COLLECTION, PROP_NONE);
560         RNA_def_property_collection_sdna(prop, NULL, "bonebase", NULL);
561         RNA_def_property_collection_funcs(prop, 0, "rna_Armature_bones_next", 0, 0, 0, 0, 0, 0, 0);
562         RNA_def_property_struct_type(prop, "Bone");
563         RNA_def_property_ui_text(prop, "Bones", "");
564
565         prop= RNA_def_property(srna, "edit_bones", PROP_COLLECTION, PROP_NONE);
566         RNA_def_property_collection_sdna(prop, NULL, "edbo", NULL);
567         RNA_def_property_struct_type(prop, "EditBone");
568         RNA_def_property_ui_text(prop, "Edit Bones", "");
569         
570         /* Enum values */
571         prop= RNA_def_property(srna, "drawtype", PROP_ENUM, PROP_NONE);
572         RNA_def_property_enum_items(prop, prop_drawtype_items);
573         RNA_def_property_ui_text(prop, "Draw Type", "");
574         RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
575         
576         prop= RNA_def_property(srna, "ghost_type", PROP_ENUM, PROP_NONE);
577         RNA_def_property_enum_sdna(prop, NULL, "ghosttype");
578         RNA_def_property_enum_items(prop, prop_ghost_type_items);
579         RNA_def_property_ui_text(prop, "Ghost Drawing", "Method of Onion-skinning for active Action");
580         RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
581         
582         /* Boolean values */
583                 /* layer */
584         prop= RNA_def_property(srna, "layer", PROP_BOOLEAN, PROP_NONE);
585         RNA_def_property_boolean_sdna(prop, NULL, "layer", 1);
586         RNA_def_property_array(prop, 16);
587         RNA_def_property_ui_text(prop, "Visible Layers", "Armature layer visibility.");
588         RNA_def_property_boolean_funcs(prop, NULL, "rna_Armature_layer_set");
589         RNA_def_property_update(prop, NC_OBJECT|ND_POSE, NULL);
590         RNA_def_property_flag(prop, PROP_LIB_EXCEPTION);
591         
592                 /* layer protection */
593         prop= RNA_def_property(srna, "layer_protection", PROP_BOOLEAN, PROP_NONE);
594         RNA_def_property_boolean_sdna(prop, NULL, "layer_protected", 1);
595         RNA_def_property_array(prop, 16);
596         RNA_def_property_ui_text(prop, "Layer Proxy Protection", "Protected layers in Proxy Instances are restored to Proxy settings on file reload and undo.");        
597         RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
598                 
599                 /* flag */
600         prop= RNA_def_property(srna, "rest_position", PROP_BOOLEAN, PROP_NONE);
601         RNA_def_property_boolean_sdna(prop, NULL, "flag", ARM_RESTPOS);
602         RNA_def_property_ui_text(prop, "Rest Position", "Show Armature in Rest Position. No posing possible.");
603         RNA_def_property_update(prop, 0, "rna_Armature_update_data");
604         
605         prop= RNA_def_property(srna, "draw_axes", PROP_BOOLEAN, PROP_NONE);
606         RNA_def_property_boolean_sdna(prop, NULL, "flag", ARM_DRAWAXES);
607         RNA_def_property_ui_text(prop, "Draw Axes", "Draw bone axes.");
608         RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
609         
610         prop= RNA_def_property(srna, "draw_names", PROP_BOOLEAN, PROP_NONE);
611         RNA_def_property_boolean_sdna(prop, NULL, "flag", ARM_DRAWNAMES);
612         RNA_def_property_ui_text(prop, "Draw Names", "Draw bone names.");
613         RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
614         
615         prop= RNA_def_property(srna, "delay_deform", PROP_BOOLEAN, PROP_NONE);
616         RNA_def_property_boolean_sdna(prop, NULL, "flag", ARM_DELAYDEFORM);
617         RNA_def_property_ui_text(prop, "Delay Deform", "Don't deform children when manipulating bones in Pose Mode");
618         RNA_def_property_update(prop, 0, "rna_Armature_update_data");
619         
620         prop= RNA_def_property(srna, "x_axis_mirror", PROP_BOOLEAN, PROP_NONE);
621         RNA_def_property_boolean_sdna(prop, NULL, "flag", ARM_MIRROR_EDIT);
622         RNA_def_property_ui_text(prop, "X-Axis Mirror", "Apply changes to matching bone on opposite side of X-Axis.");
623         RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
624         
625         prop= RNA_def_property(srna, "auto_ik", PROP_BOOLEAN, PROP_NONE);
626         RNA_def_property_boolean_sdna(prop, NULL, "flag", ARM_AUTO_IK);
627         RNA_def_property_ui_text(prop, "Auto IK", "Add temporaral IK constraints while grabbing bones in Pose Mode.");
628         RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
629         
630         prop= RNA_def_property(srna, "draw_custom_bone_shapes", PROP_BOOLEAN, PROP_NONE);
631         RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", ARM_NO_CUSTOM);
632         RNA_def_property_ui_text(prop, "Draw Custom Bone Shapes", "Draw bones with their custom shapes.");
633         RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
634         
635         prop= RNA_def_property(srna, "draw_group_colors", PROP_BOOLEAN, PROP_NONE);
636         RNA_def_property_boolean_sdna(prop, NULL, "flag", ARM_COL_CUSTOM);
637         RNA_def_property_ui_text(prop, "Draw Bone Group Colors", "Draw bone group colors.");
638         RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
639         
640         prop= RNA_def_property(srna, "ghost_only_selected", PROP_BOOLEAN, PROP_NONE);
641         RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", ARM_GHOST_ONLYSEL);
642         RNA_def_property_ui_text(prop, "Draw Ghosts on Selected Keyframes Only", "");
643         RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
644         
645                 /* deformflag */
646         prop= RNA_def_property(srna, "deform_vertexgroups", PROP_BOOLEAN, PROP_NONE);
647         RNA_def_property_boolean_sdna(prop, NULL, "deformflag", ARM_DEF_VGROUP);
648         RNA_def_property_ui_text(prop, "Deform Vertex Groups", "Enable Vertex Groups when defining deform");
649         RNA_def_property_update(prop, 0, "rna_Armature_update_data");
650         
651         prop= RNA_def_property(srna, "deform_envelope", PROP_BOOLEAN, PROP_NONE);
652         RNA_def_property_boolean_sdna(prop, NULL, "deformflag", ARM_DEF_ENVELOPE);
653         RNA_def_property_ui_text(prop, "Deform Envelopes", "Enable Bone Envelopes when defining deform");
654         RNA_def_property_update(prop, 0, "rna_Armature_update_data");
655         
656         prop= RNA_def_property(srna, "deform_quaternion", PROP_BOOLEAN, PROP_NONE);
657         RNA_def_property_boolean_sdna(prop, NULL, "deformflag", ARM_DEF_QUATERNION);
658         RNA_def_property_ui_text(prop, "Use Dual Quaternion Deformation", "Enable deform rotation with Quaternions");
659         RNA_def_property_update(prop, 0, "rna_Armature_update_data");
660         
661         prop= RNA_def_property(srna, "deform_bbone_rest", PROP_BOOLEAN, PROP_NONE);
662         RNA_def_property_boolean_sdna(prop, NULL, "deformflag", ARM_DEF_B_BONE_REST);
663         RNA_def_property_ui_text(prop, "B-Bones Deform in Rest Position", "Make B-Bones deform already in Rest Position");
664         RNA_def_property_update(prop, 0, "rna_Armature_update_data");
665         
666         //prop= RNA_def_property(srna, "deform_invert_vertexgroups", PROP_BOOLEAN, PROP_NONE);
667         //RNA_def_property_boolean_negative_sdna(prop, NULL, "deformflag", ARM_DEF_INVERT_VGROUP);
668         //RNA_def_property_ui_text(prop, "Invert Vertex Group Influence", "Invert Vertex Group influence (only for Modifiers)");
669         //RNA_def_property_update(prop, 0, "rna_Armature_update_data");
670         
671                 /* pathflag */
672         prop= RNA_def_property(srna, "paths_show_frame_numbers", PROP_BOOLEAN, PROP_NONE);
673         RNA_def_property_boolean_sdna(prop, NULL, "pathflag", ARM_PATH_FNUMS);
674         RNA_def_property_ui_text(prop, "Paths Show Frame Numbers", "When drawing Armature in Pose Mode, show frame numbers on Bone Paths");
675         RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
676         
677         prop= RNA_def_property(srna, "paths_highlight_keyframes", PROP_BOOLEAN, PROP_NONE);
678         RNA_def_property_boolean_sdna(prop, NULL, "pathflag", ARM_PATH_KFRAS);
679         RNA_def_property_ui_text(prop, "Paths Highlight Keyframes", "When drawing Armature in Pose Mode, emphasize position of keyframes on Bone Paths");
680         RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
681         
682         prop= RNA_def_property(srna, "paths_show_keyframe_numbers", PROP_BOOLEAN, PROP_NONE);
683         RNA_def_property_boolean_sdna(prop, NULL, "pathflag", ARM_PATH_KFNOS);
684         RNA_def_property_ui_text(prop, "Paths Show Keyframe Numbers", "When drawing Armature in Pose Mode, show frame numbers of Keyframes on Bone Paths");
685         RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
686         
687         prop= RNA_def_property(srna, "paths_show_around_current_frame", PROP_BOOLEAN, PROP_NONE);
688         RNA_def_property_boolean_sdna(prop, NULL, "pathflag", ARM_PATH_ACFRA);
689         RNA_def_property_ui_text(prop, "Paths Around Current Frame", "When drawing Armature in Pose Mode, only show section of Bone Paths that falls around current frame");
690         RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
691         
692         prop= RNA_def_property(srna, "paths_calculate_head_positions", PROP_BOOLEAN, PROP_NONE);
693         RNA_def_property_boolean_sdna(prop, NULL, "pathflag", ARM_PATH_HEADS);
694         RNA_def_property_ui_text(prop, "Paths Use Heads", "When calculating Bone Paths, use Head locations instead of Tips");
695         RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
696         
697         /* Number fields */
698                 /* ghost/onionskining settings */
699         prop= RNA_def_property(srna, "ghost_step", PROP_INT, PROP_NONE);
700         RNA_def_property_int_sdna(prop, NULL, "ghostep");
701         RNA_def_property_range(prop, 0, 30);
702         RNA_def_property_ui_text(prop, "Ghosting Step", "Number of frame steps on either side of current frame to show as ghosts (only for 'Around Current Frame' Onion-skining method).");
703         RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
704         
705         prop= RNA_def_property(srna, "ghost_size", PROP_INT, PROP_NONE);
706         RNA_def_property_int_sdna(prop, NULL, "ghostsize");
707         RNA_def_property_range(prop, 1, 20);
708         RNA_def_property_ui_text(prop, "Ghosting Frame Step", "Frame step for Ghosts (not for 'On Keyframes' Onion-skining method).");
709         RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
710         
711         prop= RNA_def_property(srna, "ghost_start_frame", PROP_INT, PROP_NONE);
712         RNA_def_property_int_sdna(prop, NULL, "ghostsf");
713         RNA_def_property_int_funcs(prop, NULL, "rna_Armature_ghost_start_frame_set", NULL);
714         RNA_def_property_ui_text(prop, "Ghosting Start Frame", "Starting frame of range of Ghosts to display (not for 'Around Current Frame' Onion-skinning method).");
715         RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
716         
717         prop= RNA_def_property(srna, "ghost_end_frame", PROP_INT, PROP_NONE);
718         RNA_def_property_int_sdna(prop, NULL, "ghostef");
719         RNA_def_property_int_funcs(prop, NULL, "rna_Armature_ghost_end_frame_set", NULL);
720         RNA_def_property_ui_text(prop, "Ghosting End Frame", "End frame of range of Ghosts to display (not for 'Around Current Frame' Onion-skinning method).");
721         RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
722         
723                 /* bone path settings */
724         prop= RNA_def_property(srna, "path_size", PROP_INT, PROP_NONE);
725         RNA_def_property_int_sdna(prop, NULL, "pathsize");
726         RNA_def_property_range(prop, 1, 100);
727         RNA_def_property_ui_text(prop, "Paths Frame Step", "Number of frames between 'dots' on Bone Paths (when drawing).");
728         RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
729         
730         prop= RNA_def_property(srna, "path_start_frame", PROP_INT, PROP_NONE);
731         RNA_def_property_int_sdna(prop, NULL, "pathsf");
732         RNA_def_property_int_funcs(prop, NULL, "rna_Armature_path_start_frame_set", NULL);
733         RNA_def_property_ui_text(prop, "Paths Calculation Start Frame", "Starting frame of range of frames to use for Bone Path calculations.");
734         RNA_def_property_update(prop, 0, "rna_Armature_update_data");
735         
736         prop= RNA_def_property(srna, "path_end_frame", PROP_INT, PROP_NONE);
737         RNA_def_property_int_sdna(prop, NULL, "pathef");
738         RNA_def_property_int_funcs(prop, NULL, "rna_Armature_path_end_frame_set", NULL);
739         RNA_def_property_ui_text(prop, "Paths Calculation End Frame", "End frame of range of frames to use for Bone Path calculations.");
740         RNA_def_property_update(prop, 0, "rna_Armature_update_data");
741         
742         prop= RNA_def_property(srna, "path_before_current", PROP_INT, PROP_NONE);
743         RNA_def_property_int_sdna(prop, NULL, "pathbc");
744         RNA_def_property_range(prop, 1, MAXFRAMEF/2);
745         RNA_def_property_ui_text(prop, "Paths Frames Before Current", "Number of frames before current frame to show on Bone Paths (only for 'Around Current' option).");
746         RNA_def_property_update(prop, 0, "rna_Armature_update_data");
747         
748         prop= RNA_def_property(srna, "path_after_current", PROP_INT, PROP_NONE);
749         RNA_def_property_int_sdna(prop, NULL, "pathac");
750         RNA_def_property_range(prop, 1, MAXFRAMEF/2);
751         RNA_def_property_ui_text(prop, "Paths Frames After Current", "Number of frames after current frame to show on Bone Paths (only for 'Around Current' option).");
752         RNA_def_property_update(prop, 0, "rna_Armature_update_data");
753 }
754
755 void RNA_def_armature(BlenderRNA *brna)
756 {
757         rna_def_armature(brna);
758         rna_def_bone(brna);
759         rna_def_edit_bone(brna);
760 }
761
762 #endif