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