Sculpt:
[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 *fm= (FModifier*)ptr->data;
282         FMod_Generator *gen= fm->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 *fm= (FModifier*)ptr->data;
295         FMod_Generator *gen= fm->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 *fm= (FModifier*)ptr->data;
302         FMod_Generator *gen= fm->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
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         /* coefficients array */
350                 // FIXME: this is quite difficult to try to wrap
351         //prop= RNA_def_property(srna, "coefficients", PROP_COLLECTION, PROP_NONE);
352         //RNA_def_property_collection_funcs(prop, "rna_FModifierGenerator_coefficients_begin", "rna_FModifierGenerator_coefficients_next", "rna_FModifierGenerator_coefficients_end", "rna_iterator_array_get", "rna_FModifierGenerator_coefficients_length", 0, 0, 0, 0);
353         //RNA_def_property_ui_text(prop, "Coefficients", "Coefficients for 'x' (starting from lowest power of x^0).");
354 }
355
356 /* --------- */
357
358 static void rna_def_fmodifier_function_generator(BlenderRNA *brna)
359 {
360         StructRNA *srna;
361         PropertyRNA *prop;
362         
363         static EnumPropertyItem prop_type_items[] = {
364                 {0, "SIN", 0, "Sine", ""},
365                 {1, "COS", 0, "Cosine", ""},
366                 {2, "TAN", 0, "Tangent", ""},
367                 {3, "SQRT", 0, "Square Root", ""},
368                 {4, "LN", 0, "Natural Logarithm", ""},
369                 {5, "SINC", 0, "Normalised Sine", "sin(x) / x"},
370                 {0, NULL, 0, NULL, NULL}};
371         
372         srna= RNA_def_struct(brna, "FModifierFunctionGenerator", "FModifier");
373         RNA_def_struct_ui_text(srna, "Built-In Function F-Modifier", "Generates values using a Built-In Function.");
374         RNA_def_struct_sdna_from(srna, "FMod_FunctionGenerator", "data");
375         
376         /* coefficients */
377         prop= RNA_def_property(srna, "amplitude", PROP_FLOAT, PROP_NONE);
378         RNA_def_property_ui_text(prop, "Amplitude", "Scale factor determining the maximum/minimum values.");
379         RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME_EDIT, NULL);
380         
381         prop= RNA_def_property(srna, "phase_multiplier", PROP_FLOAT, PROP_NONE);
382         RNA_def_property_ui_text(prop, "Phase Multiplier", "Scale factor determining the 'speed' of the function.");
383         RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME_EDIT, NULL);
384         
385         prop= RNA_def_property(srna, "phase_offset", PROP_FLOAT, PROP_NONE);
386         RNA_def_property_ui_text(prop, "Phase Offset", "Constant factor to offset time by for function.");
387         RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME_EDIT, NULL);
388         
389         prop= RNA_def_property(srna, "value_offset", PROP_FLOAT, PROP_NONE);
390         RNA_def_property_ui_text(prop, "Value Offset", "Constant factor to offset values by.");
391         RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME_EDIT, NULL);
392         
393         /* flags */
394         prop= RNA_def_property(srna, "additive", PROP_BOOLEAN, PROP_NONE);
395         RNA_def_property_boolean_sdna(prop, NULL, "flag", FCM_GENERATOR_ADDITIVE);
396         RNA_def_property_ui_text(prop, "Additive", "Values generated by this modifier are applied on top of the existing values instead of overwriting them.");
397         RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME_EDIT, NULL);
398         
399         prop= RNA_def_property(srna, "function_type", PROP_ENUM, PROP_NONE);
400         RNA_def_property_enum_sdna(prop, NULL, "type");
401         RNA_def_property_enum_items(prop, prop_type_items);
402         RNA_def_property_ui_text(prop, "Type", "Type of built-in function to use.");
403         RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME_EDIT, NULL);
404 }
405
406 /* --------- */
407
408 static void rna_def_fmodifier_envelope_ctrl(BlenderRNA *brna)
409 {
410         StructRNA *srna;
411         PropertyRNA *prop;
412         
413         srna= RNA_def_struct(brna, "FModifierEnvelopeControlPoint", NULL);
414         RNA_def_struct_ui_text(srna, "Envelope Control Point", "Control point for envelope F-Modifier.");
415         RNA_def_struct_sdna(srna, "FCM_EnvelopeData");
416         
417         /* min/max extents 
418          *      - for now, these are allowed to go past each other, so that we can have inverted action
419          *      - technically, the range is limited by the settings in the envelope-modifier data, not here...
420          */
421         prop= RNA_def_property(srna, "minimum", PROP_FLOAT, PROP_NONE);
422         RNA_def_property_float_sdna(prop, NULL, "min");
423         RNA_def_property_ui_text(prop, "Minimum Value", "Lower bound of envelope at this control-point.");
424         RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME_EDIT, NULL);
425         
426         prop= RNA_def_property(srna, "maximum", PROP_FLOAT, PROP_NONE);
427         RNA_def_property_float_sdna(prop, NULL, "max");
428         RNA_def_property_ui_text(prop, "Maximum Value", "Upper bound of envelope at this control-point.");
429         RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME_EDIT, NULL);
430         
431         /* Frame */
432         prop= RNA_def_property(srna, "frame", PROP_FLOAT, PROP_TIME);
433         RNA_def_property_float_sdna(prop, NULL, "time");
434         RNA_def_property_ui_text(prop, "Frame", "Frame this control-point occurs on.");
435         RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME_EDIT, NULL);
436         
437         // TODO:
438         //      - selection flags (not implemented in UI yet though)
439 }
440
441 static void rna_def_fmodifier_envelope(BlenderRNA *brna)
442 {
443         StructRNA *srna;
444         PropertyRNA *prop;
445         
446         srna= RNA_def_struct(brna, "FModifierEnvelope", "FModifier");
447         RNA_def_struct_ui_text(srna, "Envelope F-Modifier", "Scales the values of the modified F-Curve.");
448         RNA_def_struct_sdna_from(srna, "FMod_Envelope", "data");
449         
450         /* Collections */
451         prop= RNA_def_property(srna, "control_points", PROP_COLLECTION, PROP_NONE);
452         RNA_def_property_collection_sdna(prop, NULL, "data", "totvert");
453         RNA_def_property_struct_type(prop, "FModifierEnvelopeControlPoint");
454         RNA_def_property_ui_text(prop, "Control Points", "Control points defining the shape of the envelope.");
455         
456         /* Range Settings */
457         prop= RNA_def_property(srna, "reference_value", PROP_FLOAT, PROP_NONE);
458         RNA_def_property_float_sdna(prop, NULL, "midval");
459         RNA_def_property_ui_text(prop, "Reference Value", "Value that envelope's influence is centered around / based on.");
460         RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME_EDIT, NULL);
461         
462         prop= RNA_def_property(srna, "default_minimum", PROP_FLOAT, PROP_NONE);
463         RNA_def_property_float_sdna(prop, NULL, "min");
464         RNA_def_property_ui_text(prop, "Default Minimum", "Lower distance from Reference Value for 1:1 default influence.");
465         RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME_EDIT, NULL);
466         
467         prop= RNA_def_property(srna, "default_maximum", PROP_FLOAT, PROP_NONE);
468         RNA_def_property_float_sdna(prop, NULL, "max");
469         RNA_def_property_ui_text(prop, "Default Maximum", "Upper distance from Reference Value for 1:1 default influence.");
470         RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME_EDIT, NULL);
471 }
472
473 /* --------- */
474
475 static void rna_def_fmodifier_cycles(BlenderRNA *brna)
476 {
477         StructRNA *srna;
478         PropertyRNA *prop;
479         
480         static EnumPropertyItem prop_type_items[] = {
481                 {FCM_EXTRAPOLATE_NONE, "NONE", 0, "No Cycles", "Don't do anything."},
482                 {FCM_EXTRAPOLATE_CYCLIC, "REPEAT", 0, "Repeat Motion", "Repeat keyframe range as-is."},
483                 {FCM_EXTRAPOLATE_CYCLIC_OFFSET, "REPEAT_OFFSET", 0, "Repeat with Offset", "Repeat keyframe range, but with offset based on gradient between values"},
484                 {FCM_EXTRAPOLATE_MIRROR, "MIRROR", 0, "Repeat Mirrored", "Alternate between forward and reverse playback of keyframe range"},
485                 {0, NULL, 0, NULL, NULL}};
486         
487         srna= RNA_def_struct(brna, "FModifierCycles", "FModifier");
488         RNA_def_struct_ui_text(srna, "Cycles F-Modifier", "Repeats the values of the modified F-Curve.");
489         RNA_def_struct_sdna_from(srna, "FMod_Cycles", "data");
490         
491         /* before */
492         prop= RNA_def_property(srna, "before_mode", PROP_ENUM, PROP_NONE);
493         RNA_def_property_enum_items(prop, prop_type_items);
494         RNA_def_property_ui_text(prop, "Before Mode", "Cycling mode to use before first keyframe.");
495         RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME_EDIT, NULL);
496         
497         prop= RNA_def_property(srna, "before_cycles", PROP_FLOAT, PROP_NONE);
498         RNA_def_property_ui_text(prop, "Before Cycles", "Maximum number of cycles to allow before first keyframe. (0 = infinite)");
499         RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME_EDIT, NULL);
500         
501         /* after */
502         prop= RNA_def_property(srna, "after_mode", PROP_ENUM, PROP_NONE);
503         RNA_def_property_enum_items(prop, prop_type_items);
504         RNA_def_property_ui_text(prop, "After Mode", "Cycling mode to use after last keyframe.");
505         RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME_EDIT, NULL);
506         
507         prop= RNA_def_property(srna, "after_cycles", PROP_FLOAT, PROP_NONE);
508         RNA_def_property_ui_text(prop, "After Cycles", "Maximum number of cycles to allow after last keyframe. (0 = infinite)");
509         RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME_EDIT, NULL);
510 }
511
512 /* --------- */
513
514 static void rna_def_fmodifier_python(BlenderRNA *brna)
515 {
516         StructRNA *srna;
517         //PropertyRNA *prop;
518         
519         srna= RNA_def_struct(brna, "FModifierPython", "FModifier");
520         RNA_def_struct_ui_text(srna, "Python F-Modifier", "Performs user-defined operation on the modified F-Curve.");
521         RNA_def_struct_sdna_from(srna, "FMod_Python", "data");
522 }
523
524 /* --------- */
525
526 static void rna_def_fmodifier_limits(BlenderRNA *brna)
527 {
528         StructRNA *srna;
529         PropertyRNA *prop;
530         
531         srna= RNA_def_struct(brna, "FModifierLimits", "FModifier");
532         RNA_def_struct_ui_text(srna, "Limits F-Modifier", "Limits the time/value ranges of the modified F-Curve.");
533         RNA_def_struct_sdna_from(srna, "FMod_Limits", "data");
534         
535         prop= RNA_def_property(srna, "use_minimum_x", PROP_BOOLEAN, PROP_NONE);
536         RNA_def_property_boolean_sdna(prop, NULL, "flag", FCM_LIMIT_XMIN);
537         RNA_def_property_ui_text(prop, "Minimum X", "Use the minimum X value.");
538         RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME_EDIT, NULL);
539         
540         prop= RNA_def_property(srna, "use_minimum_y", PROP_BOOLEAN, PROP_NONE);
541         RNA_def_property_boolean_sdna(prop, NULL, "flag", FCM_LIMIT_YMIN);
542         RNA_def_property_ui_text(prop, "Minimum Y", "Use the minimum Y value.");
543         RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME_EDIT, NULL);
544         
545         prop= RNA_def_property(srna, "use_maximum_x", PROP_BOOLEAN, PROP_NONE);
546         RNA_def_property_boolean_sdna(prop, NULL, "flag", FCM_LIMIT_XMAX);
547         RNA_def_property_ui_text(prop, "Maximum X", "Use the maximum X value.");
548         RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME_EDIT, NULL);
549         
550         prop= RNA_def_property(srna, "use_maximum_y", PROP_BOOLEAN, PROP_NONE);
551         RNA_def_property_boolean_sdna(prop, NULL, "flag", FCM_LIMIT_YMAX);
552         RNA_def_property_ui_text(prop, "Maximum Y", "Use the maximum Y value.");
553         RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME_EDIT, NULL);
554         
555         prop= RNA_def_property(srna, "minimum_x", PROP_FLOAT, PROP_NONE);
556         RNA_def_property_float_sdna(prop, NULL, "rect.xmin");
557         RNA_def_property_ui_text(prop, "Minimum X", "Lowest X value to allow.");
558         RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME_EDIT, NULL);
559         
560         prop= RNA_def_property(srna, "minimum_y", PROP_FLOAT, PROP_NONE);
561         RNA_def_property_float_sdna(prop, NULL, "rect.ymin");
562         RNA_def_property_ui_text(prop, "Minimum Y", "Lowest Y value to allow.");
563         RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME_EDIT, NULL);
564         
565         prop= RNA_def_property(srna, "maximum_x", PROP_FLOAT, PROP_NONE);
566         RNA_def_property_float_sdna(prop, NULL, "rect.xmax");
567         RNA_def_property_ui_text(prop, "Maximum X", "Highest X value to allow.");
568         RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME_EDIT, NULL);
569         
570         prop= RNA_def_property(srna, "maximum_y", PROP_FLOAT, PROP_NONE);
571         RNA_def_property_float_sdna(prop, NULL, "rect.ymax");
572         RNA_def_property_ui_text(prop, "Maximum Y", "Highest Y value to allow.");
573         RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME_EDIT, NULL);
574 }
575
576 /* --------- */
577
578 static void rna_def_fmodifier_noise(BlenderRNA *brna)
579 {
580         StructRNA *srna;
581         PropertyRNA *prop;
582         
583         static EnumPropertyItem prop_modification_items[] = {
584                 {FCM_NOISE_MODIF_REPLACE, "REPLACE", 0, "Replace", ""},
585                 {FCM_NOISE_MODIF_ADD, "ADD", 0, "Add", ""},
586                 {FCM_NOISE_MODIF_SUBTRACT, "SUBTRACT", 0, "Subtract", ""},
587                 {FCM_NOISE_MODIF_MULTIPLY, "MULTIPLY", 0, "Multiply", ""},
588                 {0, NULL, 0, NULL, NULL}};
589         
590         srna= RNA_def_struct(brna, "FModifierNoise", "FModifier");
591         RNA_def_struct_ui_text(srna, "Noise F-Modifier", "Gives randomness to the modified F-Curve.");
592         RNA_def_struct_sdna_from(srna, "FMod_Noise", "data");
593         
594         prop= RNA_def_property(srna, "modification", PROP_ENUM, PROP_NONE);
595         RNA_def_property_enum_items(prop, prop_modification_items);
596         RNA_def_property_ui_text(prop, "Modification", "Method of modifying the existing F-Curve.");
597         RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME_EDIT, NULL);
598         
599         prop= RNA_def_property(srna, "size", PROP_FLOAT, PROP_NONE);
600         RNA_def_property_float_sdna(prop, NULL, "size");
601         RNA_def_property_ui_text(prop, "Size", "Scaling (in time) of the noise");
602         RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME_EDIT, NULL);
603         
604         prop= RNA_def_property(srna, "strength", PROP_FLOAT, PROP_NONE);
605         RNA_def_property_float_sdna(prop, NULL, "strength");
606         RNA_def_property_ui_text(prop, "Strength", "Amplitude of the noise - the amount that it modifies the underlying curve");
607         RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME_EDIT, NULL);
608         
609         prop= RNA_def_property(srna, "phase", PROP_FLOAT, PROP_NONE);
610         RNA_def_property_float_sdna(prop, NULL, "phase");
611         RNA_def_property_ui_text(prop, "Phase", "A random seed for the noise effect");
612         RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME_EDIT, NULL);
613         
614         prop= RNA_def_property(srna, "depth", PROP_INT, PROP_NONE);
615         RNA_def_property_int_sdna(prop, NULL, "depth");
616         RNA_def_property_ui_text(prop, "Depth", "Amount of fine level detail present in the noise");
617         RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME_EDIT, NULL);
618
619 }
620
621
622 /* --------- */
623
624 static void rna_def_fmodifier_sound(BlenderRNA *brna)
625 {
626         StructRNA *srna;
627         PropertyRNA *prop;
628
629         static EnumPropertyItem prop_modification_items[] = {
630                 {FCM_SOUND_MODIF_REPLACE, "REPLACE", 0, "Replace", ""},
631                 {FCM_SOUND_MODIF_ADD, "ADD", 0, "Add", ""},
632                 {FCM_SOUND_MODIF_SUBTRACT, "SUBTRACT", 0, "Subtract", ""},
633                 {FCM_SOUND_MODIF_MULTIPLY, "MULTIPLY", 0, "Multiply", ""},
634                 {0, NULL, 0, NULL, NULL}};
635
636         srna= RNA_def_struct(brna, "FModifierSound", "FModifier");
637         RNA_def_struct_ui_text(srna, "Sound F-Modifier", "Modifies an F-Curve based on the amplitudes in a sound.");
638         RNA_def_struct_sdna_from(srna, "FMod_Sound", "data");
639
640         prop= RNA_def_property(srna, "modification", PROP_ENUM, PROP_NONE);
641         RNA_def_property_enum_items(prop, prop_modification_items);
642         RNA_def_property_ui_text(prop, "Modification", "Method of modifying the existing F-Curve.");
643         RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME_EDIT, NULL);
644
645         prop= RNA_def_property(srna, "strength", PROP_FLOAT, PROP_NONE);
646         RNA_def_property_float_sdna(prop, NULL, "strength");
647         RNA_def_property_ui_text(prop, "Strength", "Amplitude of the sound - the amount that it modifies the underlying curve");
648         RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME_EDIT, NULL);
649
650         prop= RNA_def_property(srna, "delay", PROP_FLOAT, PROP_NONE);
651         RNA_def_property_float_sdna(prop, NULL, "delay");
652         RNA_def_property_ui_text(prop, "delay", "The delay before the sound curve modification should start");
653         RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME_EDIT, NULL);
654
655         prop= RNA_def_property(srna, "sound", PROP_POINTER, PROP_NONE);
656         RNA_def_property_struct_type(prop, "Sound");
657         RNA_def_property_flag(prop, PROP_EDITABLE);
658         RNA_def_property_ui_text(prop, "Sound", "Sound datablock used by this modifier.");
659
660 }
661
662 /* --------- */
663
664 static void rna_def_fmodifier(BlenderRNA *brna)
665 {
666         StructRNA *srna;
667         PropertyRNA *prop;
668         
669         /* base struct definition */
670         srna= RNA_def_struct(brna, "FModifier", NULL);
671         RNA_def_struct_refine_func(srna, "rna_FModifierType_refine");
672         RNA_def_struct_ui_text(srna, "F-Modifier", "Modifier for values of F-Curve.");
673         
674 #if 0 // XXX not used yet
675         /* name */
676         prop= RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
677         RNA_def_struct_name_property(srna, prop);
678         RNA_def_property_ui_text(prop, "Name", "Short description of F-Curve Modifier.");
679 #endif // XXX not used yet
680         
681         /* type */
682         prop= RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
683         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
684         RNA_def_property_enum_items(prop, fmodifier_type_items);
685         RNA_def_property_ui_text(prop, "Type", "F-Curve Modifier Type");
686         
687         /* settings */
688         prop= RNA_def_property(srna, "expanded", PROP_BOOLEAN, PROP_NONE);
689         RNA_def_property_boolean_sdna(prop, NULL, "flag", FMODIFIER_FLAG_EXPANDED);
690         RNA_def_property_ui_text(prop, "Expanded", "F-Curve Modifier's panel is expanded in UI.");
691         RNA_def_property_ui_icon(prop, ICON_TRIA_RIGHT, 1);
692         
693         prop= RNA_def_property(srna, "muted", PROP_BOOLEAN, PROP_NONE);
694         RNA_def_property_boolean_sdna(prop, NULL, "flag", FMODIFIER_FLAG_MUTED);
695         RNA_def_property_ui_text(prop, "Muted", "F-Curve Modifier will not be evaluated.");
696         RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME_PROP, NULL);
697         RNA_def_property_ui_icon(prop, ICON_MUTE_IPO_OFF, 1);
698         
699                 // XXX this is really an internal flag, but it may be useful for some tools to be able to access this...
700         prop= RNA_def_property(srna, "disabled", PROP_BOOLEAN, PROP_NONE);
701         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
702         RNA_def_property_boolean_sdna(prop, NULL, "flag", FMODIFIER_FLAG_DISABLED);
703         RNA_def_property_ui_text(prop, "Disabled", "F-Curve Modifier has invalid settings and will not be evaluated.");
704         RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME_PROP, NULL);
705         
706                 // TODO: setting this to true must ensure that all others in stack are turned off too...
707         prop= RNA_def_property(srna, "active", PROP_BOOLEAN, PROP_NONE);
708         RNA_def_property_boolean_sdna(prop, NULL, "flag", FMODIFIER_FLAG_ACTIVE);
709         RNA_def_property_ui_text(prop, "Active", "F-Curve Modifier is the one being edited ");
710         RNA_def_property_boolean_funcs(prop, NULL, "rna_Fmodifier_active_set");
711         RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME_PROP, "rna_Fmodifier_active_update");
712         RNA_def_property_ui_icon(prop, ICON_RADIOBUT_OFF, 1);
713 }       
714
715 /* *********************** */
716
717 static void rna_def_drivertarget(BlenderRNA *brna)
718 {
719         StructRNA *srna;
720         PropertyRNA *prop;
721         
722         srna= RNA_def_struct(brna, "DriverTarget", NULL);
723         RNA_def_struct_ui_text(srna, "Driver Target", "Variable from some source/target for driver relationship.");
724         
725         /* Variable Name */
726         prop= RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
727         RNA_def_struct_name_property(srna, prop);
728         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)");
729         RNA_def_property_update(prop, 0, "rna_DriverTarget_update_data");
730         
731         /* Target Properties - ID-block to Drive */
732         prop= RNA_def_property(srna, "id", PROP_POINTER, PROP_NONE);
733         RNA_def_property_struct_type(prop, "ID");
734         RNA_def_property_flag(prop, PROP_EDITABLE);
735         RNA_def_property_editable_func(prop, "rna_DriverTarget_id_editable");
736         RNA_def_property_pointer_funcs(prop, NULL, NULL, "rna_DriverTarget_id_typef");
737         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)");
738         RNA_def_property_update(prop, 0, "rna_DriverTarget_update_data");
739         
740         prop= RNA_def_property(srna, "id_type", PROP_ENUM, PROP_NONE);
741         RNA_def_property_enum_sdna(prop, NULL, "idtype");
742         RNA_def_property_enum_items(prop, id_type_items);
743         RNA_def_property_enum_default(prop, ID_OB);
744         RNA_def_property_enum_funcs(prop, NULL, "rna_DriverTarget_id_type_set", NULL);
745         RNA_def_property_ui_text(prop, "ID Type", "Type of ID-block that can be used.");
746         RNA_def_property_update(prop, 0, "rna_DriverTarget_update_data");
747         
748         /* Target Properties - Property to Drive */
749         prop= RNA_def_property(srna, "rna_path", PROP_STRING, PROP_NONE);
750         RNA_def_property_string_funcs(prop, "rna_DriverTarget_RnaPath_get", "rna_DriverTarget_RnaPath_length", "rna_DriverTarget_RnaPath_set");
751         RNA_def_property_ui_text(prop, "RNA Path", "RNA Path (from Object) to property used");
752         RNA_def_property_update(prop, 0, "rna_DriverTarget_update_data");
753         
754         prop= RNA_def_property(srna, "array_index", PROP_INT, PROP_NONE);
755         RNA_def_property_ui_text(prop, "RNA Array Index", "Index to the specific property used (if applicable)");
756         RNA_def_property_update(prop, 0, "rna_DriverTarget_update_data");
757 }
758
759
760 /* channeldriver.targets.* */
761 static void rna_def_channeldriver_targets(BlenderRNA *brna, PropertyRNA *cprop)
762 {
763         StructRNA *srna;
764 //      PropertyRNA *prop;
765
766         FunctionRNA *func;
767         PropertyRNA *parm;
768
769         RNA_def_property_srna(cprop, "ChannelDriverTargets");
770         srna= RNA_def_struct(brna, "ChannelDriverTargets", NULL);
771         RNA_def_struct_sdna(srna, "ChannelDriver");
772         RNA_def_struct_ui_text(srna, "ChannelDriver Targets", "Collection of channel driver Targets.");
773
774
775         /* add target */
776         func= RNA_def_function(srna, "new", "rna_Driver_new_target");
777         RNA_def_function_ui_description(func, "Add a new target for the driver.");
778                 /* return type */
779         parm= RNA_def_pointer(func, "target", "DriverTarget", "", "Newly created Driver Target.");
780                 RNA_def_function_return(func, parm);
781
782         /* remove target */
783         func= RNA_def_function(srna, "remove", "rna_Driver_remove_target");
784                 RNA_def_function_ui_description(func, "Remove an existing target from the driver.");
785                 /* target to remove*/
786         parm= RNA_def_pointer(func, "target", "DriverTarget", "", "Target to remove from the driver.");
787                 RNA_def_property_flag(parm, PROP_REQUIRED);
788
789 }
790
791 static void rna_def_channeldriver(BlenderRNA *brna)
792 {
793         StructRNA *srna;
794         PropertyRNA *prop;
795         
796         static EnumPropertyItem prop_type_items[] = {
797                 {DRIVER_TYPE_AVERAGE, "AVERAGE", 0, "Averaged Value", ""},
798                 {DRIVER_TYPE_PYTHON, "SCRIPTED", 0, "Scripted Expression", ""},
799                 {DRIVER_TYPE_ROTDIFF, "ROTDIFF", 0, "Rotational Difference", ""},
800                 {0, NULL, 0, NULL, NULL}};
801
802         srna= RNA_def_struct(brna, "Driver", NULL);
803         RNA_def_struct_sdna(srna, "ChannelDriver");
804         RNA_def_struct_ui_text(srna, "Driver", "Driver for the value of a setting based on an external value.");
805
806         /* Enums */
807         prop= RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
808         RNA_def_property_enum_items(prop, prop_type_items);
809         RNA_def_property_ui_text(prop, "Type", "Driver types.");
810         RNA_def_property_update(prop, 0, "rna_ChannelDriver_update_data");
811
812         /* String values */
813         prop= RNA_def_property(srna, "expression", PROP_STRING, PROP_NONE);
814         RNA_def_property_ui_text(prop, "Expression", "Expression to use for Scripted Expression.");
815         RNA_def_property_update(prop, 0, "rna_ChannelDriver_update_data");
816
817         /* Collections */
818         prop= RNA_def_property(srna, "targets", PROP_COLLECTION, PROP_NONE);
819         RNA_def_property_collection_sdna(prop, NULL, "targets", NULL);
820         RNA_def_property_struct_type(prop, "DriverTarget");
821         RNA_def_property_ui_text(prop, "Target Variables", "Properties acting as targets for this driver.");
822         rna_def_channeldriver_targets(brna, prop);
823         
824         /* Functions */
825         RNA_api_drivers(srna);
826 }
827
828 /* *********************** */
829
830 static void rna_def_fpoint(BlenderRNA *brna)
831 {
832         StructRNA *srna;
833         PropertyRNA *prop;
834         
835         srna= RNA_def_struct(brna, "FCurveSample", NULL);
836         RNA_def_struct_sdna(srna, "FPoint");
837         RNA_def_struct_ui_text(srna, "F-Curve Sample", "Sample point for F-Curve.");
838         
839         /* Boolean values */
840         prop= RNA_def_property(srna, "selected", PROP_BOOLEAN, PROP_NONE);
841         RNA_def_property_boolean_sdna(prop, NULL, "flag", 1);
842         RNA_def_property_ui_text(prop, "Selected", "Selection status");
843         
844         /* Vector value */
845         prop= RNA_def_property(srna, "point", PROP_FLOAT, PROP_XYZ);
846         RNA_def_property_array(prop, 2);
847         RNA_def_property_float_sdna(prop, NULL, "vec");
848         RNA_def_property_ui_text(prop, "Point", "Point coordinates");
849 }
850
851 /* channeldriver.targets.* */
852 static void rna_def_fcurve_modifiers(BlenderRNA *brna, PropertyRNA *cprop)
853 {
854         /* add target */
855         StructRNA *srna;
856         PropertyRNA *prop;
857
858         FunctionRNA *func;
859         PropertyRNA *parm;
860
861         RNA_def_property_srna(cprop, "FCurveModifiers");
862         srna= RNA_def_struct(brna, "FCurveModifiers", NULL);
863         RNA_def_struct_sdna(srna, "FCurve");
864         RNA_def_struct_ui_text(srna, "FCurve Modifiers", "Collection of fcurve modifiers.");
865
866
867         /* Collection active property */
868         prop= RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
869         RNA_def_property_struct_type(prop, "FModifier");
870         RNA_def_property_pointer_funcs(prop, "rna_FCurve_active_modifier_get", "rna_FCurve_active_modifier_set", NULL);
871         RNA_def_property_flag(prop, PROP_EDITABLE);
872         RNA_def_property_ui_text(prop, "Active fcurve modifier", "Active fcurve modifier.");
873
874         /* Constraint collection */
875         func= RNA_def_function(srna, "new", "rna_FCurve_modifiers_new");
876         RNA_def_function_flag(func, FUNC_USE_CONTEXT);
877         RNA_def_function_ui_description(func, "Add a constraint to this object");
878         /* return type */
879         parm= RNA_def_pointer(func, "fmodifier", "FModifier", "", "New fmodifier.");
880         RNA_def_function_return(func, parm);
881         /* object to add */
882         parm= RNA_def_enum(func, "type", fmodifier_type_items, 1, "", "Constraint type to add.");
883         RNA_def_property_flag(parm, PROP_REQUIRED);
884
885         func= RNA_def_function(srna, "remove", "rna_FCurve_modifiers_remove");
886         RNA_def_function_flag(func, FUNC_USE_CONTEXT);
887         RNA_def_function_ui_description(func, "Remove a modifier from this fcurve.");
888         /* return type */
889         parm= RNA_def_boolean(func, "success", 0, "Success", "Removed the constraint successfully.");
890         RNA_def_function_return(func, parm);
891         /* object to add */
892         parm= RNA_def_int(func, "index", 0, 0, INT_MAX, "Index", "", 0, INT_MAX);
893         RNA_def_property_flag(parm, PROP_REQUIRED);
894 }
895
896 static void rna_def_fcurve(BlenderRNA *brna)
897 {
898         StructRNA *srna;
899         PropertyRNA *prop;
900         
901         static EnumPropertyItem prop_mode_extend_items[] = {
902                 {FCURVE_EXTRAPOLATE_CONSTANT, "CONSTANT", 0, "Constant", ""},
903                 {FCURVE_EXTRAPOLATE_LINEAR, "LINEAR", 0, "Linear", ""},
904                 {0, NULL, 0, NULL, NULL}};
905         static EnumPropertyItem prop_mode_color_items[] = {
906                 {FCURVE_COLOR_AUTO_RAINBOW, "AUTO_RAINBOW", 0, "Auto Rainbow", ""},
907                 {FCURVE_COLOR_AUTO_RGB, "AUTO_RGB", 0, "Auto XYZ to RGB", ""},
908                 {FCURVE_COLOR_CUSTOM, "CUSTOM", 0, "User Defined", ""},
909                 {0, NULL, 0, NULL, NULL}};
910
911         srna= RNA_def_struct(brna, "FCurve", NULL);
912         RNA_def_struct_ui_text(srna, "F-Curve", "F-Curve defining values of a period of time.");
913         RNA_def_struct_ui_icon(srna, ICON_ANIM_DATA);
914
915         /* Enums */
916         prop= RNA_def_property(srna, "extrapolation", PROP_ENUM, PROP_NONE);
917         RNA_def_property_enum_sdna(prop, NULL, "extend");
918         RNA_def_property_enum_items(prop, prop_mode_extend_items);
919         RNA_def_property_ui_text(prop, "Extrapolation", "");
920
921         /* Pointers */
922         prop= RNA_def_property(srna, "driver", PROP_POINTER, PROP_NONE);
923         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
924         RNA_def_property_ui_text(prop, "Driver", "Channel Driver (only set for Driver F-Curves)");
925         
926         /* Path + Array Index */
927         prop= RNA_def_property(srna, "rna_path", PROP_STRING, PROP_NONE);
928         RNA_def_property_string_funcs(prop, "rna_FCurve_RnaPath_get", "rna_FCurve_RnaPath_length", "rna_FCurve_RnaPath_set");
929         RNA_def_property_ui_text(prop, "RNA Path", "RNA Path to property affected by F-Curve.");
930         
931         prop= RNA_def_property(srna, "array_index", PROP_INT, PROP_NONE);
932         RNA_def_property_ui_text(prop, "RNA Array Index", "Index to the specific property affected by F-Curve if applicable.");
933         
934         /* Color */
935         prop= RNA_def_property(srna, "color_mode", PROP_ENUM, PROP_NONE);
936         RNA_def_property_enum_items(prop, prop_mode_color_items);
937         RNA_def_property_ui_text(prop, "Color Mode", "Method used to determine color of F-Curve in Graph Editor.");
938         
939         prop= RNA_def_property(srna, "color", PROP_FLOAT, PROP_COLOR);
940         RNA_def_property_array(prop, 3);
941         RNA_def_property_ui_text(prop, "Color", "Color of the F-Curve in the Graph Editor.");
942         
943         /* Collections */
944         prop= RNA_def_property(srna, "sampled_points", PROP_COLLECTION, PROP_NONE);
945         RNA_def_property_collection_sdna(prop, NULL, "fpt", "totvert");
946         RNA_def_property_struct_type(prop, "FCurveSample");
947         RNA_def_property_ui_text(prop, "Sampled Points", "Sampled animation data");
948
949         prop= RNA_def_property(srna, "keyframe_points", PROP_COLLECTION, PROP_NONE);
950         RNA_def_property_collection_sdna(prop, NULL, "bezt", "totvert");
951         RNA_def_property_struct_type(prop, "BezierCurvePoint");
952         RNA_def_property_ui_text(prop, "Keyframes", "User-editable keyframes");
953         
954         prop= RNA_def_property(srna, "modifiers", PROP_COLLECTION, PROP_NONE);
955         RNA_def_property_struct_type(prop, "FModifier");
956         RNA_def_property_ui_text(prop, "Modifiers", "Modifiers affecting the shape of the F-Curve.");
957
958         rna_def_fcurve_modifiers(brna, prop);
959 }
960
961 /* *********************** */
962
963 void RNA_def_fcurve(BlenderRNA *brna)
964 {
965         rna_def_fcurve(brna);
966         rna_def_fpoint(brna);
967         
968         rna_def_drivertarget(brna);
969         rna_def_channeldriver(brna);
970         
971         rna_def_fmodifier(brna);
972         
973         rna_def_fmodifier_generator(brna);
974         rna_def_fmodifier_function_generator(brna);
975         rna_def_fmodifier_envelope(brna);
976                 rna_def_fmodifier_envelope_ctrl(brna);
977         rna_def_fmodifier_cycles(brna);
978         rna_def_fmodifier_python(brna);
979         rna_def_fmodifier_limits(brna);
980         rna_def_fmodifier_noise(brna);
981         rna_def_fmodifier_sound(brna);
982 }
983
984
985 #endif