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