- use a generic bone class so all 3 bone types (Edit/Pose/Armature) - can have the...
[blender.git] / source / blender / makesrna / intern / rna_pose.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), Roland Hess, Joshua Leung
21  *
22  * ***** END GPL LICENSE BLOCK *****
23  */
24
25 #include <stdlib.h>
26 #include <string.h>
27
28 #include "RNA_define.h"
29 #include "RNA_types.h"
30 #include "RNA_enum_types.h"
31
32 #include "rna_internal.h"
33
34 #include "DNA_action_types.h"
35 #include "DNA_armature_types.h"
36 #include "DNA_constraint_types.h"
37 #include "DNA_object_types.h"
38 #include "DNA_scene_types.h"
39
40 #include "WM_types.h"
41
42 #ifdef RNA_RUNTIME
43
44 #include "BIK_api.h"
45 #include "BKE_action.h"
46 #include "BKE_armature.h"
47 #include "BLI_math.h"
48
49 #include "DNA_userdef_types.h"
50
51 #include "BKE_context.h"
52 #include "BKE_constraint.h"
53 #include "BKE_depsgraph.h"
54 #include "BKE_idprop.h"
55
56 #include "ED_object.h"
57 #include "ED_armature.h"
58
59 #include "MEM_guardedalloc.h"
60
61 static void rna_Pose_update(bContext *C, PointerRNA *ptr)
62 {
63         // XXX when to use this? ob->pose->flag |= (POSE_LOCKED|POSE_DO_UNLOCK);
64
65         DAG_id_flush_update(ptr->id.data, OB_RECALC_DATA);
66 }
67
68 static void rna_Pose_IK_update(bContext *C, PointerRNA *ptr)
69 {
70         // XXX when to use this? ob->pose->flag |= (POSE_LOCKED|POSE_DO_UNLOCK);
71         Object *ob= ptr->id.data;
72
73         DAG_id_flush_update(&ob->id, OB_RECALC_DATA);
74         BIK_clear_data(ob->pose);
75 }
76
77 static char *rna_PoseBone_path(PointerRNA *ptr)
78 {
79         return BLI_sprintfN("pose.bones[\"%s\"]", ((bPoseChannel*)ptr->data)->name);
80 }
81
82 static void rna_BoneGroup_color_set_set(PointerRNA *ptr, int value)
83 {
84         bActionGroup *grp= ptr->data;
85         
86         /* if valid value, set the new enum value, then copy the relevant colours? */
87         if ((value >= -1) && (value < 21))
88                 grp->customCol= value;
89         else
90                 return;
91         
92         /* only do color copying if using a custom color (i.e. not default colour)  */
93         if (grp->customCol) {
94                 if (grp->customCol > 0) {
95                         /* copy theme colors on-to group's custom color in case user tries to edit color */
96                         bTheme *btheme= U.themes.first;
97                         ThemeWireColor *col_set= &btheme->tarm[(grp->customCol - 1)];
98                         
99                         memcpy(&grp->cs, col_set, sizeof(ThemeWireColor));
100                 }
101                 else {
102                         /* init custom colors with a generic multi-color rgb set, if not initialised already (for custom color set) */
103                         if (grp->cs.solid[0] == 0) {
104                                 /* define for setting colors in theme below */
105                                 #define SETCOL(col, r, g, b, a)  col[0]=r; col[1]=g; col[2]= b; col[3]= a;
106                                 
107                                 SETCOL(grp->cs.solid, 0xff, 0x00, 0x00, 255);
108                                 SETCOL(grp->cs.select, 0x81, 0xe6, 0x14, 255);
109                                 SETCOL(grp->cs.active, 0x18, 0xb6, 0xe0, 255);
110                                 
111                                 #undef SETCOL
112                         }
113                 }
114         }
115 }
116
117 static IDProperty *rna_PoseBone_idproperties(PointerRNA *ptr, int create)
118 {
119         bPoseChannel *pchan= ptr->data;
120
121         if(create && !pchan->prop) {
122                 IDPropertyTemplate val = {0};
123                 pchan->prop= IDP_New(IDP_GROUP, val, "RNA_PoseChannel group");
124         }
125
126         return pchan->prop;
127 }
128
129 static void rna_Pose_ik_solver_set(struct PointerRNA *ptr, int value)
130 {
131         bPose *pose= (bPose*)ptr->data;
132
133         if (pose->iksolver != value) {
134                 // the solver has changed, must clean any temporary structures
135                 BIK_clear_data(pose);
136                 if (pose->ikparam) {
137                         MEM_freeN(pose->ikparam);
138                         pose->ikparam = NULL;
139                 }
140                 pose->iksolver = value;
141                 init_pose_ikparam(pose);
142         }
143 }
144
145 static void rna_Pose_ik_solver_update(bContext *C, PointerRNA *ptr)
146 {
147         Object *ob= ptr->id.data;
148         bPose *pose = ptr->data;
149         Scene *scene = CTX_data_scene(C);
150
151         pose->flag |= POSE_RECALC;      // checks & sorts pose channels
152         DAG_scene_sort(scene);
153         
154         update_pose_constraint_flags(pose);
155         
156         object_test_constraints(ob);
157
158         DAG_id_flush_update(&ob->id, OB_RECALC_DATA|OB_RECALC_OB);
159 }
160
161 /* rotation - axis-angle */
162 static void rna_PoseChannel_rotation_axis_angle_get(PointerRNA *ptr, float *value)
163 {
164         bPoseChannel *pchan= ptr->data;
165         
166         /* for now, assume that rotation mode is axis-angle */
167         value[0]= pchan->rotAngle;
168         copy_v3_v3(&value[1], pchan->rotAxis);
169 }
170
171 /* rotation - axis-angle */
172 static void rna_PoseChannel_rotation_axis_angle_set(PointerRNA *ptr, const float *value)
173 {
174         bPoseChannel *pchan= ptr->data;
175         
176         /* for now, assume that rotation mode is axis-angle */
177         pchan->rotAngle= value[0];
178         copy_v3_v3(pchan->rotAxis, (float *)&value[1]);
179         
180         // TODO: validate axis?
181 }
182
183 static void rna_PoseChannel_rotation_mode_set(PointerRNA *ptr, int value)
184 {
185         bPoseChannel *pchan= ptr->data;
186         
187         /* use API Method for conversions... */
188         BKE_rotMode_change_values(pchan->quat, pchan->eul, pchan->rotAxis, &pchan->rotAngle, pchan->rotmode, (short)value);
189         
190         /* finally, set the new rotation type */
191         pchan->rotmode= value;
192 }
193
194 static void rna_PoseChannel_name_set(PointerRNA *ptr, const char *value)
195 {
196         Object *ob= (Object*)ptr->id.data;
197         bPoseChannel *pchan= (bPoseChannel*)ptr->data;
198         char oldname[32], newname[32];
199         
200         /* need to be on the stack */
201         BLI_strncpy(newname, value, 32);
202         BLI_strncpy(oldname, pchan->name, 32);
203         
204         ED_armature_bone_rename(ob->data, oldname, newname);
205 }
206
207 static int rna_PoseChannel_has_ik_get(PointerRNA *ptr)
208 {
209         Object *ob= (Object*)ptr->id.data;
210         bPoseChannel *pchan= (bPoseChannel*)ptr->data;
211
212         return ED_pose_channel_in_IK_chain(ob, pchan);
213 }
214
215 StructRNA *rna_IKParam_refine(PointerRNA *ptr)
216 {
217         bIKParam *param = (bIKParam *)ptr->data;
218
219         switch (param->iksolver) {
220         case IKSOLVER_ITASC:
221                 return &RNA_Itasc;
222         default:
223                 return &RNA_IKParam;
224         }
225 }
226
227 PointerRNA rna_Pose_ikparam_get(struct PointerRNA *ptr)
228 {
229         bPose *pose= (bPose*)ptr->data;
230         return rna_pointer_inherit_refine(ptr, &RNA_IKParam, pose->ikparam);
231 }
232
233 static StructRNA *rna_Pose_ikparam_typef(PointerRNA *ptr)
234 {
235         bPose *pose= (bPose*)ptr->data;
236
237         switch (pose->iksolver) {
238         case IKSOLVER_ITASC:
239                 return &RNA_Itasc;
240         default:
241                 return &RNA_IKParam;
242         }
243 }
244
245 static void rna_Itasc_update(bContext *C, PointerRNA *ptr)
246 {
247         Object *ob = ptr->id.data;
248         bItasc *itasc = ptr->data;
249
250         /* verify values */
251         if (itasc->precision < 0.0001f)
252                 itasc->precision = 0.0001f;
253         if (itasc->minstep < 0.001f)
254                 itasc->minstep = 0.001f;
255         if (itasc->maxstep < itasc->minstep)
256                 itasc->maxstep = itasc->minstep;
257         if (itasc->feedback < 0.01f)
258                 itasc->feedback = 0.01f;
259         if (itasc->feedback > 100.f)
260                 itasc->feedback = 100.f;
261         if (itasc->maxvel < 0.01f)
262                 itasc->maxvel = 0.01f;
263         if (itasc->maxvel > 100.f)
264                 itasc->maxvel = 100.f;
265         BIK_update_param(ob->pose);
266
267         DAG_id_flush_update(&ob->id, OB_RECALC_DATA);
268 }
269
270 static void rna_Itasc_update_rebuild(bContext *C, PointerRNA *ptr)
271 {
272         Object *ob= ptr->id.data;
273         bPose *pose = ob->pose;
274
275         pose->flag |= POSE_RECALC;      // checks & sorts pose channels
276         rna_Itasc_update(C, ptr);
277 }
278
279 static PointerRNA rna_PoseChannel_bone_group_get(PointerRNA *ptr)
280 {
281         Object *ob= (Object*)ptr->id.data;
282         bPose *pose= (ob) ? ob->pose : NULL;
283         bPoseChannel *pchan= (bPoseChannel*)ptr->data;
284         bActionGroup *grp;
285         
286         if (pose)
287                 grp= BLI_findlink(&pose->agroups, pchan->agrp_index-1);
288         else
289                 grp= NULL;
290         
291         return rna_pointer_inherit_refine(ptr, &RNA_BoneGroup, grp);
292 }
293
294 static void rna_PoseChannel_bone_group_set(PointerRNA *ptr, PointerRNA value)
295 {
296         Object *ob= (Object*)ptr->id.data;
297         bPose *pose= (ob) ? ob->pose : NULL;
298         bPoseChannel *pchan= (bPoseChannel*)ptr->data;
299         
300         if (pose)
301                 pchan->agrp_index= BLI_findindex(&pose->agroups, value.data) + 1;
302         else
303                 pchan->agrp_index= 0;
304 }
305
306 static int rna_PoseChannel_bone_group_index_get(PointerRNA *ptr)
307 {
308         bPoseChannel *pchan= (bPoseChannel*)ptr->data;
309         return MAX2(pchan->agrp_index-1, 0);
310 }
311
312 static void rna_PoseChannel_bone_group_index_set(PointerRNA *ptr, int value)
313 {
314         bPoseChannel *pchan= (bPoseChannel*)ptr->data;
315         pchan->agrp_index= value+1;
316 }
317
318 static void rna_PoseChannel_bone_group_index_range(PointerRNA *ptr, int *min, int *max)
319 {
320         Object *ob= (Object*)ptr->id.data;
321         bPose *pose= (ob) ? ob->pose : NULL;
322         
323         *min= 0;
324         
325         if (pose) {
326                 *max= BLI_countlist(&pose->agroups)-1;
327                 *max= MAX2(0, *max);
328         }
329         else
330                 *max= 0;
331 }
332
333 static PointerRNA rna_Pose_active_bone_group_get(PointerRNA *ptr)
334 {
335         bPose *pose= (bPose*)ptr->data;
336         return rna_pointer_inherit_refine(ptr, &RNA_BoneGroup, BLI_findlink(&pose->agroups, pose->active_group-1));
337 }
338
339 static void rna_Pose_active_bone_group_set(PointerRNA *ptr, PointerRNA value)
340 {
341         bPose *pose= (bPose*)ptr->data;
342         pose->active_group= BLI_findindex(&pose->agroups, value.data) + 1;
343 }
344
345 static int rna_Pose_active_bone_group_index_get(PointerRNA *ptr)
346 {
347         bPose *pose= (bPose*)ptr->data;
348         return MAX2(pose->active_group-1, 0);
349 }
350
351 static void rna_Pose_active_bone_group_index_set(PointerRNA *ptr, int value)
352 {
353         bPose *pose= (bPose*)ptr->data;
354         pose->active_group= value+1;
355 }
356
357 static void rna_Pose_active_bone_group_index_range(PointerRNA *ptr, int *min, int *max)
358 {
359         bPose *pose= (bPose*)ptr->data;
360
361         *min= 0;
362         *max= BLI_countlist(&pose->agroups)-1;
363         *max= MAX2(0, *max);
364 }
365
366 #if 0
367 static void rna_pose_bgroup_name_index_get(PointerRNA *ptr, char *value, int index)
368 {
369         bPose *pose= (bPose*)ptr->data;
370         bActionGroup *grp;
371
372         grp= BLI_findlink(&pose->agroups, index-1);
373
374         if(grp) BLI_strncpy(value, grp->name, sizeof(grp->name));
375         else BLI_strncpy(value, "", sizeof(grp->name)); // XXX if invalid pointer, won't this crash?
376 }
377
378 static int rna_pose_bgroup_name_index_length(PointerRNA *ptr, int index)
379 {
380         bPose *pose= (bPose*)ptr->data;
381         bActionGroup *grp;
382
383         grp= BLI_findlink(&pose->agroups, index-1);
384         return (grp)? strlen(grp->name): 0;
385 }
386
387 static void rna_pose_bgroup_name_index_set(PointerRNA *ptr, const char *value, short *index)
388 {
389         bPose *pose= (bPose*)ptr->data;
390         bActionGroup *grp;
391         int a;
392         
393         for (a=1, grp=pose->agroups.first; grp; grp=grp->next, a++) {
394                 if (strcmp(grp->name, value) == 0) {
395                         *index= a;
396                         return;
397                 }
398         }
399         
400         *index= 0;
401 }
402
403 static void rna_pose_pgroup_name_set(PointerRNA *ptr, const char *value, char *result, int maxlen)
404 {
405         bPose *pose= (bPose*)ptr->data;
406         bActionGroup *grp;
407         
408         for (grp= pose->agroups.first; grp; grp= grp->next) {
409                 if (strcmp(grp->name, value) == 0) {
410                         BLI_strncpy(result, value, maxlen);
411                         return;
412                 }
413         }
414         
415         BLI_strncpy(result, "", maxlen);
416 }
417 #endif
418
419 static PointerRNA rna_PoseChannel_active_constraint_get(PointerRNA *ptr)
420 {
421         bPoseChannel *pchan= (bPoseChannel*)ptr->data;
422         bConstraint *con= constraints_get_active(&pchan->constraints);
423         return rna_pointer_inherit_refine(ptr, &RNA_Constraint, con);
424 }
425
426 static void rna_PoseChannel_active_constraint_set(PointerRNA *ptr, PointerRNA value)
427 {
428         bPoseChannel *pchan= (bPoseChannel*)ptr->data;
429         constraints_set_active(&pchan->constraints, (bConstraint *)value.data);
430 }
431
432 static bConstraint *rna_PoseChannel_constraints_new(bPoseChannel *pchan, bContext *C, int type)
433 {
434         //WM_event_add_notifier(C, NC_OBJECT|ND_CONSTRAINT|NA_ADDED, object);
435         // TODO, pass object also
436         // TODO, new pose bones don't have updated draw flags
437         return add_pose_constraint(NULL, pchan, NULL, type);
438 }
439
440 static int rna_PoseChannel_constraints_remove(bPoseChannel *pchan, bContext *C, int index)
441 {
442         // TODO
443         //ED_object_constraint_set_active(object, NULL);
444         //WM_event_add_notifier(C, NC_OBJECT|ND_CONSTRAINT, object);
445         return remove_constraint_index(&pchan->constraints, index);
446 }
447
448 #else
449
450 static void rna_def_bone_group(BlenderRNA *brna)
451 {
452         static EnumPropertyItem prop_colorSets_items[] = {
453                 {0, "DEFAULT", 0, "Default Colors", ""},
454                 {1, "THEME01", 0, "01 - Theme Color Set", ""},
455                 {2, "THEME02", 0, "02 - Theme Color Set", ""},
456                 {3, "THEME03", 0, "03 - Theme Color Set", ""},
457                 {4, "THEME04", 0, "04 - Theme Color Set", ""},
458                 {5, "THEME05", 0, "05 - Theme Color Set", ""},
459                 {6, "THEME06", 0, "06 - Theme Color Set", ""},
460                 {7, "THEME07", 0, "07 - Theme Color Set", ""},
461                 {8, "THEME08", 0, "08 - Theme Color Set", ""},
462                 {9, "THEME09", 0, "09 - Theme Color Set", ""},
463                 {10, "THEME10", 0, "10 - Theme Color Set", ""},
464                 {11, "THEME11", 0, "11 - Theme Color Set", ""},
465                 {12, "THEME12", 0, "12 - Theme Color Set", ""},
466                 {13, "THEME13", 0, "13 - Theme Color Set", ""},
467                 {14, "THEME14", 0, "14 - Theme Color Set", ""},
468                 {15, "THEME15", 0, "15 - Theme Color Set", ""},
469                 {16, "THEME16", 0, "16 - Theme Color Set", ""},
470                 {17, "THEME17", 0, "17 - Theme Color Set", ""},
471                 {18, "THEME18", 0, "18 - Theme Color Set", ""},
472                 {19, "THEME19", 0, "19 - Theme Color Set", ""},
473                 {20, "THEME20", 0, "20 - Theme Color Set", ""},
474                 {-1, "CUSTOM", 0, "Custom Color Set", ""},
475                 {0, NULL, 0, NULL, NULL}};
476         
477         StructRNA *srna;
478         PropertyRNA *prop;
479         
480         /* struct */
481         srna= RNA_def_struct(brna, "BoneGroup", NULL);
482         RNA_def_struct_sdna(srna, "bActionGroup");
483         RNA_def_struct_ui_text(srna, "Bone Group", "Groups of Pose Channels (Bones).");
484         RNA_def_struct_ui_icon(srna, ICON_GROUP_BONE);
485         
486         /* name */
487         prop= RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
488         RNA_def_property_ui_text(prop, "Name", "");
489         RNA_def_struct_name_property(srna, prop);
490         
491         // TODO: add some runtime-collections stuff to access grouped bones 
492         
493         /* color set + colors */
494         prop= RNA_def_property(srna, "color_set", PROP_ENUM, PROP_NONE);
495         RNA_def_property_enum_sdna(prop, NULL, "customCol");
496         RNA_def_property_enum_items(prop, prop_colorSets_items);
497         RNA_def_property_enum_funcs(prop, NULL, "rna_BoneGroup_color_set_set", NULL);
498         RNA_def_property_ui_text(prop, "Color Set", "Custom color set to use.");
499         RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Pose_update");
500         
501                 // TODO: editing the colors for this should result in changes to the color type...
502         prop= RNA_def_property(srna, "colors", PROP_POINTER, PROP_NONE);
503         RNA_def_property_flag(prop, PROP_NEVER_NULL);
504         RNA_def_property_struct_type(prop, "ThemeBoneColorSet");
505         RNA_def_property_pointer_sdna(prop, NULL, "cs"); /* NOTE: the DNA data is not really a pointer, but this code works :) */
506         RNA_def_property_ui_text(prop, "Colors", "Copy of the colors associated with the group's color set.");
507         RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Pose_update");
508 }
509
510 static EnumPropertyItem prop_iksolver_items[] = {
511         {IKSOLVER_LEGACY, "LEGACY", 0, "Legacy", "Original IK solver."},
512         {IKSOLVER_ITASC, "ITASC", 0, "iTaSC", "Multi constraint, stateful IK solver."},
513         {0, NULL, 0, NULL, NULL}};
514
515 static EnumPropertyItem prop_solver_items[] = {
516         {ITASC_SOLVER_SDLS, "SDLS", 0, "SDLS", "Selective Damped Least Square"},
517         {ITASC_SOLVER_DLS, "DLS", 0, "DLS", "Damped Least Square with Numerical Filtering"},
518         {0, NULL, 0, NULL, NULL}};
519
520
521 static void rna_def_pose_channel_constraints(BlenderRNA *brna, PropertyRNA *cprop)
522 {
523         StructRNA *srna;
524         PropertyRNA *prop;
525
526         FunctionRNA *func;
527         PropertyRNA *parm;
528
529         RNA_def_property_srna(cprop, "PoseBoneConstraints");
530         srna= RNA_def_struct(brna, "PoseBoneConstraints", NULL);
531         RNA_def_struct_sdna(srna, "bPoseChannel");
532         RNA_def_struct_ui_text(srna, "PoseBone Constraints", "Collection of pose bone constraints.");
533
534         /* Collection active property */
535         prop= RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
536         RNA_def_property_struct_type(prop, "Constraint");
537         RNA_def_property_pointer_funcs(prop, "rna_PoseChannel_active_constraint_get", "rna_PoseChannel_active_constraint_set", NULL);
538         RNA_def_property_flag(prop, PROP_EDITABLE);
539         RNA_def_property_ui_text(prop, "Active Constraint", "Active PoseChannel constraint.");
540
541
542         /* Constraint collection */
543         func= RNA_def_function(srna, "new", "rna_PoseChannel_constraints_new");
544         RNA_def_function_flag(func, FUNC_USE_CONTEXT);
545         RNA_def_function_ui_description(func, "Add a constraint to this object");
546         /* return type */
547         parm= RNA_def_pointer(func, "constraint", "Constraint", "", "New constraint.");
548         RNA_def_function_return(func, parm);
549         /* object to add */
550         parm= RNA_def_enum(func, "type", constraint_type_items, 1, "", "Constraint type to add.");
551         RNA_def_property_flag(parm, PROP_REQUIRED);
552
553         func= RNA_def_function(srna, "remove", "rna_PoseChannel_constraints_remove");
554         RNA_def_function_flag(func, FUNC_USE_CONTEXT);
555         RNA_def_function_ui_description(func, "Remove a constraint from this object.");
556         /* return type */
557         parm= RNA_def_boolean(func, "success", 0, "Success", "Removed the constraint successfully.");
558         RNA_def_function_return(func, parm);
559         /* object to add */
560         parm= RNA_def_int(func, "index", 0, 0, INT_MAX, "Index", "", 0, INT_MAX);
561         RNA_def_property_flag(parm, PROP_REQUIRED);
562 }
563
564 static void rna_def_pose_channel(BlenderRNA *brna)
565 {
566         // XXX: this RNA enum define is currently duplicated for objects, since there is some text here which is not applicable
567         static EnumPropertyItem prop_rotmode_items[] = {
568                 {ROT_MODE_QUAT, "QUATERNION", 0, "Quaternion (WXYZ)", "No Gimbal Lock (default)"},
569                 {ROT_MODE_XYZ, "XYZ", 0, "XYZ Euler", "XYZ Rotation Order. Prone to Gimbal Lock"},
570                 {ROT_MODE_XZY, "XZY", 0, "XZY Euler", "XZY Rotation Order. Prone to Gimbal Lock"},
571                 {ROT_MODE_YXZ, "YXZ", 0, "YXZ Euler", "YXZ Rotation Order. Prone to Gimbal Lock"},
572                 {ROT_MODE_YZX, "YZX", 0, "YZX Euler", "YZX Rotation Order. Prone to Gimbal Lock"},
573                 {ROT_MODE_ZXY, "ZXY", 0, "ZXY Euler", "ZXY Rotation Order. Prone to Gimbal Lock"},
574                 {ROT_MODE_ZYX, "ZYX", 0, "ZYX Euler", "ZYX Rotation Order. Prone to Gimbal Lock"},
575                 {ROT_MODE_AXISANGLE, "AXIS_ANGLE", 0, "Axis Angle", "Axis Angle (W+XYZ). Defines a rotation around some axis defined by 3D-Vector."},
576                 {0, NULL, 0, NULL, NULL}};
577         
578         StructRNA *srna;
579         PropertyRNA *prop;
580
581         srna= RNA_def_struct(brna, "PoseBone", NULL);
582         RNA_def_struct_sdna(srna, "bPoseChannel");
583         RNA_def_struct_ui_text(srna, "Pose Bone", "Channel defining pose data for a bone in a Pose.");
584         RNA_def_struct_path_func(srna, "rna_PoseBone_path");
585         RNA_def_struct_idproperties_func(srna, "rna_PoseBone_idproperties");
586         
587         /* Bone Constraints */
588         prop= RNA_def_property(srna, "constraints", PROP_COLLECTION, PROP_NONE);
589         RNA_def_property_struct_type(prop, "Constraint");
590         RNA_def_property_ui_text(prop, "Constraints", "Constraints that act on this PoseChannel.");
591
592         rna_def_pose_channel_constraints(brna, prop);
593
594         /* Name + Selection Status */
595         prop= RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
596         RNA_def_property_string_funcs(prop, NULL, NULL, "rna_PoseChannel_name_set");
597         RNA_def_property_ui_text(prop, "Name", "");
598         RNA_def_struct_name_property(srna, prop);
599
600         prop= RNA_def_property(srna, "selected", PROP_BOOLEAN, PROP_NONE);
601         RNA_def_property_boolean_sdna(prop, NULL, "selectflag", BONE_SELECTED);
602         RNA_def_property_ui_text(prop, "Selected", "");
603
604         /* Baked Bone Path cache data s*/
605         prop= RNA_def_property(srna, "path_start_frame", PROP_INT, PROP_TIME);
606         RNA_def_property_int_sdna(prop, NULL, "pathsf");
607         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
608         RNA_def_property_ui_text(prop, "Bone Paths Calculation Start Frame", "Starting frame of range of frames to use for Bone Path calculations.");
609         RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Pose_update");
610
611         prop= RNA_def_property(srna, "path_end_frame", PROP_INT, PROP_TIME);
612         RNA_def_property_int_sdna(prop, NULL, "pathef");
613         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
614         RNA_def_property_ui_text(prop, "Bone Paths Calculation End Frame", "End frame of range of frames to use for Bone Path calculations.");
615         RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Pose_update");
616         
617         /* Relationships to other bones */
618         prop= RNA_def_property(srna, "bone", PROP_POINTER, PROP_NONE);
619         RNA_def_property_flag(prop, PROP_NEVER_NULL);
620         RNA_def_property_struct_type(prop, "Bone");
621         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
622         RNA_def_property_ui_text(prop, "Bone", "Bone associated with this PoseBone.");
623
624         prop= RNA_def_property(srna, "parent", PROP_POINTER, PROP_NONE);
625         RNA_def_property_struct_type(prop, "PoseBone");
626         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
627         RNA_def_property_ui_text(prop, "Parent", "Parent of this pose bone.");
628
629         prop= RNA_def_property(srna, "child", PROP_POINTER, PROP_NONE);
630         RNA_def_property_struct_type(prop, "PoseBone");
631         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
632         RNA_def_property_ui_text(prop, "Child", "Child of this pose bone.");
633         
634         /* Transformation settings */
635         prop= RNA_def_property(srna, "location", PROP_FLOAT, PROP_TRANSLATION);
636         RNA_def_property_float_sdna(prop, NULL, "loc");
637         RNA_def_property_ui_text(prop, "Location", "");
638         RNA_def_property_update(prop, NC_OBJECT|ND_TRANSFORM, "rna_Pose_update");
639
640         prop= RNA_def_property(srna, "scale", PROP_FLOAT, PROP_XYZ);
641         RNA_def_property_float_sdna(prop, NULL, "size");
642         RNA_def_property_ui_text(prop, "Scale", "");
643         RNA_def_property_update(prop, NC_OBJECT|ND_TRANSFORM, "rna_Pose_update");
644
645         prop= RNA_def_property(srna, "rotation_quaternion", PROP_FLOAT, PROP_QUATERNION);
646         RNA_def_property_float_sdna(prop, NULL, "quat");
647         RNA_def_property_ui_text(prop, "Quaternion Rotation", "Rotation in Quaternions.");
648         RNA_def_property_update(prop, NC_OBJECT|ND_TRANSFORM, "rna_Pose_update");
649         
650                 /* XXX: for axis-angle, it would have been nice to have 2 separate fields for UI purposes, but
651                  * having a single one is better for Keyframing and other property-management situations...
652                  */
653         prop= RNA_def_property(srna, "rotation_axis_angle", PROP_FLOAT, PROP_AXISANGLE);
654         RNA_def_property_array(prop, 4); // TODO: maybe we'll need to define the 'default value' getter too...
655         RNA_def_property_float_funcs(prop, "rna_PoseChannel_rotation_axis_angle_get", "rna_PoseChannel_rotation_axis_angle_set", NULL);
656         RNA_def_property_ui_text(prop, "Axis-Angle Rotation", "Angle of Rotation for Axis-Angle rotation representation.");
657         RNA_def_property_update(prop, NC_OBJECT|ND_TRANSFORM, "rna_Pose_update");
658         
659         prop= RNA_def_property(srna, "rotation_euler", PROP_FLOAT, PROP_EULER);
660         RNA_def_property_float_sdna(prop, NULL, "eul");
661         RNA_def_property_ui_text(prop, "Euler Rotation", "Rotation in Eulers.");
662         RNA_def_property_update(prop, NC_OBJECT|ND_TRANSFORM, "rna_Pose_update");
663         
664         prop= RNA_def_property(srna, "rotation_mode", PROP_ENUM, PROP_NONE);
665         RNA_def_property_enum_sdna(prop, NULL, "rotmode");
666         RNA_def_property_enum_items(prop, prop_rotmode_items); // XXX move to using a single define of this someday
667         RNA_def_property_enum_funcs(prop, NULL, "rna_PoseChannel_rotation_mode_set", NULL);
668         RNA_def_property_ui_text(prop, "Rotation Mode", "");
669         RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Pose_update");
670         
671         /* transform matrices - should be read-only since these are set directly by AnimSys evaluation */
672         prop= RNA_def_property(srna, "channel_matrix", PROP_FLOAT, PROP_MATRIX);
673         RNA_def_property_float_sdna(prop, NULL, "chan_mat");
674         RNA_def_property_array(prop, 16);
675         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
676         RNA_def_property_ui_text(prop, "Channel Matrix", "4x4 matrix, before constraints.");
677         
678         prop= RNA_def_property(srna, "matrix", PROP_FLOAT, PROP_MATRIX);
679         RNA_def_property_float_sdna(prop, NULL, "pose_mat");
680         RNA_def_property_array(prop, 16);
681         RNA_def_property_clear_flag(prop, PROP_EDITABLE); 
682         RNA_def_property_ui_text(prop, "Pose Matrix", "Final 4x4 matrix for this channel.");
683
684         /*
685         prop= RNA_def_property(srna, "constraint_inverse_matrix", PROP_FLOAT, PROP_MATRIX);
686         RNA_def_property_struct_type(prop, "constinv");
687         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
688         RNA_def_property_ui_text(prop, "Constraint Inverse Matrix", "4x4 matrix, defines transform from final position to unconstrained position.");
689         */
690         
691         /* Head/Tail Coordinates (in Pose Space) - Automatically calculated... */
692         prop= RNA_def_property(srna, "head", PROP_FLOAT, PROP_TRANSLATION);
693         RNA_def_property_float_sdna(prop, NULL, "pose_head");
694         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
695         RNA_def_property_ui_text(prop, "Pose Head Position", "Location of head of the channel's bone.");
696
697         prop= RNA_def_property(srna, "tail", PROP_FLOAT, PROP_TRANSLATION);
698         RNA_def_property_float_sdna(prop, NULL, "pose_tail");
699         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
700         RNA_def_property_ui_text(prop, "Pose Tail Position", "Location of tail of the channel's bone.");
701         
702         /* IK Settings */
703         prop= RNA_def_property(srna, "has_ik", PROP_BOOLEAN, PROP_NONE);
704         RNA_def_property_boolean_funcs(prop,  "rna_PoseChannel_has_ik_get", NULL);
705         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
706         RNA_def_property_ui_text(prop, "Has IK", "Is part of an IK chain.");
707         RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Pose_IK_update");
708
709         prop= RNA_def_property(srna, "ik_dof_x", PROP_BOOLEAN, PROP_NONE);
710         RNA_def_property_boolean_negative_sdna(prop, NULL, "ikflag", BONE_IK_NO_XDOF);
711         RNA_def_property_ui_text(prop, "IK X DoF", "Allow movement around the X axis.");
712         RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Pose_IK_update");
713
714         prop= RNA_def_property(srna, "ik_dof_y", PROP_BOOLEAN, PROP_NONE);
715         RNA_def_property_boolean_negative_sdna(prop, NULL, "ikflag", BONE_IK_NO_YDOF);
716         RNA_def_property_ui_text(prop, "IK Y DoF", "Allow movement around the Y axis.");
717         RNA_def_property_update(prop, NC_OBJECT|ND_POSE|ND_TRANSFORM, "rna_Pose_IK_update");
718
719         prop= RNA_def_property(srna, "ik_dof_z", PROP_BOOLEAN, PROP_NONE);
720         RNA_def_property_boolean_negative_sdna(prop, NULL, "ikflag", BONE_IK_NO_ZDOF);
721         RNA_def_property_ui_text(prop, "IK Z DoF", "Allow movement around the Z axis.");
722         RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Pose_IK_update");
723
724         prop= RNA_def_property(srna, "ik_limit_x", PROP_BOOLEAN, PROP_NONE);
725         RNA_def_property_boolean_sdna(prop, NULL, "ikflag", BONE_IK_XLIMIT);
726         RNA_def_property_ui_text(prop, "IK X Limit", "Limit movement around the X axis.");
727         RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Pose_IK_update");
728
729         prop= RNA_def_property(srna, "ik_limit_y", PROP_BOOLEAN, PROP_NONE);
730         RNA_def_property_boolean_sdna(prop, NULL, "ikflag", BONE_IK_YLIMIT);
731         RNA_def_property_ui_text(prop, "IK Y Limit", "Limit movement around the Y axis.");
732         RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Pose_IK_update");
733
734         prop= RNA_def_property(srna, "ik_limit_z", PROP_BOOLEAN, PROP_NONE);
735         RNA_def_property_boolean_sdna(prop, NULL, "ikflag", BONE_IK_ZLIMIT);
736         RNA_def_property_ui_text(prop, "IK Z Limit", "Limit movement around the Z axis.");
737         RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Pose_IK_update");
738         
739         prop= RNA_def_property(srna, "ik_rot_control", PROP_BOOLEAN, PROP_NONE);
740         RNA_def_property_boolean_sdna(prop, NULL, "ikflag", BONE_IK_ROTCTL);
741         RNA_def_property_ui_text(prop, "IK rot control", "Apply channel rotation as IK constraint");
742         RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Pose_IK_update");
743         
744         prop= RNA_def_property(srna, "ik_lin_control", PROP_BOOLEAN, PROP_NONE);
745         RNA_def_property_boolean_sdna(prop, NULL, "ikflag", BONE_IK_LINCTL);
746         RNA_def_property_ui_text(prop, "IK rot control", "Apply channel size as IK constraint if stretching is enabled");
747         RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Pose_IK_update");
748         
749         prop= RNA_def_property(srna, "ik_min_x", PROP_FLOAT, PROP_ANGLE);
750         RNA_def_property_float_sdna(prop, NULL, "limitmin[0]");
751         RNA_def_property_range(prop, -180.0f, 0.0f);
752         RNA_def_property_ui_text(prop, "IK X Minimum", "Minimum angles for IK Limit");
753         RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Pose_IK_update");
754
755         prop= RNA_def_property(srna, "ik_max_x", PROP_FLOAT, PROP_ANGLE);
756         RNA_def_property_float_sdna(prop, NULL, "limitmax[0]");
757         RNA_def_property_range(prop, 0.0f, 180.0f);
758         RNA_def_property_ui_text(prop, "IK X Maximum", "Maximum angles for IK Limit");
759         RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Pose_IK_update");
760
761         prop= RNA_def_property(srna, "ik_min_y", PROP_FLOAT, PROP_ANGLE);
762         RNA_def_property_float_sdna(prop, NULL, "limitmin[1]");
763         RNA_def_property_range(prop, -180.0f, 0.0f);
764         RNA_def_property_ui_text(prop, "IK Y Minimum", "Minimum angles for IK Limit");
765         RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Pose_IK_update");
766
767         prop= RNA_def_property(srna, "ik_max_y", PROP_FLOAT, PROP_ANGLE);
768         RNA_def_property_float_sdna(prop, NULL, "limitmax[1]");
769         RNA_def_property_range(prop, 0.0f, 180.0f);
770         RNA_def_property_ui_text(prop, "IK Y Maximum", "Maximum angles for IK Limit");
771         RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Pose_IK_update");
772
773         prop= RNA_def_property(srna, "ik_min_z", PROP_FLOAT, PROP_ANGLE);
774         RNA_def_property_float_sdna(prop, NULL, "limitmin[2]");
775         RNA_def_property_range(prop, -180.0f, 0.0f);
776         RNA_def_property_ui_text(prop, "IK Z Minimum", "Minimum angles for IK Limit");
777         RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Pose_IK_update");
778
779         prop= RNA_def_property(srna, "ik_max_z", PROP_FLOAT, PROP_ANGLE);
780         RNA_def_property_float_sdna(prop, NULL, "limitmax[2]");
781         RNA_def_property_range(prop, 0.0f, 180.0f);
782         RNA_def_property_ui_text(prop, "IK Z Maximum", "Maximum angles for IK Limit");
783         RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Pose_IK_update");
784
785         prop= RNA_def_property(srna, "ik_stiffness_x", PROP_FLOAT, PROP_NONE);
786         RNA_def_property_float_sdna(prop, NULL, "stiffness[0]");
787         RNA_def_property_range(prop, 0.0f, 0.99f);
788         RNA_def_property_ui_text(prop, "IK X Stiffness", "IK stiffness around the X axis.");
789         RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Pose_IK_update");
790
791         prop= RNA_def_property(srna, "ik_stiffness_y", PROP_FLOAT, PROP_NONE);
792         RNA_def_property_float_sdna(prop, NULL, "stiffness[1]");
793         RNA_def_property_range(prop, 0.0f, 0.99f);
794         RNA_def_property_ui_text(prop, "IK Y Stiffness", "IK stiffness around the Y axis.");
795         RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Pose_IK_update");
796
797         prop= RNA_def_property(srna, "ik_stiffness_z", PROP_FLOAT, PROP_NONE);
798         RNA_def_property_float_sdna(prop, NULL, "stiffness[2]");
799         RNA_def_property_range(prop, 0.0f, 0.99f);
800         RNA_def_property_ui_text(prop, "IK Z Stiffness", "IK stiffness around the Z axis.");
801         RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Pose_IK_update");
802
803         prop= RNA_def_property(srna, "ik_stretch", PROP_FLOAT, PROP_NONE);
804         RNA_def_property_float_sdna(prop, NULL, "ikstretch");
805         RNA_def_property_range(prop, 0.0f,1.0f);
806         RNA_def_property_ui_text(prop, "IK Stretch", "Allow scaling of the bone for IK.");
807         RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Pose_IK_update");
808         
809         prop= RNA_def_property(srna, "ik_rot_weight", PROP_FLOAT, PROP_NONE);
810         RNA_def_property_float_sdna(prop, NULL, "ikrotweight");
811         RNA_def_property_range(prop, 0.0f,1.0f);
812         RNA_def_property_ui_text(prop, "IK Rot Weight", "Weight of rotation constraint for IK.");
813         RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Pose_update");
814         
815         prop= RNA_def_property(srna, "ik_lin_weight", PROP_FLOAT, PROP_NONE);
816         RNA_def_property_float_sdna(prop, NULL, "iklinweight");
817         RNA_def_property_range(prop, 0.0f,1.0f);
818         RNA_def_property_ui_text(prop, "IK Lin Weight", "Weight of scale constraint for IK.");
819         RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Pose_update");
820         
821         /* custom bone shapes */
822         prop= RNA_def_property(srna, "custom_shape", PROP_POINTER, PROP_NONE);
823         RNA_def_property_pointer_sdna(prop, NULL, "custom");
824         RNA_def_property_struct_type(prop, "Object");
825         RNA_def_property_flag(prop, PROP_EDITABLE);
826         RNA_def_property_ui_text(prop, "Custom Object", "Object that defines custom draw type for this bone.");
827         RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Pose_update");
828         
829         /* bone groups */
830         prop= RNA_def_property(srna, "bone_group_index", PROP_INT, PROP_NONE);
831         RNA_def_property_int_sdna(prop, NULL, "agrp_index");
832         RNA_def_property_flag(prop, PROP_EDITABLE);
833         RNA_def_property_int_funcs(prop, "rna_PoseChannel_bone_group_index_get", "rna_PoseChannel_bone_group_index_set", "rna_PoseChannel_bone_group_index_range");
834         RNA_def_property_ui_text(prop, "Bone Group Index", "Bone Group this pose channel belongs to (0=no group).");
835         RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Pose_update");
836         
837         prop= RNA_def_property(srna, "bone_group", PROP_POINTER, PROP_NONE);
838         RNA_def_property_struct_type(prop, "BoneGroup");
839         RNA_def_property_flag(prop, PROP_EDITABLE);
840         RNA_def_property_pointer_funcs(prop, "rna_PoseChannel_bone_group_get", "rna_PoseChannel_bone_group_set", NULL);
841         RNA_def_property_ui_text(prop, "Bone Group", "Bone Group this pose channel belongs to");
842         RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Pose_update");
843         
844         /* transform locks */
845         prop= RNA_def_property(srna, "lock_location", PROP_BOOLEAN, PROP_XYZ);
846         RNA_def_property_boolean_sdna(prop, NULL, "protectflag", OB_LOCK_LOCX);
847         RNA_def_property_array(prop, 3);
848         RNA_def_property_ui_text(prop, "Lock Location", "Lock editing of location in the interface.");
849         RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Pose_update");
850
851         prop= RNA_def_property(srna, "lock_rotation", PROP_BOOLEAN, PROP_XYZ);
852         RNA_def_property_boolean_sdna(prop, NULL, "protectflag", OB_LOCK_ROTX);
853         RNA_def_property_array(prop, 3);
854         RNA_def_property_ui_text(prop, "Lock Rotation", "Lock editing of rotation in the interface.");
855         RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Pose_update");
856         
857                 // XXX this is sub-optimal - it really should be included above, but due to technical reasons we can't do this!
858         prop= RNA_def_property(srna, "lock_rotation_w", PROP_BOOLEAN, PROP_NONE);
859         RNA_def_property_boolean_sdna(prop, NULL, "protectflag", OB_LOCK_ROTW);
860         RNA_def_property_ui_text(prop, "Lock Rotation (4D Angle)", "Lock editing of 'angle' component of four-component rotations in the interface.");
861         RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Pose_update");
862                 // XXX this needs a better name
863         prop= RNA_def_property(srna, "lock_rotations_4d", PROP_BOOLEAN, PROP_NONE);
864         RNA_def_property_boolean_sdna(prop, NULL, "protectflag", OB_LOCK_ROT4D);
865         RNA_def_property_ui_text(prop, "Lock Rotations (4D)", "Lock editing of four component rotations by components (instead of as Eulers).");
866         RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Pose_update");
867
868         prop= RNA_def_property(srna, "lock_scale", PROP_BOOLEAN, PROP_XYZ);
869         RNA_def_property_boolean_sdna(prop, NULL, "protectflag", OB_LOCK_SCALEX);
870         RNA_def_property_array(prop, 3);
871         RNA_def_property_ui_text(prop, "Lock Scale", "Lock editing of scale in the interface.");
872         RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Pose_update");
873
874         RNA_api_pose_channel(srna);
875 }
876
877 static void rna_def_pose_itasc(BlenderRNA *brna)
878 {
879         static const EnumPropertyItem prop_itasc_mode_items[]= {
880                 {0, "ANIMATION", 0, "Animation", "Stateless solver computing pose starting from current action and non-IK constraints."},
881                 {ITASC_SIMULATION, "SIMULATION", 0, "Simulation", "Statefull solver running in real-time context and ignoring actions and non-IK constraints."},
882                 {0, NULL, 0, NULL, NULL}};
883         static const EnumPropertyItem prop_itasc_reiteration_items[]= {
884                 {0, "NEVER", 0, "Never", "The solver does not reiterate, not even on first frame (starts from rest pose)."},
885                 {ITASC_INITIAL_REITERATION, "INITIAL", 0, "Initial", "The solver reiterates (converges) on the first frame but not on subsequent frame."},
886                 {ITASC_INITIAL_REITERATION|ITASC_REITERATION, "ALWAYS", 0, "Always", "The solver reiterates (converges) on all frames."},
887                 {0, NULL, 0, NULL, NULL}};
888
889         StructRNA *srna;
890         PropertyRNA *prop;
891
892         srna= RNA_def_struct(brna, "Itasc", "IKParam");
893         RNA_def_struct_sdna(srna, "bItasc");
894         RNA_def_struct_ui_text(srna, "bItasc", "Parameters for the iTaSC IK solver.");
895
896         prop= RNA_def_property(srna, "precision", PROP_FLOAT, PROP_NONE);
897         RNA_def_property_float_sdna(prop, NULL, "precision");
898         RNA_def_property_range(prop, 0.0f,0.1f);
899         RNA_def_property_ui_text(prop, "Precision", "Precision of convergence in case of reiteration.");
900         RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Itasc_update");
901
902         prop= RNA_def_property(srna, "num_iter", PROP_INT, PROP_NONE);
903         RNA_def_property_int_sdna(prop, NULL, "numiter");
904         RNA_def_property_range(prop, 1.f,1000.f);
905         RNA_def_property_ui_text(prop, "Iterations", "Maximum number of iterations for convergence in case of reiteration.");
906         RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Itasc_update");
907
908         prop= RNA_def_property(srna, "num_step", PROP_INT, PROP_NONE);
909         RNA_def_property_int_sdna(prop, NULL, "numstep");
910         RNA_def_property_range(prop, 1.f, 50.f);
911         RNA_def_property_ui_text(prop, "Num steps", "Divides the frame interval into this many steps.");
912         RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Itasc_update");
913
914         prop= RNA_def_property(srna, "mode", PROP_ENUM, PROP_NONE);
915         RNA_def_property_enum_bitflag_sdna(prop, NULL, "flag");
916         RNA_def_property_enum_items(prop, prop_itasc_mode_items);
917         RNA_def_property_ui_text(prop, "Mode", NULL);
918         RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Itasc_update_rebuild");
919
920         prop= RNA_def_property(srna, "reiteration", PROP_ENUM, PROP_NONE);
921         RNA_def_property_enum_bitflag_sdna(prop, NULL, "flag");
922         RNA_def_property_enum_items(prop, prop_itasc_reiteration_items);
923         RNA_def_property_ui_text(prop, "Reiteration", "Defines if the solver is allowed to reiterate (converges until precision is met) on none, first or all frames");
924         RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Itasc_update");
925
926         prop= RNA_def_property(srna, "auto_step", PROP_BOOLEAN, PROP_NONE);
927         RNA_def_property_boolean_sdna(prop, NULL, "flag", ITASC_AUTO_STEP);
928         RNA_def_property_ui_text(prop, "Auto step", "Automatically determine the optimal number of steps for best performance/accurary trade off.");
929         RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Itasc_update");
930
931         prop= RNA_def_property(srna, "min_step", PROP_FLOAT, PROP_NONE);
932         RNA_def_property_float_sdna(prop, NULL, "minstep");
933         RNA_def_property_range(prop, 0.0f,0.1f);
934         RNA_def_property_ui_text(prop, "Min step", "Lower bound for timestep in second in case of automatic substeps.");
935         RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Itasc_update");
936
937         prop= RNA_def_property(srna, "max_step", PROP_FLOAT, PROP_NONE);
938         RNA_def_property_float_sdna(prop, NULL, "maxstep");
939         RNA_def_property_range(prop, 0.0f,1.0f);
940         RNA_def_property_ui_text(prop, "Max step", "Higher bound for timestep in second in case of automatic substeps.");
941         RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Itasc_update");
942
943         prop= RNA_def_property(srna, "feedback", PROP_FLOAT, PROP_NONE);
944         RNA_def_property_float_sdna(prop, NULL, "feedback");
945         RNA_def_property_range(prop, 0.0f,100.0f);
946         RNA_def_property_ui_text(prop, "Feedback", "Feedback coefficient for error correction. Average response time=1/feedback. Default=20.");
947         RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Itasc_update");
948
949         prop= RNA_def_property(srna, "max_velocity", PROP_FLOAT, PROP_NONE);
950         RNA_def_property_float_sdna(prop, NULL, "maxvel");
951         RNA_def_property_range(prop, 0.0f,100.0f);
952         RNA_def_property_ui_text(prop, "Max Velocity", "Maximum joint velocity in rad/s. Default=50.");
953         RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Itasc_update");
954
955         prop= RNA_def_property(srna, "solver", PROP_ENUM, PROP_NONE);
956         RNA_def_property_enum_sdna(prop, NULL, "solver");
957         RNA_def_property_enum_items(prop, prop_solver_items);
958         RNA_def_property_ui_text(prop, "Solver", "Solving method selection: Automatic damping or manual damping");
959         RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Itasc_update_rebuild");
960
961         prop= RNA_def_property(srna, "dampmax", PROP_FLOAT, PROP_NONE);
962         RNA_def_property_float_sdna(prop, NULL, "dampmax");
963         RNA_def_property_range(prop, 0.0f,1.0f);
964         RNA_def_property_ui_text(prop, "Damp", "Maximum damping coefficient when singular value is nearly 0. Higher values=more stability, less reactivity. Default=0.5");
965         RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Itasc_update");
966
967         prop= RNA_def_property(srna, "dampeps", PROP_FLOAT, PROP_NONE);
968         RNA_def_property_float_sdna(prop, NULL, "dampeps");
969         RNA_def_property_range(prop, 0.0f,1.0f);
970         RNA_def_property_ui_text(prop, "Epsilon", "Singular value under which damping is progressively applied. Higher values=more stability, less reactivity. Default=0.1");
971         RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Itasc_update");
972 }
973
974 static void rna_def_pose_ikparam(BlenderRNA *brna)
975 {
976         StructRNA *srna;
977         PropertyRNA *prop;
978
979         srna= RNA_def_struct(brna, "IKParam", NULL);
980         RNA_def_struct_sdna(srna, "bIKParam");
981         RNA_def_struct_ui_text(srna, "IKParam", "Base type for IK solver parameters.");
982         RNA_def_struct_refine_func(srna, "rna_IKParam_refine");
983
984         prop= RNA_def_property(srna, "ik_solver", PROP_ENUM, PROP_NONE);
985         RNA_def_property_enum_sdna(prop, NULL, "iksolver");
986         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
987         RNA_def_property_enum_items(prop, prop_iksolver_items);
988         RNA_def_property_ui_text(prop, "IK Solver", "IK solver for which these parameters are defined, 0 for Legacy, 1 for iTaSC.");
989 }
990
991 static void rna_def_pose(BlenderRNA *brna)
992 {
993         StructRNA *srna;
994         PropertyRNA *prop;
995         
996         /* struct definition */
997         srna= RNA_def_struct(brna, "Pose", NULL);
998         RNA_def_struct_sdna(srna, "bPose");
999         RNA_def_struct_ui_text(srna, "Pose", "A collection of pose channels, including settings for animating bones.");
1000
1001         /* pose channels */
1002         prop= RNA_def_property(srna, "bones", PROP_COLLECTION, PROP_NONE);
1003         RNA_def_property_collection_sdna(prop, NULL, "chanbase", NULL);
1004         RNA_def_property_struct_type(prop, "PoseBone");
1005         RNA_def_property_ui_text(prop, "Pose Bones", "Individual pose bones for the armature.");
1006
1007         /* bone groups */
1008         prop= RNA_def_property(srna, "bone_groups", PROP_COLLECTION, PROP_NONE);
1009         RNA_def_property_collection_sdna(prop, NULL, "agroups", NULL);
1010         RNA_def_property_struct_type(prop, "BoneGroup");
1011         RNA_def_property_ui_text(prop, "Bone Groups", "Groups of the bones.");
1012
1013         prop= RNA_def_property(srna, "active_bone_group", PROP_POINTER, PROP_NONE);
1014         RNA_def_property_struct_type(prop, "BoneGroup");
1015         RNA_def_property_flag(prop, PROP_EDITABLE);
1016         RNA_def_property_pointer_funcs(prop, "rna_Pose_active_bone_group_get", "rna_Pose_active_bone_group_set", NULL);
1017         RNA_def_property_ui_text(prop, "Active Bone Group", "Active bone group for this pose.");
1018         RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Pose_update");
1019
1020         prop= RNA_def_property(srna, "active_bone_group_index", PROP_INT, PROP_NONE);
1021         RNA_def_property_int_sdna(prop, NULL, "active_group");
1022         RNA_def_property_int_funcs(prop, "rna_Pose_active_bone_group_index_get", "rna_Pose_active_bone_group_index_set", "rna_Pose_active_bone_group_index_range");
1023         RNA_def_property_ui_text(prop, "Active Bone Group Index", "Active index in bone groups array.");
1024         RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Pose_update");
1025
1026         prop= RNA_def_property(srna, "ik_solver", PROP_ENUM, PROP_NONE);
1027         RNA_def_property_enum_sdna(prop, NULL, "iksolver");
1028         RNA_def_property_enum_funcs(prop, NULL, "rna_Pose_ik_solver_set", NULL);
1029         RNA_def_property_enum_items(prop, prop_iksolver_items);
1030         RNA_def_property_ui_text(prop, "IK Solver", "Selection of IK solver for IK chain, current choice is 0 for Legacy, 1 for iTaSC.");
1031         RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Pose_ik_solver_update");
1032
1033         prop= RNA_def_property(srna, "ik_param", PROP_POINTER, PROP_NONE);
1034         RNA_def_property_struct_type(prop, "IKParam");
1035         RNA_def_property_pointer_funcs(prop, "rna_Pose_ikparam_get", NULL, "rna_Pose_ikparam_typef");
1036         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1037         RNA_def_property_ui_text(prop, "IK Param", "Parameters for IK solver.");
1038
1039         /* RNA_api_pose(srna); */
1040 }
1041
1042 void RNA_def_pose(BlenderRNA *brna)
1043 {
1044         rna_def_pose(brna);
1045         rna_def_pose_channel(brna);
1046         rna_def_pose_ikparam(brna);
1047         rna_def_pose_itasc(brna);
1048         rna_def_bone_group(brna);
1049 }
1050
1051 #endif