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