Drivers UI: Debug Info
[blender.git] / source / blender / makesrna / intern / rna_fcurve.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 (2009), Joshua Leung
21  *
22  * ***** END GPL LICENSE BLOCK *****
23  */
24
25 #include <stdlib.h>
26
27 #include "RNA_access.h"
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_anim_types.h"
35 #include "DNA_object_types.h"
36 #include "DNA_scene_types.h"
37
38 #include "MEM_guardedalloc.h"
39
40 #include "WM_types.h"
41
42 EnumPropertyItem fmodifier_type_items[] = {
43         {FMODIFIER_TYPE_NULL, "NULL", 0, "Invalid", ""},
44         {FMODIFIER_TYPE_GENERATOR, "GENERATOR", 0, "Generator", ""},
45         {FMODIFIER_TYPE_FN_GENERATOR, "FNGENERATOR", 0, "Built-In Function", ""},
46         {FMODIFIER_TYPE_ENVELOPE, "ENVELOPE", 0, "Envelope", ""},
47         {FMODIFIER_TYPE_CYCLES, "CYCLES", 0, "Cycles", ""},
48         {FMODIFIER_TYPE_NOISE, "NOISE", 0, "Noise", ""},
49         {FMODIFIER_TYPE_FILTER, "FILTER", 0, "Filter", ""},
50         {FMODIFIER_TYPE_PYTHON, "PYTHON", 0, "Python", ""},
51         {FMODIFIER_TYPE_LIMITS, "LIMITS", 0, "Limits", ""},
52         {0, NULL, 0, NULL, NULL}};
53
54 #ifdef RNA_RUNTIME
55
56 #include "WM_api.h"
57
58 static StructRNA *rna_FModifierType_refine(struct PointerRNA *ptr)
59 {
60         FModifier *fcm= (FModifier *)ptr->data;
61
62         switch (fcm->type) {
63                 case FMODIFIER_TYPE_GENERATOR:
64                         return &RNA_FModifierGenerator;
65                 case FMODIFIER_TYPE_FN_GENERATOR:
66                         return &RNA_FModifierFunctionGenerator;
67                 case FMODIFIER_TYPE_ENVELOPE:
68                         return &RNA_FModifierEnvelope;
69                 case FMODIFIER_TYPE_CYCLES:
70                         return &RNA_FModifierCycles;
71                 case FMODIFIER_TYPE_NOISE:
72                         return &RNA_FModifierNoise;
73                 //case FMODIFIER_TYPE_FILTER:
74                 //      return &RNA_FModifierFilter;
75                 case FMODIFIER_TYPE_PYTHON:
76                         return &RNA_FModifierPython;
77                 case FMODIFIER_TYPE_LIMITS:
78                         return &RNA_FModifierLimits;
79                 default:
80                         return &RNA_UnknownType;
81         }
82 }
83
84 /* ****************************** */
85
86 #include "BKE_fcurve.h"
87 #include "BKE_depsgraph.h"
88 #include "BKE_animsys.h"
89
90 static void rna_ChannelDriver_update_data(Main *bmain, Scene *scene, PointerRNA *ptr)
91 {
92         ID *id= ptr->id.data;
93         ChannelDriver *driver= ptr->data;
94
95         driver->flag &= ~DRIVER_FLAG_INVALID;
96         
97         // TODO: this really needs an update guard...
98         DAG_scene_sort(scene);
99         DAG_id_flush_update(id, OB_RECALC_OB|OB_RECALC_DATA);
100         
101         WM_main_add_notifier(NC_SCENE|ND_FRAME, scene);
102 }
103
104 static void rna_ChannelDriver_update_expr(Main *bmain, Scene *scene, PointerRNA *ptr)
105 {
106         ChannelDriver *driver= ptr->data;
107         driver->flag |= DRIVER_FLAG_RECOMPILE;
108         rna_ChannelDriver_update_data(bmain, scene, ptr);
109 }
110
111 static void rna_DriverTarget_update_data(Main *bmain, Scene *scene, PointerRNA *ptr)
112 {
113         PointerRNA driverptr;
114         ChannelDriver *driver;
115         FCurve *fcu;
116         AnimData *adt= BKE_animdata_from_id(ptr->id.data);
117
118         /* find the driver this belongs to and update it */
119         for (fcu=adt->drivers.first; fcu; fcu=fcu->next) {
120                 driver= fcu->driver;
121                 
122                 if (driver) {
123                         // FIXME: need to be able to search targets for required one...
124                         //BLI_findindex(&driver->targets, ptr->data) != -1) 
125                         RNA_pointer_create(ptr->id.data, &RNA_Driver, driver, &driverptr);
126                         rna_ChannelDriver_update_data(bmain, scene, &driverptr);
127                         return;
128                 }
129         }
130 }
131
132 static void rna_DriverTarget_update_name(Main *bmain, Scene *scene, PointerRNA *ptr)
133 {
134         ChannelDriver *driver= ptr->data;
135         rna_DriverTarget_update_data(bmain, scene, ptr);
136
137         driver->flag |= DRIVER_FLAG_RENAMEVAR;
138
139 }
140
141 /* ----------- */
142
143 static StructRNA *rna_DriverTarget_id_typef(PointerRNA *ptr)
144 {
145         DriverTarget *dtar= (DriverTarget*)ptr->data;
146         return ID_code_to_RNA_type(dtar->idtype);
147 }
148
149 static int rna_DriverTarget_id_editable(PointerRNA *ptr)
150 {
151         DriverTarget *dtar= (DriverTarget*)ptr->data;
152         return (dtar->idtype)? PROP_EDITABLE : 0;
153 }
154
155 static void rna_DriverTarget_id_type_set(PointerRNA *ptr, int value)
156 {
157         DriverTarget *data= (DriverTarget*)(ptr->data);
158         
159         /* set the driver type, then clear the id-block if the type is invalid */
160         data->idtype= value;
161         if ((data->id) && (GS(data->id->name) != data->idtype))
162                 data->id= NULL;
163 }
164
165 static void rna_DriverTarget_RnaPath_get(PointerRNA *ptr, char *value)
166 {
167         DriverTarget *dtar= (DriverTarget *)ptr->data;
168
169         if (dtar->rna_path)
170                 strcpy(value, dtar->rna_path);
171         else
172                 strcpy(value, "");
173 }
174
175 static int rna_DriverTarget_RnaPath_length(PointerRNA *ptr)
176 {
177         DriverTarget *dtar= (DriverTarget *)ptr->data;
178         
179         if (dtar->rna_path)
180                 return strlen(dtar->rna_path);
181         else
182                 return 0;
183 }
184
185 static void rna_DriverTarget_RnaPath_set(PointerRNA *ptr, const char *value)
186 {
187         DriverTarget *dtar= (DriverTarget *)ptr->data;
188         
189         // XXX in this case we need to be very careful, as this will require some new dependencies to be added!
190         if (dtar->rna_path)
191                 MEM_freeN(dtar->rna_path);
192         
193         if (strlen(value))
194                 dtar->rna_path= BLI_strdup(value);
195         else 
196                 dtar->rna_path= NULL;
197 }
198
199 static void rna_DriverVariable_type_set(PointerRNA *ptr, int value)
200 {
201         DriverVar *dvar= (DriverVar *)ptr->data;
202         
203         /* call the API function for this */
204         driver_change_variable_type(dvar, value);
205 }
206
207 /* ****************************** */
208
209 static void rna_FCurve_RnaPath_get(PointerRNA *ptr, char *value)
210 {
211         FCurve *fcu= (FCurve *)ptr->data;
212
213         if (fcu->rna_path)
214                 strcpy(value, fcu->rna_path);
215         else
216                 strcpy(value, "");
217 }
218
219 static int rna_FCurve_RnaPath_length(PointerRNA *ptr)
220 {
221         FCurve *fcu= (FCurve *)ptr->data;
222         
223         if (fcu->rna_path)
224                 return strlen(fcu->rna_path);
225         else
226                 return 0;
227 }
228
229 static void rna_FCurve_RnaPath_set(PointerRNA *ptr, const char *value)
230 {
231         FCurve *fcu= (FCurve *)ptr->data;
232
233         if (fcu->rna_path)
234                 MEM_freeN(fcu->rna_path);
235         
236         if (strlen(value))
237                 fcu->rna_path= BLI_strdup(value);
238         else 
239                 fcu->rna_path= NULL;
240 }
241
242 DriverVar *rna_Driver_new_variable(ChannelDriver *driver)
243 {
244         /* call the API function for this */
245         return driver_add_new_variable(driver);
246 }
247
248 void rna_Driver_remove_variable(ChannelDriver *driver, DriverVar *dvar)
249 {
250         /* call the API function for this */
251         driver_free_variable(driver, dvar);
252 }
253
254
255 static PointerRNA rna_FCurve_active_modifier_get(PointerRNA *ptr)
256 {
257         FCurve *fcu= (FCurve*)ptr->data;
258         FModifier *fcm= find_active_fmodifier(&fcu->modifiers);
259         return rna_pointer_inherit_refine(ptr, &RNA_FModifier, fcm);
260 }
261
262 static void rna_FCurve_active_modifier_set(PointerRNA *ptr, PointerRNA value)
263 {
264         FCurve *fcu= (FCurve*)ptr->data;
265         set_active_fmodifier(&fcu->modifiers, (FModifier *)value.data);
266 }
267
268 static FModifier *rna_FCurve_modifiers_new(FCurve *fcu, bContext *C, int type)
269 {
270         return add_fmodifier(&fcu->modifiers, type);
271 }
272
273 static int rna_FCurve_modifiers_remove(FCurve *fcu, bContext *C, int index)
274 {
275         return remove_fmodifier_index(&fcu->modifiers, index);
276 }
277
278 static void rna_FModifier_active_set(PointerRNA *ptr, int value)
279 {
280         FModifier *fm= (FModifier*)ptr->data;
281
282         /* don't toggle, always switch on */
283         fm->flag |= FMODIFIER_FLAG_ACTIVE;
284 }
285
286 static void rna_FModifier_active_update(Main *bmain, Scene *scene, PointerRNA *ptr)
287 {
288         FModifier *fm, *fmo= (FModifier*)ptr->data;
289
290         /* clear active state of other FModifiers in this list */
291         for (fm=fmo->prev; fm; fm=fm->prev)
292         {
293                 fm->flag &= ~FMODIFIER_FLAG_ACTIVE;
294         }
295         for (fm=fmo->next; fm; fm=fm->next)
296         {
297                 fm->flag &= ~FMODIFIER_FLAG_ACTIVE;
298         }
299         
300 }
301
302 static int rna_FModifierGenerator_coefficients_get_length(PointerRNA *ptr, int length[RNA_MAX_ARRAY_DIMENSION])
303 {
304         FModifier *fcm= (FModifier*)ptr->data;
305         FMod_Generator *gen= fcm->data;
306
307         if(gen)
308                 length[0]= gen->arraysize;
309         else
310                 length[0]= 100; /* for raw_access, untested */
311
312         return length[0];
313 }
314
315 static void rna_FModifierGenerator_coefficients_get(PointerRNA *ptr, float *values)
316 {
317         FModifier *fcm= (FModifier*)ptr->data;
318         FMod_Generator *gen= fcm->data;
319         memcpy(values, gen->coefficients, gen->arraysize * sizeof(float));
320 }
321
322 static void rna_FModifierGenerator_coefficients_set(PointerRNA *ptr, const float *values)
323 {
324         FModifier *fcm= (FModifier*)ptr->data;
325         FMod_Generator *gen= fcm->data;
326         memcpy(gen->coefficients, values, gen->arraysize * sizeof(float));
327 }
328
329 #else
330
331 static void rna_def_fmodifier_generator(BlenderRNA *brna)
332 {
333         StructRNA *srna;
334         PropertyRNA *prop;
335         
336         static EnumPropertyItem generator_mode_items[] = {
337                 {FCM_GENERATOR_POLYNOMIAL, "POLYNOMIAL", 0, "Expanded Polynomial", ""},
338                 {FCM_GENERATOR_POLYNOMIAL_FACTORISED, "POLYNOMIAL_FACTORISED", 0, "Factorised Polynomial", ""},
339                 {0, NULL, 0, NULL, NULL}};
340         
341         srna= RNA_def_struct(brna, "FModifierGenerator", "FModifier");
342         RNA_def_struct_ui_text(srna, "Generator F-Curve Modifier", "Deterministically generates values for the modified F-Curve.");
343         RNA_def_struct_sdna_from(srna, "FMod_Generator", "data");
344         
345         /* define common props */
346         prop= RNA_def_property(srna, "additive", PROP_BOOLEAN, PROP_NONE);
347         RNA_def_property_boolean_sdna(prop, NULL, "flag", FCM_GENERATOR_ADDITIVE);
348         RNA_def_property_ui_text(prop, "Additive", "Values generated by this modifier are applied on top of the existing values instead of overwriting them.");
349         RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME_EDIT, NULL);
350         
351                 // XXX this has a special validation func
352         prop= RNA_def_property(srna, "mode", PROP_ENUM, PROP_NONE);
353         RNA_def_property_enum_items(prop, generator_mode_items);
354         RNA_def_property_ui_text(prop, "Mode", "Type of generator to use.");
355         RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME_EDIT, NULL);
356         
357         
358         /* order of the polynomial */
359                 // XXX this has a special validation func
360         prop= RNA_def_property(srna, "poly_order", PROP_INT, PROP_NONE);
361         RNA_def_property_ui_text(prop, "Polynomial Order", "The highest power of 'x' for this polynomial. (number of coefficients - 1)");
362         RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME_EDIT, NULL);
363         
364         /* coefficients array */
365         prop= RNA_def_property(srna, "coefficients", PROP_FLOAT, PROP_NONE);
366         RNA_def_property_array(prop, 32);
367         RNA_def_property_flag(prop, PROP_DYNAMIC);
368         RNA_def_property_dynamic_array_funcs(prop, "rna_FModifierGenerator_coefficients_get_length");
369         RNA_def_property_float_funcs(prop, "rna_FModifierGenerator_coefficients_get", "rna_FModifierGenerator_coefficients_set", NULL);
370         RNA_def_property_ui_text(prop, "Coefficients", "Coefficients for 'x' (starting from lowest power of x^0).");
371 }
372
373 /* --------- */
374
375 static void rna_def_fmodifier_function_generator(BlenderRNA *brna)
376 {
377         StructRNA *srna;
378         PropertyRNA *prop;
379         
380         static EnumPropertyItem prop_type_items[] = {
381                 {0, "SIN", 0, "Sine", ""},
382                 {1, "COS", 0, "Cosine", ""},
383                 {2, "TAN", 0, "Tangent", ""},
384                 {3, "SQRT", 0, "Square Root", ""},
385                 {4, "LN", 0, "Natural Logarithm", ""},
386                 {5, "SINC", 0, "Normalised Sine", "sin(x) / x"},
387                 {0, NULL, 0, NULL, NULL}};
388         
389         srna= RNA_def_struct(brna, "FModifierFunctionGenerator", "FModifier");
390         RNA_def_struct_ui_text(srna, "Built-In Function F-Modifier", "Generates values using a Built-In Function.");
391         RNA_def_struct_sdna_from(srna, "FMod_FunctionGenerator", "data");
392         
393         /* coefficients */
394         prop= RNA_def_property(srna, "amplitude", PROP_FLOAT, PROP_NONE);
395         RNA_def_property_ui_text(prop, "Amplitude", "Scale factor determining the maximum/minimum values.");
396         RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME_EDIT, NULL);
397         
398         prop= RNA_def_property(srna, "phase_multiplier", PROP_FLOAT, PROP_NONE);
399         RNA_def_property_ui_text(prop, "Phase Multiplier", "Scale factor determining the 'speed' of the function.");
400         RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME_EDIT, NULL);
401         
402         prop= RNA_def_property(srna, "phase_offset", PROP_FLOAT, PROP_NONE);
403         RNA_def_property_ui_text(prop, "Phase Offset", "Constant factor to offset time by for function.");
404         RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME_EDIT, NULL);
405         
406         prop= RNA_def_property(srna, "value_offset", PROP_FLOAT, PROP_NONE);
407         RNA_def_property_ui_text(prop, "Value Offset", "Constant factor to offset values by.");
408         RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME_EDIT, NULL);
409         
410         /* flags */
411         prop= RNA_def_property(srna, "additive", PROP_BOOLEAN, PROP_NONE);
412         RNA_def_property_boolean_sdna(prop, NULL, "flag", FCM_GENERATOR_ADDITIVE);
413         RNA_def_property_ui_text(prop, "Additive", "Values generated by this modifier are applied on top of the existing values instead of overwriting them.");
414         RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME_EDIT, NULL);
415         
416         prop= RNA_def_property(srna, "function_type", PROP_ENUM, PROP_NONE);
417         RNA_def_property_enum_sdna(prop, NULL, "type");
418         RNA_def_property_enum_items(prop, prop_type_items);
419         RNA_def_property_ui_text(prop, "Type", "Type of built-in function to use.");
420         RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME_EDIT, NULL);
421 }
422
423 /* --------- */
424
425 static void rna_def_fmodifier_envelope_ctrl(BlenderRNA *brna)
426 {
427         StructRNA *srna;
428         PropertyRNA *prop;
429         
430         srna= RNA_def_struct(brna, "FModifierEnvelopeControlPoint", NULL);
431         RNA_def_struct_ui_text(srna, "Envelope Control Point", "Control point for envelope F-Modifier.");
432         RNA_def_struct_sdna(srna, "FCM_EnvelopeData");
433         
434         /* min/max extents 
435          *      - for now, these are allowed to go past each other, so that we can have inverted action
436          *      - technically, the range is limited by the settings in the envelope-modifier data, not here...
437          */
438         prop= RNA_def_property(srna, "minimum", PROP_FLOAT, PROP_NONE);
439         RNA_def_property_float_sdna(prop, NULL, "min");
440         RNA_def_property_ui_text(prop, "Minimum Value", "Lower bound of envelope at this control-point.");
441         RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME_EDIT, NULL);
442         
443         prop= RNA_def_property(srna, "maximum", PROP_FLOAT, PROP_NONE);
444         RNA_def_property_float_sdna(prop, NULL, "max");
445         RNA_def_property_ui_text(prop, "Maximum Value", "Upper bound of envelope at this control-point.");
446         RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME_EDIT, NULL);
447         
448         /* Frame */
449         prop= RNA_def_property(srna, "frame", PROP_FLOAT, PROP_TIME);
450         RNA_def_property_float_sdna(prop, NULL, "time");
451         RNA_def_property_ui_text(prop, "Frame", "Frame this control-point occurs on.");
452         RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME_EDIT, NULL);
453         
454         // TODO:
455         //      - selection flags (not implemented in UI yet though)
456 }
457
458 static void rna_def_fmodifier_envelope(BlenderRNA *brna)
459 {
460         StructRNA *srna;
461         PropertyRNA *prop;
462         
463         srna= RNA_def_struct(brna, "FModifierEnvelope", "FModifier");
464         RNA_def_struct_ui_text(srna, "Envelope F-Modifier", "Scales the values of the modified F-Curve.");
465         RNA_def_struct_sdna_from(srna, "FMod_Envelope", "data");
466         
467         /* Collections */
468         prop= RNA_def_property(srna, "control_points", PROP_COLLECTION, PROP_NONE);
469         RNA_def_property_collection_sdna(prop, NULL, "data", "totvert");
470         RNA_def_property_struct_type(prop, "FModifierEnvelopeControlPoint");
471         RNA_def_property_ui_text(prop, "Control Points", "Control points defining the shape of the envelope.");
472         
473         /* Range Settings */
474         prop= RNA_def_property(srna, "reference_value", PROP_FLOAT, PROP_NONE);
475         RNA_def_property_float_sdna(prop, NULL, "midval");
476         RNA_def_property_ui_text(prop, "Reference Value", "Value that envelope's influence is centered around / based on.");
477         RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME_EDIT, NULL);
478         
479         prop= RNA_def_property(srna, "default_minimum", PROP_FLOAT, PROP_NONE);
480         RNA_def_property_float_sdna(prop, NULL, "min");
481         RNA_def_property_ui_text(prop, "Default Minimum", "Lower distance from Reference Value for 1:1 default influence.");
482         RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME_EDIT, NULL);
483         
484         prop= RNA_def_property(srna, "default_maximum", PROP_FLOAT, PROP_NONE);
485         RNA_def_property_float_sdna(prop, NULL, "max");
486         RNA_def_property_ui_text(prop, "Default Maximum", "Upper distance from Reference Value for 1:1 default influence.");
487         RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME_EDIT, NULL);
488 }
489
490 /* --------- */
491
492 static void rna_def_fmodifier_cycles(BlenderRNA *brna)
493 {
494         StructRNA *srna;
495         PropertyRNA *prop;
496         
497         static EnumPropertyItem prop_type_items[] = {
498                 {FCM_EXTRAPOLATE_NONE, "NONE", 0, "No Cycles", "Don't do anything."},
499                 {FCM_EXTRAPOLATE_CYCLIC, "REPEAT", 0, "Repeat Motion", "Repeat keyframe range as-is."},
500                 {FCM_EXTRAPOLATE_CYCLIC_OFFSET, "REPEAT_OFFSET", 0, "Repeat with Offset", "Repeat keyframe range, but with offset based on gradient between values"},
501                 {FCM_EXTRAPOLATE_MIRROR, "MIRROR", 0, "Repeat Mirrored", "Alternate between forward and reverse playback of keyframe range"},
502                 {0, NULL, 0, NULL, NULL}};
503         
504         srna= RNA_def_struct(brna, "FModifierCycles", "FModifier");
505         RNA_def_struct_ui_text(srna, "Cycles F-Modifier", "Repeats the values of the modified F-Curve.");
506         RNA_def_struct_sdna_from(srna, "FMod_Cycles", "data");
507         
508         /* before */
509         prop= RNA_def_property(srna, "before_mode", PROP_ENUM, PROP_NONE);
510         RNA_def_property_enum_items(prop, prop_type_items);
511         RNA_def_property_ui_text(prop, "Before Mode", "Cycling mode to use before first keyframe.");
512         RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME_EDIT, NULL);
513         
514         prop= RNA_def_property(srna, "before_cycles", PROP_FLOAT, PROP_NONE);
515         RNA_def_property_ui_text(prop, "Before Cycles", "Maximum number of cycles to allow before first keyframe. (0 = infinite)");
516         RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME_EDIT, NULL);
517         
518         /* after */
519         prop= RNA_def_property(srna, "after_mode", PROP_ENUM, PROP_NONE);
520         RNA_def_property_enum_items(prop, prop_type_items);
521         RNA_def_property_ui_text(prop, "After Mode", "Cycling mode to use after last keyframe.");
522         RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME_EDIT, NULL);
523         
524         prop= RNA_def_property(srna, "after_cycles", PROP_FLOAT, PROP_NONE);
525         RNA_def_property_ui_text(prop, "After Cycles", "Maximum number of cycles to allow after last keyframe. (0 = infinite)");
526         RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME_EDIT, NULL);
527 }
528
529 /* --------- */
530
531 static void rna_def_fmodifier_python(BlenderRNA *brna)
532 {
533         StructRNA *srna;
534         //PropertyRNA *prop;
535         
536         srna= RNA_def_struct(brna, "FModifierPython", "FModifier");
537         RNA_def_struct_ui_text(srna, "Python F-Modifier", "Performs user-defined operation on the modified F-Curve.");
538         RNA_def_struct_sdna_from(srna, "FMod_Python", "data");
539 }
540
541 /* --------- */
542
543 static void rna_def_fmodifier_limits(BlenderRNA *brna)
544 {
545         StructRNA *srna;
546         PropertyRNA *prop;
547         
548         srna= RNA_def_struct(brna, "FModifierLimits", "FModifier");
549         RNA_def_struct_ui_text(srna, "Limits F-Modifier", "Limits the time/value ranges of the modified F-Curve.");
550         RNA_def_struct_sdna_from(srna, "FMod_Limits", "data");
551         
552         prop= RNA_def_property(srna, "use_minimum_x", PROP_BOOLEAN, PROP_NONE);
553         RNA_def_property_boolean_sdna(prop, NULL, "flag", FCM_LIMIT_XMIN);
554         RNA_def_property_ui_text(prop, "Minimum X", "Use the minimum X value.");
555         RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME_EDIT, NULL);
556         
557         prop= RNA_def_property(srna, "use_minimum_y", PROP_BOOLEAN, PROP_NONE);
558         RNA_def_property_boolean_sdna(prop, NULL, "flag", FCM_LIMIT_YMIN);
559         RNA_def_property_ui_text(prop, "Minimum Y", "Use the minimum Y value.");
560         RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME_EDIT, NULL);
561         
562         prop= RNA_def_property(srna, "use_maximum_x", PROP_BOOLEAN, PROP_NONE);
563         RNA_def_property_boolean_sdna(prop, NULL, "flag", FCM_LIMIT_XMAX);
564         RNA_def_property_ui_text(prop, "Maximum X", "Use the maximum X value.");
565         RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME_EDIT, NULL);
566         
567         prop= RNA_def_property(srna, "use_maximum_y", PROP_BOOLEAN, PROP_NONE);
568         RNA_def_property_boolean_sdna(prop, NULL, "flag", FCM_LIMIT_YMAX);
569         RNA_def_property_ui_text(prop, "Maximum Y", "Use the maximum Y value.");
570         RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME_EDIT, NULL);
571         
572         prop= RNA_def_property(srna, "minimum_x", PROP_FLOAT, PROP_NONE);
573         RNA_def_property_float_sdna(prop, NULL, "rect.xmin");
574         RNA_def_property_ui_text(prop, "Minimum X", "Lowest X value to allow.");
575         RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME_EDIT, NULL);
576         
577         prop= RNA_def_property(srna, "minimum_y", PROP_FLOAT, PROP_NONE);
578         RNA_def_property_float_sdna(prop, NULL, "rect.ymin");
579         RNA_def_property_ui_text(prop, "Minimum Y", "Lowest Y value to allow.");
580         RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME_EDIT, NULL);
581         
582         prop= RNA_def_property(srna, "maximum_x", PROP_FLOAT, PROP_NONE);
583         RNA_def_property_float_sdna(prop, NULL, "rect.xmax");
584         RNA_def_property_ui_text(prop, "Maximum X", "Highest X value to allow.");
585         RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME_EDIT, NULL);
586         
587         prop= RNA_def_property(srna, "maximum_y", PROP_FLOAT, PROP_NONE);
588         RNA_def_property_float_sdna(prop, NULL, "rect.ymax");
589         RNA_def_property_ui_text(prop, "Maximum Y", "Highest Y value to allow.");
590         RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME_EDIT, NULL);
591 }
592
593 /* --------- */
594
595 static void rna_def_fmodifier_noise(BlenderRNA *brna)
596 {
597         StructRNA *srna;
598         PropertyRNA *prop;
599         
600         static EnumPropertyItem prop_modification_items[] = {
601                 {FCM_NOISE_MODIF_REPLACE, "REPLACE", 0, "Replace", ""},
602                 {FCM_NOISE_MODIF_ADD, "ADD", 0, "Add", ""},
603                 {FCM_NOISE_MODIF_SUBTRACT, "SUBTRACT", 0, "Subtract", ""},
604                 {FCM_NOISE_MODIF_MULTIPLY, "MULTIPLY", 0, "Multiply", ""},
605                 {0, NULL, 0, NULL, NULL}};
606         
607         srna= RNA_def_struct(brna, "FModifierNoise", "FModifier");
608         RNA_def_struct_ui_text(srna, "Noise F-Modifier", "Gives randomness to the modified F-Curve.");
609         RNA_def_struct_sdna_from(srna, "FMod_Noise", "data");
610         
611         prop= RNA_def_property(srna, "modification", PROP_ENUM, PROP_NONE);
612         RNA_def_property_enum_items(prop, prop_modification_items);
613         RNA_def_property_ui_text(prop, "Modification", "Method of modifying the existing F-Curve.");
614         RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME_EDIT, NULL);
615         
616         prop= RNA_def_property(srna, "size", PROP_FLOAT, PROP_NONE);
617         RNA_def_property_float_sdna(prop, NULL, "size");
618         RNA_def_property_ui_text(prop, "Size", "Scaling (in time) of the noise");
619         RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME_EDIT, NULL);
620         
621         prop= RNA_def_property(srna, "strength", PROP_FLOAT, PROP_NONE);
622         RNA_def_property_float_sdna(prop, NULL, "strength");
623         RNA_def_property_ui_text(prop, "Strength", "Amplitude of the noise - the amount that it modifies the underlying curve");
624         RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME_EDIT, NULL);
625         
626         prop= RNA_def_property(srna, "phase", PROP_FLOAT, PROP_NONE);
627         RNA_def_property_float_sdna(prop, NULL, "phase");
628         RNA_def_property_ui_text(prop, "Phase", "A random seed for the noise effect");
629         RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME_EDIT, NULL);
630         
631         prop= RNA_def_property(srna, "depth", PROP_INT, PROP_NONE);
632         RNA_def_property_int_sdna(prop, NULL, "depth");
633         RNA_def_property_ui_text(prop, "Depth", "Amount of fine level detail present in the noise");
634         RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME_EDIT, NULL);
635
636 }
637
638
639 /* --------- */
640
641 static void rna_def_fmodifier(BlenderRNA *brna)
642 {
643         StructRNA *srna;
644         PropertyRNA *prop;
645         
646         /* base struct definition */
647         srna= RNA_def_struct(brna, "FModifier", NULL);
648         RNA_def_struct_refine_func(srna, "rna_FModifierType_refine");
649         RNA_def_struct_ui_text(srna, "F-Modifier", "Modifier for values of F-Curve.");
650         
651 #if 0 // XXX not used yet
652         /* name */
653         prop= RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
654         RNA_def_struct_name_property(srna, prop);
655         RNA_def_property_ui_text(prop, "Name", "Short description of F-Curve Modifier.");
656 #endif // XXX not used yet
657         
658         /* type */
659         prop= RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
660         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
661         RNA_def_property_enum_items(prop, fmodifier_type_items);
662         RNA_def_property_ui_text(prop, "Type", "F-Curve Modifier Type");
663         
664         /* settings */
665         prop= RNA_def_property(srna, "expanded", PROP_BOOLEAN, PROP_NONE);
666         RNA_def_property_boolean_sdna(prop, NULL, "flag", FMODIFIER_FLAG_EXPANDED);
667         RNA_def_property_ui_text(prop, "Expanded", "F-Curve Modifier's panel is expanded in UI.");
668         RNA_def_property_ui_icon(prop, ICON_TRIA_RIGHT, 1);
669         
670         prop= RNA_def_property(srna, "muted", PROP_BOOLEAN, PROP_NONE);
671         RNA_def_property_boolean_sdna(prop, NULL, "flag", FMODIFIER_FLAG_MUTED);
672         RNA_def_property_ui_text(prop, "Muted", "F-Curve Modifier will not be evaluated.");
673         RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME_PROP, NULL);
674         RNA_def_property_ui_icon(prop, ICON_MUTE_IPO_OFF, 1);
675         
676                 // XXX this is really an internal flag, but it may be useful for some tools to be able to access this...
677         prop= RNA_def_property(srna, "disabled", PROP_BOOLEAN, PROP_NONE);
678         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
679         RNA_def_property_boolean_sdna(prop, NULL, "flag", FMODIFIER_FLAG_DISABLED);
680         RNA_def_property_ui_text(prop, "Disabled", "F-Curve Modifier has invalid settings and will not be evaluated.");
681         RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME_PROP, NULL);
682         
683                 // TODO: setting this to true must ensure that all others in stack are turned off too...
684         prop= RNA_def_property(srna, "active", PROP_BOOLEAN, PROP_NONE);
685         RNA_def_property_boolean_sdna(prop, NULL, "flag", FMODIFIER_FLAG_ACTIVE);
686         RNA_def_property_ui_text(prop, "Active", "F-Curve Modifier is the one being edited ");
687         RNA_def_property_boolean_funcs(prop, NULL, "rna_FModifier_active_set");
688         RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME_PROP, "rna_FModifier_active_update");
689         RNA_def_property_ui_icon(prop, ICON_RADIOBUT_OFF, 1);
690 }       
691
692 /* *********************** */
693
694 static void rna_def_drivertarget(BlenderRNA *brna)
695 {
696         StructRNA *srna;
697         PropertyRNA *prop;
698         
699         static EnumPropertyItem prop_trans_chan_items[] = {
700                 {DTAR_TRANSCHAN_LOCX, "LOC_X", 0, "X Location", ""},
701                 {DTAR_TRANSCHAN_LOCY, "LOC_Y", 0, "Y Location", ""},
702                 {DTAR_TRANSCHAN_LOCZ, "LOC_Z", 0, "Z Location", ""},
703                 {DTAR_TRANSCHAN_ROTX, "ROT_X", 0, "X Rotation", ""},
704                 {DTAR_TRANSCHAN_ROTY, "ROT_Y", 0, "Y Rotation", ""},
705                 {DTAR_TRANSCHAN_ROTZ, "ROT_Z", 0, "Z Rotation", ""},
706                 {DTAR_TRANSCHAN_SCALEX, "SCALE_X", 0, "X Scale", ""},
707                 {DTAR_TRANSCHAN_SCALEY, "SCALE_Y", 0, "Y Scale", ""},
708                 {DTAR_TRANSCHAN_SCALEZ, "SCALE_Z", 0, "Z Scale", ""},
709                 {0, NULL, 0, NULL, NULL}};
710         
711         srna= RNA_def_struct(brna, "DriverTarget", NULL);
712         RNA_def_struct_ui_text(srna, "Driver Target", "Source of input values for driver variables.");
713         
714         /* Target Properties - ID-block to Drive */
715         prop= RNA_def_property(srna, "id", PROP_POINTER, PROP_NONE);
716         RNA_def_property_struct_type(prop, "ID");
717         RNA_def_property_flag(prop, PROP_EDITABLE);
718         RNA_def_property_editable_func(prop, "rna_DriverTarget_id_editable");
719         RNA_def_property_pointer_funcs(prop, NULL, NULL, "rna_DriverTarget_id_typef");
720         RNA_def_property_ui_text(prop, "ID", "ID-block that the specific property used can be found from (id_type property must be set first)");
721         RNA_def_property_update(prop, 0, "rna_DriverTarget_update_data");
722         
723         prop= RNA_def_property(srna, "id_type", PROP_ENUM, PROP_NONE);
724         RNA_def_property_enum_sdna(prop, NULL, "idtype");
725         RNA_def_property_enum_items(prop, id_type_items);
726         RNA_def_property_enum_default(prop, ID_OB);
727         // XXX need to add an 'editable func' for this, in the case where certain flags are set already...
728         RNA_def_property_enum_funcs(prop, NULL, "rna_DriverTarget_id_type_set", NULL);
729         RNA_def_property_ui_text(prop, "ID Type", "Type of ID-block that can be used.");
730         RNA_def_property_update(prop, 0, "rna_DriverTarget_update_data");
731         
732         /* Target Properties - Property to Drive */
733         prop= RNA_def_property(srna, "data_path", PROP_STRING, PROP_NONE);
734         RNA_def_property_string_funcs(prop, "rna_DriverTarget_RnaPath_get", "rna_DriverTarget_RnaPath_length", "rna_DriverTarget_RnaPath_set");
735         RNA_def_property_ui_text(prop, "Data Path", "RNA Path (from ID-block) to property used.");
736         RNA_def_property_update(prop, 0, "rna_DriverTarget_update_data");
737         
738         prop= RNA_def_property(srna, "bone_target", PROP_STRING, PROP_NONE);
739         RNA_def_property_string_sdna(prop, NULL, "pchan_name");
740         RNA_def_property_ui_text(prop, "Bone Name", "Name of PoseBone to use as target.");
741         RNA_def_property_update(prop, 0, "rna_DriverTarget_update_data");
742         
743         prop= RNA_def_property(srna, "transform_type", PROP_ENUM, PROP_NONE);
744         RNA_def_property_enum_sdna(prop, NULL, "transChan");
745         RNA_def_property_enum_items(prop, prop_trans_chan_items);
746         RNA_def_property_ui_text(prop, "Type", "Driver variable type.");
747         RNA_def_property_update(prop, 0, "rna_DriverTarget_update_data");
748         
749         prop= RNA_def_property(srna, "use_local_space_transforms", PROP_BOOLEAN, PROP_NONE);
750         RNA_def_property_boolean_sdna(prop, NULL, "flag", DTAR_FLAG_LOCALSPACE);
751         RNA_def_property_ui_text(prop, "Local Space", "Use transforms in Local Space (as opposed to the worldspace default).");
752         RNA_def_property_update(prop, 0, "rna_DriverTarget_update_data");
753 }
754
755 static void rna_def_drivervar(BlenderRNA *brna)
756 {
757         StructRNA *srna;
758         PropertyRNA *prop;
759         
760         static EnumPropertyItem prop_type_items[] = {
761                 {DVAR_TYPE_SINGLE_PROP, "SINGLE_PROP", 0, "Single Property", "Use the value from some RNA property (Default)"},
762                 {DVAR_TYPE_TRANSFORM_CHAN, "TRANSFORMS", 0, "Transform Channel", "Final transformation value of object or bone"},
763                 {DVAR_TYPE_ROT_DIFF, "ROTATION_DIFF", 0, "Rotational Difference", "Use the angle between two bones"},
764                 {DVAR_TYPE_LOC_DIFF, "LOC_DIFF", 0, "Distance", "Distance between two bones or objects"},
765                 {0, NULL, 0, NULL, NULL}};
766                 
767         
768         srna= RNA_def_struct(brna, "DriverVariable", NULL);
769         RNA_def_struct_sdna(srna, "DriverVar");
770         RNA_def_struct_ui_text(srna, "Driver Variable", "Variable from some source/target for driver relationship.");
771         
772         /* Variable Name */
773         prop= RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
774         RNA_def_struct_name_property(srna, prop);
775         RNA_def_property_ui_text(prop, "Name", "Name to use in scripted expressions/functions. (No spaces or dots are allowed. Also, must not start with a symbol or digit)");
776         RNA_def_property_update(prop, 0, "rna_DriverTarget_update_name"); // XXX
777         
778         /* Enums */
779         prop= RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
780         RNA_def_property_enum_items(prop, prop_type_items);
781         RNA_def_property_enum_funcs(prop, NULL, "rna_DriverVariable_type_set", NULL);
782         RNA_def_property_ui_text(prop, "Type", "Driver variable type.");
783         RNA_def_property_update(prop, 0, "rna_ChannelDriver_update_data"); // XXX
784         
785         /* Targets */
786         // TODO: for nicer api, only expose the relevant props via subclassing, instead of exposing the collection of targets
787         prop= RNA_def_property(srna, "targets", PROP_COLLECTION, PROP_NONE);
788         RNA_def_property_collection_sdna(prop, NULL, "targets", "num_targets");
789         RNA_def_property_struct_type(prop, "DriverTarget");
790         RNA_def_property_ui_text(prop, "Targets", "Sources of input data for evaluating this variable.");
791 }
792
793
794 /* channeldriver.variables.* */
795 static void rna_def_channeldriver_variables(BlenderRNA *brna, PropertyRNA *cprop)
796 {
797         StructRNA *srna;
798 //      PropertyRNA *prop;
799         
800         FunctionRNA *func;
801         PropertyRNA *parm;
802         
803         RNA_def_property_srna(cprop, "ChannelDriverVariables");
804         srna= RNA_def_struct(brna, "ChannelDriverVariables", NULL);
805         RNA_def_struct_sdna(srna, "ChannelDriver");
806         RNA_def_struct_ui_text(srna, "ChannelDriver Variables", "Collection of channel driver Variables.");
807         
808         
809         /* add variable */
810         func= RNA_def_function(srna, "new", "rna_Driver_new_variable");
811         RNA_def_function_ui_description(func, "Add a new variable for the driver.");
812                 /* return type */
813         parm= RNA_def_pointer(func, "var", "DriverVariable", "", "Newly created Driver Variable.");
814                 RNA_def_function_return(func, parm);
815
816         /* remove variable */
817         func= RNA_def_function(srna, "remove", "rna_Driver_remove_variable");
818                 RNA_def_function_ui_description(func, "Remove an existing variable from the driver.");
819                 /* target to remove */
820         parm= RNA_def_pointer(func, "var", "DriverVariable", "", "Variable to remove from the driver.");
821                 RNA_def_property_flag(parm, PROP_REQUIRED);
822 }
823
824 static void rna_def_channeldriver(BlenderRNA *brna)
825 {
826         StructRNA *srna;
827         PropertyRNA *prop;
828         
829         static EnumPropertyItem prop_type_items[] = {
830                 {DRIVER_TYPE_AVERAGE, "AVERAGE", 0, "Averaged Value", ""},
831                 {DRIVER_TYPE_SUM, "SUM", 0, "Sum Values", ""},
832                 {DRIVER_TYPE_PYTHON, "SCRIPTED", 0, "Scripted Expression", ""},
833                 {DRIVER_TYPE_MIN, "MIN", 0, "Minimum Value", ""},
834                 {DRIVER_TYPE_MAX, "MAX", 0, "Maximum Value", ""},
835                 {0, NULL, 0, NULL, NULL}};
836
837         srna= RNA_def_struct(brna, "Driver", NULL);
838         RNA_def_struct_sdna(srna, "ChannelDriver");
839         RNA_def_struct_ui_text(srna, "Driver", "Driver for the value of a setting based on an external value.");
840
841         /* Enums */
842         prop= RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
843         RNA_def_property_enum_items(prop, prop_type_items);
844         RNA_def_property_ui_text(prop, "Type", "Driver type.");
845         RNA_def_property_update(prop, 0, "rna_ChannelDriver_update_data");
846
847         /* String values */
848         prop= RNA_def_property(srna, "expression", PROP_STRING, PROP_NONE);
849         RNA_def_property_ui_text(prop, "Expression", "Expression to use for Scripted Expression.");
850         RNA_def_property_update(prop, 0, "rna_ChannelDriver_update_expr");
851
852         /* Collections */
853         prop= RNA_def_property(srna, "variables", PROP_COLLECTION, PROP_NONE);
854         RNA_def_property_collection_sdna(prop, NULL, "variables", NULL);
855         RNA_def_property_struct_type(prop, "DriverVariable");
856         RNA_def_property_ui_text(prop, "Variables", "Properties acting as inputs for this driver.");
857         rna_def_channeldriver_variables(brna, prop);
858         
859         /* Settings */
860         prop= RNA_def_property(srna, "show_debug_info", PROP_BOOLEAN, PROP_NONE);
861         RNA_def_property_boolean_sdna(prop, NULL, "flag", DRIVER_FLAG_SHOWDEBUG);
862         RNA_def_property_ui_text(prop, "Show Debug Info", "Show intermediate values for the driver calculations to allow debugging of drivers.");
863         
864         /* Functions */
865         RNA_api_drivers(srna);
866 }
867
868 /* *********************** */
869
870 static void rna_def_fpoint(BlenderRNA *brna)
871 {
872         StructRNA *srna;
873         PropertyRNA *prop;
874         
875         srna= RNA_def_struct(brna, "FCurveSample", NULL);
876         RNA_def_struct_sdna(srna, "FPoint");
877         RNA_def_struct_ui_text(srna, "F-Curve Sample", "Sample point for F-Curve.");
878         
879         /* Boolean values */
880         prop= RNA_def_property(srna, "selected", PROP_BOOLEAN, PROP_NONE);
881         RNA_def_property_boolean_sdna(prop, NULL, "flag", 1);
882         RNA_def_property_ui_text(prop, "Selected", "Selection status");
883         
884         /* Vector value */
885         prop= RNA_def_property(srna, "point", PROP_FLOAT, PROP_XYZ);
886         RNA_def_property_array(prop, 2);
887         RNA_def_property_float_sdna(prop, NULL, "vec");
888         RNA_def_property_ui_text(prop, "Point", "Point coordinates");
889 }
890
891 static void rna_def_fcurve_modifiers(BlenderRNA *brna, PropertyRNA *cprop)
892 {
893         /* add modifiers */
894         StructRNA *srna;
895         PropertyRNA *prop;
896
897         FunctionRNA *func;
898         PropertyRNA *parm;
899
900         RNA_def_property_srna(cprop, "FCurveModifiers");
901         srna= RNA_def_struct(brna, "FCurveModifiers", NULL);
902         RNA_def_struct_sdna(srna, "FCurve");
903         RNA_def_struct_ui_text(srna, "F-Curve Modifiers", "Collection of F-Curve Modifiers.");
904
905
906         /* Collection active property */
907         prop= RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
908         RNA_def_property_struct_type(prop, "FModifier");
909         RNA_def_property_pointer_funcs(prop, "rna_FCurve_active_modifier_get", "rna_FCurve_active_modifier_set", NULL);
910         RNA_def_property_flag(prop, PROP_EDITABLE);
911         RNA_def_property_ui_text(prop, "Active F-Curve Modifier", "Active F-Curve Modifier.");
912
913         /* Constraint collection */
914         func= RNA_def_function(srna, "new", "rna_FCurve_modifiers_new");
915         RNA_def_function_flag(func, FUNC_USE_CONTEXT);
916         RNA_def_function_ui_description(func, "Add a constraint to this object");
917         /* return type */
918         parm= RNA_def_pointer(func, "fmodifier", "FModifier", "", "New fmodifier.");
919         RNA_def_function_return(func, parm);
920         /* object to add */
921         parm= RNA_def_enum(func, "type", fmodifier_type_items, 1, "", "Constraint type to add.");
922         RNA_def_property_flag(parm, PROP_REQUIRED);
923
924         func= RNA_def_function(srna, "remove", "rna_FCurve_modifiers_remove");
925         RNA_def_function_flag(func, FUNC_USE_CONTEXT);
926         RNA_def_function_ui_description(func, "Remove a modifier from this fcurve.");
927         /* return type */
928         parm= RNA_def_boolean(func, "success", 0, "Success", "Removed the constraint successfully.");
929         RNA_def_function_return(func, parm);
930         /* object to add */
931         parm= RNA_def_int(func, "index", 0, 0, INT_MAX, "Index", "", 0, INT_MAX);
932         RNA_def_property_flag(parm, PROP_REQUIRED);
933 }
934
935 static void rna_def_fcurve(BlenderRNA *brna)
936 {
937         StructRNA *srna;
938         PropertyRNA *prop;
939         
940         static EnumPropertyItem prop_mode_extend_items[] = {
941                 {FCURVE_EXTRAPOLATE_CONSTANT, "CONSTANT", 0, "Constant", ""},
942                 {FCURVE_EXTRAPOLATE_LINEAR, "LINEAR", 0, "Linear", ""},
943                 {0, NULL, 0, NULL, NULL}};
944         static EnumPropertyItem prop_mode_color_items[] = {
945                 {FCURVE_COLOR_AUTO_RAINBOW, "AUTO_RAINBOW", 0, "Auto Rainbow", ""},
946                 {FCURVE_COLOR_AUTO_RGB, "AUTO_RGB", 0, "Auto XYZ to RGB", ""},
947                 {FCURVE_COLOR_CUSTOM, "CUSTOM", 0, "User Defined", ""},
948                 {0, NULL, 0, NULL, NULL}};
949
950         srna= RNA_def_struct(brna, "FCurve", NULL);
951         RNA_def_struct_ui_text(srna, "F-Curve", "F-Curve defining values of a period of time.");
952         RNA_def_struct_ui_icon(srna, ICON_ANIM_DATA);
953
954         /* Enums */
955         prop= RNA_def_property(srna, "extrapolation", PROP_ENUM, PROP_NONE);
956         RNA_def_property_enum_sdna(prop, NULL, "extend");
957         RNA_def_property_enum_items(prop, prop_mode_extend_items);
958         RNA_def_property_ui_text(prop, "Extrapolation", "");
959         RNA_def_property_update(prop, NC_ANIMATION, NULL);      // XXX need an update callback for this so that animation gets evaluated
960
961         /* Pointers */
962         prop= RNA_def_property(srna, "driver", PROP_POINTER, PROP_NONE);
963         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
964         RNA_def_property_ui_text(prop, "Driver", "Channel Driver (only set for Driver F-Curves)");
965         
966         prop= RNA_def_property(srna, "group", PROP_POINTER, PROP_NONE);
967         RNA_def_property_pointer_sdna(prop, NULL, "grp");
968         RNA_def_property_clear_flag(prop, PROP_EDITABLE); // XXX this is not editable for now, since editing this will easily break the visible hierarchy
969         RNA_def_property_ui_text(prop, "Group", "Action Group that this F-Curve belongs to.");
970         
971         /* Path + Array Index */
972         prop= RNA_def_property(srna, "data_path", PROP_STRING, PROP_NONE);
973         RNA_def_property_string_funcs(prop, "rna_FCurve_RnaPath_get", "rna_FCurve_RnaPath_length", "rna_FCurve_RnaPath_set");
974         RNA_def_property_ui_text(prop, "Data Path", "RNA Path to property affected by F-Curve.");
975         RNA_def_property_update(prop, NC_ANIMATION, NULL);      // XXX need an update callback for this to that animation gets evaluated
976         
977         prop= RNA_def_property(srna, "array_index", PROP_INT, PROP_NONE);
978         RNA_def_property_ui_text(prop, "RNA Array Index", "Index to the specific property affected by F-Curve if applicable.");
979         RNA_def_property_update(prop, NC_ANIMATION, NULL);      // XXX need an update callback for this so that animation gets evaluated
980         
981         /* Color */
982         prop= RNA_def_property(srna, "color_mode", PROP_ENUM, PROP_NONE);
983         RNA_def_property_enum_items(prop, prop_mode_color_items);
984         RNA_def_property_ui_text(prop, "Color Mode", "Method used to determine color of F-Curve in Graph Editor.");
985         RNA_def_property_update(prop, NC_ANIMATION, NULL);      
986         
987         prop= RNA_def_property(srna, "color", PROP_FLOAT, PROP_COLOR);
988         RNA_def_property_array(prop, 3);
989         RNA_def_property_ui_text(prop, "Color", "Color of the F-Curve in the Graph Editor.");
990         RNA_def_property_update(prop, NC_ANIMATION, NULL);      
991         
992         /* Collections */
993         prop= RNA_def_property(srna, "sampled_points", PROP_COLLECTION, PROP_NONE);
994         RNA_def_property_collection_sdna(prop, NULL, "fpt", "totvert");
995         RNA_def_property_struct_type(prop, "FCurveSample");
996         RNA_def_property_ui_text(prop, "Sampled Points", "Sampled animation data");
997
998         prop= RNA_def_property(srna, "keyframe_points", PROP_COLLECTION, PROP_NONE);
999         RNA_def_property_collection_sdna(prop, NULL, "bezt", "totvert");
1000         RNA_def_property_struct_type(prop, "BezierSplinePoint");
1001         RNA_def_property_ui_text(prop, "Keyframes", "User-editable keyframes");
1002         
1003         prop= RNA_def_property(srna, "modifiers", PROP_COLLECTION, PROP_NONE);
1004         RNA_def_property_struct_type(prop, "FModifier");
1005         RNA_def_property_ui_text(prop, "Modifiers", "Modifiers affecting the shape of the F-Curve.");
1006
1007         rna_def_fcurve_modifiers(brna, prop);
1008 }
1009
1010 /* *********************** */
1011
1012 void RNA_def_fcurve(BlenderRNA *brna)
1013 {
1014         rna_def_fcurve(brna);
1015         rna_def_fpoint(brna);
1016         
1017         rna_def_drivertarget(brna);
1018         rna_def_drivervar(brna);
1019         rna_def_channeldriver(brna);
1020         
1021         rna_def_fmodifier(brna);
1022         
1023         rna_def_fmodifier_generator(brna);
1024         rna_def_fmodifier_function_generator(brna);
1025         rna_def_fmodifier_envelope(brna);
1026                 rna_def_fmodifier_envelope_ctrl(brna);
1027         rna_def_fmodifier_cycles(brna);
1028         rna_def_fmodifier_python(brna);
1029         rna_def_fmodifier_limits(brna);
1030         rna_def_fmodifier_noise(brna);
1031 }
1032
1033
1034 #endif