clone and stencil layer access added, renamed mask to stencil layer internally
[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         StructRNA *srna;
643         PropertyRNA *prop;
644
645         srna= RNA_def_struct(brna, "PoseBone", NULL);
646         RNA_def_struct_sdna(srna, "bPoseChannel");
647         RNA_def_struct_ui_text(srna, "Pose Bone", "Channel defining pose data for a bone in a Pose.");
648         RNA_def_struct_path_func(srna, "rna_PoseBone_path");
649         RNA_def_struct_idproperties_func(srna, "rna_PoseBone_idproperties");
650         
651         /* Bone Constraints */
652         prop= RNA_def_property(srna, "constraints", PROP_COLLECTION, PROP_NONE);
653         RNA_def_property_struct_type(prop, "Constraint");
654         RNA_def_property_ui_text(prop, "Constraints", "Constraints that act on this PoseChannel.");
655
656         rna_def_pose_channel_constraints(brna, prop);
657
658         /* Name + Selection Status */
659         prop= RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
660         RNA_def_property_string_funcs(prop, NULL, NULL, "rna_PoseChannel_name_set");
661         RNA_def_property_ui_text(prop, "Name", "");
662         RNA_def_struct_name_property(srna, prop);
663
664         prop= RNA_def_property(srna, "selected", PROP_BOOLEAN, PROP_NONE);
665         RNA_def_property_boolean_sdna(prop, NULL, "selectflag", BONE_SELECTED);
666         RNA_def_property_ui_text(prop, "Selected", "");
667
668         /* Baked Bone Path cache data s*/
669         prop= RNA_def_property(srna, "path_start_frame", PROP_INT, PROP_TIME);
670         RNA_def_property_int_sdna(prop, NULL, "pathsf");
671         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
672         RNA_def_property_ui_text(prop, "Bone Paths Calculation Start Frame", "Starting frame of range of frames to use for Bone Path calculations.");
673         RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Pose_update");
674
675         prop= RNA_def_property(srna, "path_end_frame", PROP_INT, PROP_TIME);
676         RNA_def_property_int_sdna(prop, NULL, "pathef");
677         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
678         RNA_def_property_ui_text(prop, "Bone Paths Calculation End Frame", "End frame of range of frames to use for Bone Path calculations.");
679         RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Pose_update");
680         
681         /* Relationships to other bones */
682         prop= RNA_def_property(srna, "bone", PROP_POINTER, PROP_NONE);
683         RNA_def_property_flag(prop, PROP_NEVER_NULL);
684         RNA_def_property_struct_type(prop, "Bone");
685         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
686         RNA_def_property_ui_text(prop, "Bone", "Bone associated with this PoseBone.");
687
688         prop= RNA_def_property(srna, "parent", PROP_POINTER, PROP_NONE);
689         RNA_def_property_struct_type(prop, "PoseBone");
690         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
691         RNA_def_property_ui_text(prop, "Parent", "Parent of this pose bone.");
692
693         prop= RNA_def_property(srna, "child", PROP_POINTER, PROP_NONE);
694         RNA_def_property_struct_type(prop, "PoseBone");
695         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
696         RNA_def_property_ui_text(prop, "Child", "Child of this pose bone.");
697         
698         /* Transformation settings */
699         prop= RNA_def_property(srna, "location", PROP_FLOAT, PROP_TRANSLATION);
700         RNA_def_property_float_sdna(prop, NULL, "loc");
701         RNA_def_property_editable_array_func(prop, "rna_PoseChannel_location_editable");
702         RNA_def_property_ui_text(prop, "Location", "");
703         RNA_def_property_update(prop, NC_OBJECT|ND_TRANSFORM, "rna_Pose_update");
704
705         prop= RNA_def_property(srna, "scale", PROP_FLOAT, PROP_XYZ);
706         RNA_def_property_float_sdna(prop, NULL, "size");
707         RNA_def_property_editable_array_func(prop, "rna_PoseChannel_scale_editable");
708         RNA_def_property_ui_text(prop, "Scale", "");
709         RNA_def_property_update(prop, NC_OBJECT|ND_TRANSFORM, "rna_Pose_update");
710
711         prop= RNA_def_property(srna, "rotation_quaternion", PROP_FLOAT, PROP_QUATERNION);
712         RNA_def_property_float_sdna(prop, NULL, "quat");
713         RNA_def_property_editable_array_func(prop, "rna_PoseChannel_rotation_4d_editable");
714         RNA_def_property_ui_text(prop, "Quaternion Rotation", "Rotation in Quaternions.");
715         RNA_def_property_update(prop, NC_OBJECT|ND_TRANSFORM, "rna_Pose_update");
716         
717                 /* XXX: for axis-angle, it would have been nice to have 2 separate fields for UI purposes, but
718                  * having a single one is better for Keyframing and other property-management situations...
719                  */
720         prop= RNA_def_property(srna, "rotation_axis_angle", PROP_FLOAT, PROP_AXISANGLE);
721         RNA_def_property_array(prop, 4); // TODO: maybe we'll need to define the 'default value' getter too...
722         RNA_def_property_float_funcs(prop, "rna_PoseChannel_rotation_axis_angle_get", "rna_PoseChannel_rotation_axis_angle_set", NULL);
723         RNA_def_property_editable_array_func(prop, "rna_PoseChannel_rotation_4d_editable");
724         RNA_def_property_ui_text(prop, "Axis-Angle Rotation", "Angle of Rotation for Axis-Angle rotation representation.");
725         RNA_def_property_update(prop, NC_OBJECT|ND_TRANSFORM, "rna_Pose_update");
726         
727         prop= RNA_def_property(srna, "rotation_euler", PROP_FLOAT, PROP_EULER);
728         RNA_def_property_float_sdna(prop, NULL, "eul");
729         RNA_def_property_editable_array_func(prop, "rna_PoseChannel_rotation_euler_editable");
730         RNA_def_property_ui_text(prop, "Euler Rotation", "Rotation in Eulers.");
731         RNA_def_property_update(prop, NC_OBJECT|ND_TRANSFORM, "rna_Pose_update");
732         
733         prop= RNA_def_property(srna, "rotation_mode", PROP_ENUM, PROP_NONE);
734         RNA_def_property_enum_sdna(prop, NULL, "rotmode");
735         RNA_def_property_enum_items(prop, prop_rotmode_items); // XXX move to using a single define of this someday
736         RNA_def_property_enum_funcs(prop, NULL, "rna_PoseChannel_rotation_mode_set", NULL);
737         RNA_def_property_ui_text(prop, "Rotation Mode", "");
738         RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Pose_update");
739         
740         /* transform matrices - should be read-only since these are set directly by AnimSys evaluation */
741         prop= RNA_def_property(srna, "channel_matrix", PROP_FLOAT, PROP_MATRIX);
742         RNA_def_property_float_sdna(prop, NULL, "chan_mat");
743         RNA_def_property_array(prop, 16);
744         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
745         RNA_def_property_ui_text(prop, "Channel Matrix", "4x4 matrix, before constraints.");
746         
747         prop= RNA_def_property(srna, "matrix", PROP_FLOAT, PROP_MATRIX);
748         RNA_def_property_float_sdna(prop, NULL, "pose_mat");
749         RNA_def_property_array(prop, 16);
750         RNA_def_property_clear_flag(prop, PROP_EDITABLE); 
751         RNA_def_property_ui_text(prop, "Pose Matrix", "Final 4x4 matrix for this channel.");
752
753         /*
754         prop= RNA_def_property(srna, "constraint_inverse_matrix", PROP_FLOAT, PROP_MATRIX);
755         RNA_def_property_struct_type(prop, "constinv");
756         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
757         RNA_def_property_ui_text(prop, "Constraint Inverse Matrix", "4x4 matrix, defines transform from final position to unconstrained position.");
758         */
759         
760         /* Head/Tail Coordinates (in Pose Space) - Automatically calculated... */
761         prop= RNA_def_property(srna, "head", PROP_FLOAT, PROP_TRANSLATION);
762         RNA_def_property_float_sdna(prop, NULL, "pose_head");
763         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
764         RNA_def_property_ui_text(prop, "Pose Head Position", "Location of head of the channel's bone.");
765
766         prop= RNA_def_property(srna, "tail", PROP_FLOAT, PROP_TRANSLATION);
767         RNA_def_property_float_sdna(prop, NULL, "pose_tail");
768         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
769         RNA_def_property_ui_text(prop, "Pose Tail Position", "Location of tail of the channel's bone.");
770         
771         /* IK Settings */
772         prop= RNA_def_property(srna, "has_ik", PROP_BOOLEAN, PROP_NONE);
773         RNA_def_property_boolean_funcs(prop,  "rna_PoseChannel_has_ik_get", NULL);
774         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
775         RNA_def_property_ui_text(prop, "Has IK", "Is part of an IK chain.");
776         RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Pose_IK_update");
777
778         prop= RNA_def_property(srna, "ik_dof_x", PROP_BOOLEAN, PROP_NONE);
779         RNA_def_property_boolean_negative_sdna(prop, NULL, "ikflag", BONE_IK_NO_XDOF);
780         RNA_def_property_ui_text(prop, "IK X DoF", "Allow movement around the X axis.");
781         RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Pose_IK_update");
782
783         prop= RNA_def_property(srna, "ik_dof_y", PROP_BOOLEAN, PROP_NONE);
784         RNA_def_property_boolean_negative_sdna(prop, NULL, "ikflag", BONE_IK_NO_YDOF);
785         RNA_def_property_ui_text(prop, "IK Y DoF", "Allow movement around the Y axis.");
786         RNA_def_property_update(prop, NC_OBJECT|ND_POSE|ND_TRANSFORM, "rna_Pose_IK_update");
787
788         prop= RNA_def_property(srna, "ik_dof_z", PROP_BOOLEAN, PROP_NONE);
789         RNA_def_property_boolean_negative_sdna(prop, NULL, "ikflag", BONE_IK_NO_ZDOF);
790         RNA_def_property_ui_text(prop, "IK Z DoF", "Allow movement around the Z axis.");
791         RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Pose_IK_update");
792
793         prop= RNA_def_property(srna, "ik_limit_x", PROP_BOOLEAN, PROP_NONE);
794         RNA_def_property_boolean_sdna(prop, NULL, "ikflag", BONE_IK_XLIMIT);
795         RNA_def_property_ui_text(prop, "IK X Limit", "Limit movement around the X axis.");
796         RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Pose_IK_update");
797
798         prop= RNA_def_property(srna, "ik_limit_y", PROP_BOOLEAN, PROP_NONE);
799         RNA_def_property_boolean_sdna(prop, NULL, "ikflag", BONE_IK_YLIMIT);
800         RNA_def_property_ui_text(prop, "IK Y Limit", "Limit movement around the Y axis.");
801         RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Pose_IK_update");
802
803         prop= RNA_def_property(srna, "ik_limit_z", PROP_BOOLEAN, PROP_NONE);
804         RNA_def_property_boolean_sdna(prop, NULL, "ikflag", BONE_IK_ZLIMIT);
805         RNA_def_property_ui_text(prop, "IK Z Limit", "Limit movement around the Z axis.");
806         RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Pose_IK_update");
807         
808         prop= RNA_def_property(srna, "ik_rot_control", PROP_BOOLEAN, PROP_NONE);
809         RNA_def_property_boolean_sdna(prop, NULL, "ikflag", BONE_IK_ROTCTL);
810         RNA_def_property_ui_text(prop, "IK rot control", "Apply channel rotation as IK constraint");
811         RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Pose_IK_update");
812         
813         prop= RNA_def_property(srna, "ik_lin_control", PROP_BOOLEAN, PROP_NONE);
814         RNA_def_property_boolean_sdna(prop, NULL, "ikflag", BONE_IK_LINCTL);
815         RNA_def_property_ui_text(prop, "IK rot control", "Apply channel size as IK constraint if stretching is enabled");
816         RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Pose_IK_update");
817         
818         prop= RNA_def_property(srna, "ik_min_x", PROP_FLOAT, PROP_ANGLE);
819         RNA_def_property_float_sdna(prop, NULL, "limitmin[0]");
820         RNA_def_property_range(prop, -180.0f, 0.0f);
821         RNA_def_property_ui_text(prop, "IK X Minimum", "Minimum angles for IK Limit");
822         RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Pose_IK_update");
823
824         prop= RNA_def_property(srna, "ik_max_x", PROP_FLOAT, PROP_ANGLE);
825         RNA_def_property_float_sdna(prop, NULL, "limitmax[0]");
826         RNA_def_property_range(prop, 0.0f, 180.0f);
827         RNA_def_property_ui_text(prop, "IK X Maximum", "Maximum angles for IK Limit");
828         RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Pose_IK_update");
829
830         prop= RNA_def_property(srna, "ik_min_y", PROP_FLOAT, PROP_ANGLE);
831         RNA_def_property_float_sdna(prop, NULL, "limitmin[1]");
832         RNA_def_property_range(prop, -180.0f, 0.0f);
833         RNA_def_property_ui_text(prop, "IK Y Minimum", "Minimum angles for IK Limit");
834         RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Pose_IK_update");
835
836         prop= RNA_def_property(srna, "ik_max_y", PROP_FLOAT, PROP_ANGLE);
837         RNA_def_property_float_sdna(prop, NULL, "limitmax[1]");
838         RNA_def_property_range(prop, 0.0f, 180.0f);
839         RNA_def_property_ui_text(prop, "IK Y Maximum", "Maximum angles for IK Limit");
840         RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Pose_IK_update");
841
842         prop= RNA_def_property(srna, "ik_min_z", PROP_FLOAT, PROP_ANGLE);
843         RNA_def_property_float_sdna(prop, NULL, "limitmin[2]");
844         RNA_def_property_range(prop, -180.0f, 0.0f);
845         RNA_def_property_ui_text(prop, "IK Z Minimum", "Minimum angles for IK Limit");
846         RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Pose_IK_update");
847
848         prop= RNA_def_property(srna, "ik_max_z", PROP_FLOAT, PROP_ANGLE);
849         RNA_def_property_float_sdna(prop, NULL, "limitmax[2]");
850         RNA_def_property_range(prop, 0.0f, 180.0f);
851         RNA_def_property_ui_text(prop, "IK Z Maximum", "Maximum angles for IK Limit");
852         RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Pose_IK_update");
853
854         prop= RNA_def_property(srna, "ik_stiffness_x", PROP_FLOAT, PROP_NONE);
855         RNA_def_property_float_sdna(prop, NULL, "stiffness[0]");
856         RNA_def_property_range(prop, 0.0f, 0.99f);
857         RNA_def_property_ui_text(prop, "IK X Stiffness", "IK stiffness around the X axis.");
858         RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Pose_IK_update");
859
860         prop= RNA_def_property(srna, "ik_stiffness_y", PROP_FLOAT, PROP_NONE);
861         RNA_def_property_float_sdna(prop, NULL, "stiffness[1]");
862         RNA_def_property_range(prop, 0.0f, 0.99f);
863         RNA_def_property_ui_text(prop, "IK Y Stiffness", "IK stiffness around the Y axis.");
864         RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Pose_IK_update");
865
866         prop= RNA_def_property(srna, "ik_stiffness_z", PROP_FLOAT, PROP_NONE);
867         RNA_def_property_float_sdna(prop, NULL, "stiffness[2]");
868         RNA_def_property_range(prop, 0.0f, 0.99f);
869         RNA_def_property_ui_text(prop, "IK Z Stiffness", "IK stiffness around the Z axis.");
870         RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Pose_IK_update");
871
872         prop= RNA_def_property(srna, "ik_stretch", PROP_FLOAT, PROP_NONE);
873         RNA_def_property_float_sdna(prop, NULL, "ikstretch");
874         RNA_def_property_range(prop, 0.0f,1.0f);
875         RNA_def_property_ui_text(prop, "IK Stretch", "Allow scaling of the bone for IK.");
876         RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Pose_IK_update");
877         
878         prop= RNA_def_property(srna, "ik_rot_weight", PROP_FLOAT, PROP_NONE);
879         RNA_def_property_float_sdna(prop, NULL, "ikrotweight");
880         RNA_def_property_range(prop, 0.0f,1.0f);
881         RNA_def_property_ui_text(prop, "IK Rot Weight", "Weight of rotation constraint for IK.");
882         RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Pose_update");
883         
884         prop= RNA_def_property(srna, "ik_lin_weight", PROP_FLOAT, PROP_NONE);
885         RNA_def_property_float_sdna(prop, NULL, "iklinweight");
886         RNA_def_property_range(prop, 0.0f,1.0f);
887         RNA_def_property_ui_text(prop, "IK Lin Weight", "Weight of scale constraint for IK.");
888         RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Pose_update");
889         
890         /* custom bone shapes */
891         prop= RNA_def_property(srna, "custom_shape", PROP_POINTER, PROP_NONE);
892         RNA_def_property_pointer_sdna(prop, NULL, "custom");
893         RNA_def_property_struct_type(prop, "Object");
894         RNA_def_property_flag(prop, PROP_EDITABLE);
895         RNA_def_property_ui_text(prop, "Custom Object", "Object that defines custom draw type for this bone.");
896         RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Pose_update");
897         
898         /* bone groups */
899         prop= RNA_def_property(srna, "bone_group_index", PROP_INT, PROP_NONE);
900         RNA_def_property_int_sdna(prop, NULL, "agrp_index");
901         RNA_def_property_flag(prop, PROP_EDITABLE);
902         RNA_def_property_int_funcs(prop, "rna_PoseChannel_bone_group_index_get", "rna_PoseChannel_bone_group_index_set", "rna_PoseChannel_bone_group_index_range");
903         RNA_def_property_ui_text(prop, "Bone Group Index", "Bone Group this pose channel belongs to (0=no group).");
904         RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Pose_update");
905         
906         prop= RNA_def_property(srna, "bone_group", PROP_POINTER, PROP_NONE);
907         RNA_def_property_struct_type(prop, "BoneGroup");
908         RNA_def_property_flag(prop, PROP_EDITABLE);
909         RNA_def_property_pointer_funcs(prop, "rna_PoseChannel_bone_group_get", "rna_PoseChannel_bone_group_set", NULL);
910         RNA_def_property_ui_text(prop, "Bone Group", "Bone Group this pose channel belongs to");
911         RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Pose_update");
912         
913         /* transform locks */
914         prop= RNA_def_property(srna, "lock_location", PROP_BOOLEAN, PROP_XYZ);
915         RNA_def_property_boolean_sdna(prop, NULL, "protectflag", OB_LOCK_LOCX);
916         RNA_def_property_array(prop, 3);
917         RNA_def_property_ui_text(prop, "Lock Location", "Lock editing of location in the interface.");
918         RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Pose_update");
919
920         prop= RNA_def_property(srna, "lock_rotation", PROP_BOOLEAN, PROP_XYZ);
921         RNA_def_property_boolean_sdna(prop, NULL, "protectflag", OB_LOCK_ROTX);
922         RNA_def_property_array(prop, 3);
923         RNA_def_property_ui_text(prop, "Lock Rotation", "Lock editing of rotation in the interface.");
924         RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Pose_update");
925         
926                 // XXX this is sub-optimal - it really should be included above, but due to technical reasons we can't do this!
927         prop= RNA_def_property(srna, "lock_rotation_w", PROP_BOOLEAN, PROP_NONE);
928         RNA_def_property_boolean_sdna(prop, NULL, "protectflag", OB_LOCK_ROTW);
929         RNA_def_property_ui_text(prop, "Lock Rotation (4D Angle)", "Lock editing of 'angle' component of four-component rotations in the interface.");
930         RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Pose_update");
931                 // XXX this needs a better name
932         prop= RNA_def_property(srna, "lock_rotations_4d", PROP_BOOLEAN, PROP_NONE);
933         RNA_def_property_boolean_sdna(prop, NULL, "protectflag", OB_LOCK_ROT4D);
934         RNA_def_property_ui_text(prop, "Lock Rotations (4D)", "Lock editing of four component rotations by components (instead of as Eulers).");
935         RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Pose_update");
936
937         prop= RNA_def_property(srna, "lock_scale", PROP_BOOLEAN, PROP_XYZ);
938         RNA_def_property_boolean_sdna(prop, NULL, "protectflag", OB_LOCK_SCALEX);
939         RNA_def_property_array(prop, 3);
940         RNA_def_property_ui_text(prop, "Lock Scale", "Lock editing of scale in the interface.");
941         RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Pose_update");
942
943         RNA_api_pose_channel(srna);
944 }
945
946 static void rna_def_pose_itasc(BlenderRNA *brna)
947 {
948         static const EnumPropertyItem prop_itasc_mode_items[]= {
949                 {0, "ANIMATION", 0, "Animation", "Stateless solver computing pose starting from current action and non-IK constraints."},
950                 {ITASC_SIMULATION, "SIMULATION", 0, "Simulation", "Statefull solver running in real-time context and ignoring actions and non-IK constraints."},
951                 {0, NULL, 0, NULL, NULL}};
952         static const EnumPropertyItem prop_itasc_reiteration_items[]= {
953                 {0, "NEVER", 0, "Never", "The solver does not reiterate, not even on first frame (starts from rest pose)."},
954                 {ITASC_INITIAL_REITERATION, "INITIAL", 0, "Initial", "The solver reiterates (converges) on the first frame but not on subsequent frame."},
955                 {ITASC_INITIAL_REITERATION|ITASC_REITERATION, "ALWAYS", 0, "Always", "The solver reiterates (converges) on all frames."},
956                 {0, NULL, 0, NULL, NULL}};
957
958         StructRNA *srna;
959         PropertyRNA *prop;
960
961         srna= RNA_def_struct(brna, "Itasc", "IKParam");
962         RNA_def_struct_sdna(srna, "bItasc");
963         RNA_def_struct_ui_text(srna, "bItasc", "Parameters for the iTaSC IK solver.");
964
965         prop= RNA_def_property(srna, "precision", PROP_FLOAT, PROP_NONE);
966         RNA_def_property_float_sdna(prop, NULL, "precision");
967         RNA_def_property_range(prop, 0.0f,0.1f);
968         RNA_def_property_ui_text(prop, "Precision", "Precision of convergence in case of reiteration.");
969         RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Itasc_update");
970
971         prop= RNA_def_property(srna, "num_iter", PROP_INT, PROP_NONE);
972         RNA_def_property_int_sdna(prop, NULL, "numiter");
973         RNA_def_property_range(prop, 1.f,1000.f);
974         RNA_def_property_ui_text(prop, "Iterations", "Maximum number of iterations for convergence in case of reiteration.");
975         RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Itasc_update");
976
977         prop= RNA_def_property(srna, "num_step", PROP_INT, PROP_NONE);
978         RNA_def_property_int_sdna(prop, NULL, "numstep");
979         RNA_def_property_range(prop, 1.f, 50.f);
980         RNA_def_property_ui_text(prop, "Num steps", "Divides the frame interval into this many steps.");
981         RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Itasc_update");
982
983         prop= RNA_def_property(srna, "mode", PROP_ENUM, PROP_NONE);
984         RNA_def_property_enum_bitflag_sdna(prop, NULL, "flag");
985         RNA_def_property_enum_items(prop, prop_itasc_mode_items);
986         RNA_def_property_ui_text(prop, "Mode", NULL);
987         RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Itasc_update_rebuild");
988
989         prop= RNA_def_property(srna, "reiteration", PROP_ENUM, PROP_NONE);
990         RNA_def_property_enum_bitflag_sdna(prop, NULL, "flag");
991         RNA_def_property_enum_items(prop, prop_itasc_reiteration_items);
992         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");
993         RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Itasc_update");
994
995         prop= RNA_def_property(srna, "auto_step", PROP_BOOLEAN, PROP_NONE);
996         RNA_def_property_boolean_sdna(prop, NULL, "flag", ITASC_AUTO_STEP);
997         RNA_def_property_ui_text(prop, "Auto step", "Automatically determine the optimal number of steps for best performance/accurary trade off.");
998         RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Itasc_update");
999
1000         prop= RNA_def_property(srna, "min_step", PROP_FLOAT, PROP_NONE);
1001         RNA_def_property_float_sdna(prop, NULL, "minstep");
1002         RNA_def_property_range(prop, 0.0f,0.1f);
1003         RNA_def_property_ui_text(prop, "Min step", "Lower bound for timestep in second in case of automatic substeps.");
1004         RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Itasc_update");
1005
1006         prop= RNA_def_property(srna, "max_step", PROP_FLOAT, PROP_NONE);
1007         RNA_def_property_float_sdna(prop, NULL, "maxstep");
1008         RNA_def_property_range(prop, 0.0f,1.0f);
1009         RNA_def_property_ui_text(prop, "Max step", "Higher bound for timestep in second in case of automatic substeps.");
1010         RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Itasc_update");
1011
1012         prop= RNA_def_property(srna, "feedback", PROP_FLOAT, PROP_NONE);
1013         RNA_def_property_float_sdna(prop, NULL, "feedback");
1014         RNA_def_property_range(prop, 0.0f,100.0f);
1015         RNA_def_property_ui_text(prop, "Feedback", "Feedback coefficient for error correction. Average response time=1/feedback. Default=20.");
1016         RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Itasc_update");
1017
1018         prop= RNA_def_property(srna, "max_velocity", PROP_FLOAT, PROP_NONE);
1019         RNA_def_property_float_sdna(prop, NULL, "maxvel");
1020         RNA_def_property_range(prop, 0.0f,100.0f);
1021         RNA_def_property_ui_text(prop, "Max Velocity", "Maximum joint velocity in rad/s. Default=50.");
1022         RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Itasc_update");
1023
1024         prop= RNA_def_property(srna, "solver", PROP_ENUM, PROP_NONE);
1025         RNA_def_property_enum_sdna(prop, NULL, "solver");
1026         RNA_def_property_enum_items(prop, prop_solver_items);
1027         RNA_def_property_ui_text(prop, "Solver", "Solving method selection: Automatic damping or manual damping");
1028         RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Itasc_update_rebuild");
1029
1030         prop= RNA_def_property(srna, "dampmax", PROP_FLOAT, PROP_NONE);
1031         RNA_def_property_float_sdna(prop, NULL, "dampmax");
1032         RNA_def_property_range(prop, 0.0f,1.0f);
1033         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");
1034         RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Itasc_update");
1035
1036         prop= RNA_def_property(srna, "dampeps", PROP_FLOAT, PROP_NONE);
1037         RNA_def_property_float_sdna(prop, NULL, "dampeps");
1038         RNA_def_property_range(prop, 0.0f,1.0f);
1039         RNA_def_property_ui_text(prop, "Epsilon", "Singular value under which damping is progressively applied. Higher values=more stability, less reactivity. Default=0.1");
1040         RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Itasc_update");
1041 }
1042
1043 static void rna_def_pose_ikparam(BlenderRNA *brna)
1044 {
1045         StructRNA *srna;
1046         PropertyRNA *prop;
1047
1048         srna= RNA_def_struct(brna, "IKParam", NULL);
1049         RNA_def_struct_sdna(srna, "bIKParam");
1050         RNA_def_struct_ui_text(srna, "IKParam", "Base type for IK solver parameters.");
1051         RNA_def_struct_refine_func(srna, "rna_IKParam_refine");
1052
1053         prop= RNA_def_property(srna, "ik_solver", PROP_ENUM, PROP_NONE);
1054         RNA_def_property_enum_sdna(prop, NULL, "iksolver");
1055         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1056         RNA_def_property_enum_items(prop, prop_iksolver_items);
1057         RNA_def_property_ui_text(prop, "IK Solver", "IK solver for which these parameters are defined, 0 for Legacy, 1 for iTaSC.");
1058 }
1059
1060 static void rna_def_pose(BlenderRNA *brna)
1061 {
1062         StructRNA *srna;
1063         PropertyRNA *prop;
1064         
1065         /* struct definition */
1066         srna= RNA_def_struct(brna, "Pose", NULL);
1067         RNA_def_struct_sdna(srna, "bPose");
1068         RNA_def_struct_ui_text(srna, "Pose", "A collection of pose channels, including settings for animating bones.");
1069
1070         /* pose channels */
1071         prop= RNA_def_property(srna, "bones", PROP_COLLECTION, PROP_NONE);
1072         RNA_def_property_collection_sdna(prop, NULL, "chanbase", NULL);
1073         RNA_def_property_struct_type(prop, "PoseBone");
1074         RNA_def_property_ui_text(prop, "Pose Bones", "Individual pose bones for the armature.");
1075
1076         /* bone groups */
1077         prop= RNA_def_property(srna, "bone_groups", PROP_COLLECTION, PROP_NONE);
1078         RNA_def_property_collection_sdna(prop, NULL, "agroups", NULL);
1079         RNA_def_property_struct_type(prop, "BoneGroup");
1080         RNA_def_property_ui_text(prop, "Bone Groups", "Groups of the bones.");
1081
1082         prop= RNA_def_property(srna, "active_bone_group", PROP_POINTER, PROP_NONE);
1083         RNA_def_property_struct_type(prop, "BoneGroup");
1084         RNA_def_property_flag(prop, PROP_EDITABLE);
1085         RNA_def_property_pointer_funcs(prop, "rna_Pose_active_bone_group_get", "rna_Pose_active_bone_group_set", NULL);
1086         RNA_def_property_ui_text(prop, "Active Bone Group", "Active bone group for this pose.");
1087         RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Pose_update");
1088
1089         prop= RNA_def_property(srna, "active_bone_group_index", PROP_INT, PROP_NONE);
1090         RNA_def_property_int_sdna(prop, NULL, "active_group");
1091         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");
1092         RNA_def_property_ui_text(prop, "Active Bone Group Index", "Active index in bone groups array.");
1093         RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Pose_update");
1094
1095         prop= RNA_def_property(srna, "ik_solver", PROP_ENUM, PROP_NONE);
1096         RNA_def_property_enum_sdna(prop, NULL, "iksolver");
1097         RNA_def_property_enum_funcs(prop, NULL, "rna_Pose_ik_solver_set", NULL);
1098         RNA_def_property_enum_items(prop, prop_iksolver_items);
1099         RNA_def_property_ui_text(prop, "IK Solver", "Selection of IK solver for IK chain, current choice is 0 for Legacy, 1 for iTaSC.");
1100         RNA_def_property_update(prop, NC_OBJECT|ND_POSE, "rna_Pose_ik_solver_update");
1101
1102         prop= RNA_def_property(srna, "ik_param", PROP_POINTER, PROP_NONE);
1103         RNA_def_property_struct_type(prop, "IKParam");
1104         RNA_def_property_pointer_funcs(prop, "rna_Pose_ikparam_get", NULL, "rna_Pose_ikparam_typef");
1105         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1106         RNA_def_property_ui_text(prop, "IK Param", "Parameters for IK solver.");
1107
1108         /* RNA_api_pose(srna); */
1109 }
1110
1111 void RNA_def_pose(BlenderRNA *brna)
1112 {
1113         rna_def_pose(brna);
1114         rna_def_pose_channel(brna);
1115         rna_def_pose_ikparam(brna);
1116         rna_def_pose_itasc(brna);
1117         rna_def_bone_group(brna);
1118 }
1119
1120 #endif