F-Curve Modifiers: Basic GUI for Generator Modifier working
[blender.git] / source / blender / blenkernel / intern / fcurve.c
1 /* Testing code for new animation system in 2.5 
2  * Copyright 2009, Joshua Leung
3  */
4  
5
6 #include <math.h>
7 #include <stdio.h>
8 #include <string.h>
9 #include <float.h>
10
11 #ifdef HAVE_CONFIG_H
12 #include <config.h>
13 #endif
14
15 #include "MEM_guardedalloc.h"
16
17 #include "DNA_anim_types.h"
18
19 #include "BLI_blenlib.h"
20 #include "BLI_arithb.h"
21
22 #include "BKE_fcurve.h"
23 #include "BKE_curve.h" 
24 #include "BKE_global.h"
25 #include "BKE_idprop.h"
26 #include "BKE_utildefines.h"
27
28 #include "RNA_access.h"
29 #include "RNA_types.h"
30
31 #ifndef DISABLE_PYTHON
32 #include "BPY_extern.h" /* for BPY_pydriver_eval() */
33 #endif
34
35 #define SMALL -1.0e-10
36 #define SELECT 1
37
38 /* ************************** Data-Level Functions ************************* */
39
40 /* ---------------------- Freeing --------------------------- */
41
42 /* Frees the F-Curve itself too, so make sure BLI_remlink is called before calling this... */
43 void free_fcurve (FCurve *fcu) 
44 {
45         if (fcu == NULL) 
46                 return;
47         
48         /* free curve data */
49         if (fcu) {
50                 if (fcu->bezt) MEM_freeN(fcu->bezt);
51                 if (fcu->fpt) MEM_freeN(fcu->fpt);
52         }
53         
54         /* free RNA-path, as this were allocated when getting the path string */
55         if (fcu->rna_path)
56                 MEM_freeN(fcu->rna_path);
57         
58         /* free extra data - i.e. modifiers, and driver */
59         fcurve_free_driver(fcu);
60         fcurve_free_modifiers(fcu);
61         
62         /* free f-cruve itself */
63         MEM_freeN(fcu);
64 }
65
66 /* Frees a list of F-Curves */
67 void free_fcurves (ListBase *list)
68 {
69         FCurve *fcu, *fcn;
70         
71         /* sanity check */
72         if (list == NULL)
73                 return;
74                 
75         /* free data - no need to call remlink before freeing each curve, 
76          * as we store reference to next, and freeing only touches the curve
77          * it's given
78          */
79         for (fcu= list->first; fcu; fcu= fcn) {
80                 fcn= fcu->next;
81                 free_fcurve(fcu);
82         }
83         
84         /* clear pointers just in case */
85         list->first= list->last= NULL;
86 }       
87
88 /* ---------------------- Copy --------------------------- */
89
90 /* duplicate an F-Curve */
91 FCurve *copy_fcurve (FCurve *fcu)
92 {
93         FCurve *fcu_d;
94         
95         /* sanity check */
96         if (fcu == NULL)
97                 return NULL;
98                 
99         /* make a copy */
100         fcu_d= MEM_dupallocN(fcu);
101         fcu_d->next= fcu_d->prev= NULL;
102         
103         /* copy curve data */
104         fcu_d->bezt= MEM_dupallocN(fcu_d->bezt);
105         fcu_d->fpt= MEM_dupallocN(fcu_d->fpt);
106         
107         /* copy rna-path */
108         fcu_d->rna_path= MEM_dupallocN(fcu_d->rna_path);
109         
110         /* copy driver */
111         fcu_d->driver= fcurve_copy_driver(fcu_d->driver);
112         
113         /* copy modifiers */
114         fcurve_copy_modifiers(&fcu_d->modifiers, &fcu->modifiers);
115         
116         /* return new data */
117         return fcu_d;
118 }
119
120 /* duplicate a list of F-Curves */
121 void copy_fcurves (ListBase *dst, ListBase *src)
122 {
123         FCurve *dfcu, *sfcu;
124         
125         /* sanity checks */
126         if ELEM(NULL, dst, src)
127                 return;
128         
129         /* clear destination list first */
130         dst->first= dst->last= NULL;
131         
132         /* copy one-by-one */
133         for (sfcu= src->first; sfcu; sfcu= sfcu->next) {
134                 dfcu= copy_fcurve(sfcu);
135                 BLI_addtail(dst, dfcu);
136         }
137 }
138
139 /* ---------------------- Relink --------------------------- */
140
141 #if 0
142 /* uses id->newid to match pointers with other copied data 
143  *      - called after single-user or other such
144  */
145                         if (icu->driver)
146                                 ID_NEW(icu->driver->ob);
147 #endif
148
149 /* --------------------- Finding -------------------------- */
150
151 /* Find the F-Curve affecting the given RNA-access path + index, in the list of F-Curves provided */
152 FCurve *list_find_fcurve (ListBase *list, const char rna_path[], const int array_index)
153 {
154         FCurve *fcu;
155         
156         /* sanity checks */
157         if ( ELEM(NULL, list, rna_path) || (array_index < 0) )
158                 return NULL;
159         
160         /* check paths of curves, then array indices... */
161         for (fcu= list->first; fcu; fcu= fcu->next) {
162                 /* simple string-compare (this assumes that they have the same root...) */
163                 if (strcmp(fcu->rna_path, rna_path) == 0) {
164                         /* now check indicies */
165                         if (fcu->array_index == array_index)
166                                 return fcu;
167                 }
168         }
169         
170         /* return */
171         return NULL;
172 }
173
174 /* Calculate the extents of F-Curve's data */
175 void calc_fcurve_bounds (FCurve *fcu, float *xmin, float *xmax, float *ymin, float *ymax)
176 {
177         float xminv=999999999.0f, xmaxv=-999999999.0f;
178         float yminv=999999999.0f, ymaxv=-999999999.0f;
179         short foundvert=0;
180         int i;
181         
182         if (fcu->totvert) {
183                 if (fcu->bezt) {
184                         /* frame range can be directly calculated from end verts */
185                         if (xmin || xmax) {
186                                 xminv= MIN2(xminv, fcu->bezt[0].vec[1][0]);
187                                 xmaxv= MAX2(xmaxv, fcu->bezt[fcu->totvert-1].vec[1][0]);
188                         }
189                         
190                         /* only loop over keyframes to find extents for values if needed */
191                         if (ymin || ymax) {
192                                 BezTriple *bezt;
193                                 
194                                 for (bezt=fcu->bezt, i=0; i < fcu->totvert; bezt++, i++) {
195                                         yminv= MIN2(yminv, bezt->vec[1][1]);
196                                         ymaxv= MAX2(ymaxv, bezt->vec[1][1]);
197                                 }
198                         }
199                 }
200                 else if (fcu->fpt) {
201                         /* frame range can be directly calculated from end verts */
202                         if (xmin || xmax) {
203                                 xminv= MIN2(xminv, fcu->fpt[0].vec[0]);
204                                 xmaxv= MAX2(xmaxv, fcu->fpt[fcu->totvert-1].vec[0]);
205                         }
206                         
207                         /* only loop over keyframes to find extents for values if needed */
208                         if (ymin || ymax) {
209                                 FPoint *fpt;
210                                 
211                                 for (fpt=fcu->fpt, i=0; i < fcu->totvert; fpt++, i++) {
212                                         yminv= MIN2(yminv, fpt->vec[1]);
213                                         ymaxv= MAX2(ymaxv, fpt->vec[1]);
214                                 }
215                         }
216                 }
217                 
218                 foundvert=1;
219         }
220         
221         /* minimum sizes are 1.0f */
222         if (foundvert) {
223                 if (xminv == xmaxv) xmaxv += 1.0f;
224                 if (yminv == ymaxv) ymaxv += 1.0f;
225                 
226                 if (xmin) *xmin= xminv;
227                 if (xmax) *xmax= xmaxv;
228                 
229                 if (ymin) *ymin= yminv;
230                 if (ymax) *ymax= ymaxv;
231         }
232         else {
233                 if (xmin) *xmin= 0.0f;
234                 if (xmax) *xmax= 0.0f;
235                 
236                 if (ymin) *ymin= 1.0f;
237                 if (ymax) *ymax= 1.0f;
238         }
239 }
240
241 /* Calculate the extents of F-Curve's keyframes */
242 void calc_fcurve_range (FCurve *fcu, float *start, float *end)
243 {
244         float min=999999999.0f, max=-999999999.0f;
245         short foundvert=0;
246
247         if (fcu->totvert) {
248                 if (fcu->bezt) {
249                         min= MIN2(min, fcu->bezt[0].vec[1][0]);
250                         max= MAX2(max, fcu->bezt[fcu->totvert-1].vec[1][0]);
251                 }
252                 else if (fcu->fpt) {
253                         min= MIN2(min, fcu->fpt[0].vec[0]);
254                         max= MAX2(max, fcu->fpt[fcu->totvert-1].vec[0]);
255                 }
256                 
257                 foundvert=1;
258         }
259         
260         /* minimum length is 1 frame */
261         if (foundvert) {
262                 if (min == max) max += 1.0f;
263                 *start= min;
264                 *end= max;
265         }
266         else {
267                 *start= 0.0f;
268                 *end= 1.0f;
269         }
270 }
271
272 /* ***************************** Keyframe Column Tools ********************************* */
273
274 /* add a BezTriple to a column */
275 void bezt_add_to_cfra_elem (ListBase *lb, BezTriple *bezt)
276 {
277         CfraElem *ce, *cen;
278         
279         for (ce= lb->first; ce; ce= ce->next) {
280                 /* double key? */
281                 if (ce->cfra == bezt->vec[1][0]) {
282                         if (bezt->f2 & SELECT) ce->sel= bezt->f2;
283                         return;
284                 }
285                 /* should key be inserted before this column? */
286                 else if (ce->cfra > bezt->vec[1][0]) break;
287         }
288         
289         /* create a new column */
290         cen= MEM_callocN(sizeof(CfraElem), "add_to_cfra_elem"); 
291         if (ce) BLI_insertlinkbefore(lb, ce, cen);
292         else BLI_addtail(lb, cen);
293
294         cen->cfra= bezt->vec[1][0];
295         cen->sel= bezt->f2;
296 }
297
298 /* ***************************** Samples Utilities ******************************* */
299 /* Some utilities for working with FPoints (i.e. 'sampled' animation curve data, such as
300  * data imported from BVH/Mocap files), which are specialised for use with high density datasets,
301  * which BezTriples/Keyframe data are ill equipped to do.
302  */
303  
304  
305 /* Basic sampling callback which acts as a wrapper for evaluate_fcurve() 
306  *      'data' arg here is unneeded here...
307  */
308 float fcurve_samplingcb_evalcurve (FCurve *fcu, void *data, float evaltime)
309 {
310         /* assume any interference from drivers on the curve is intended... */
311         return evaluate_fcurve(fcu, evaltime);
312
313
314  
315 /* Main API function for creating a set of sampled curve data, given some callback function 
316  * used to retrieve the values to store.
317  */
318 void fcurve_store_samples (FCurve *fcu, void *data, int start, int end, FcuSampleFunc sample_cb)
319 {
320         FPoint *fpt, *new_fpt;
321         int cfra;
322         
323         /* sanity checks */
324         // TODO: make these tests report errors using reports not printf's
325         if ELEM(NULL, fcu, sample_cb) {
326                 printf("Error: No F-Curve with F-Curve Modifiers to Bake\n");
327                 return;
328         }
329         if (start >= end) {
330                 printf("Error: Frame range for Sampled F-Curve creation is inappropriate \n");
331                 return;
332         }
333         
334         /* set up sample data */
335         fpt= new_fpt= MEM_callocN(sizeof(FPoint)*(end-start+1), "FPoint Samples");
336         
337         /* use the sampling callback at 1-frame intervals from start to end frames */
338         for (cfra= start; cfra <= end; cfra++, fpt++) {
339                 fpt->vec[0]= (float)cfra;
340                 fpt->vec[1]= sample_cb(fcu, data, (float)cfra);
341         }
342         
343         /* free any existing sample/keyframe data on curve  */
344         if (fcu->bezt) MEM_freeN(fcu->bezt);
345         if (fcu->fpt) MEM_freeN(fcu->fpt);
346         
347         /* store the samples */
348         fcu->bezt= NULL;
349         fcu->fpt= new_fpt;
350         fcu->totvert= end - start + 1;
351 }
352
353 /* ***************************** F-Curve Sanity ********************************* */
354 /* The functions here are used in various parts of Blender, usually after some editing
355  * of keyframe data has occurred. They ensure that keyframe data is properly ordered and
356  * that the handles are correctly 
357  */
358
359 /* This function recalculates the handles of an F-Curve 
360  * If the BezTriples have been rearranged, sort them first before using this.
361  */
362 void calchandles_fcurve (FCurve *fcu)
363 {
364         BezTriple *bezt, *prev, *next;
365         int a= fcu->totvert;
366
367         /* Error checking:
368          *      - need at least two points
369          *      - need bezier keys
370          *      - only bezier-interpolation has handles (for now)
371          */
372         if (ELEM(NULL, fcu, fcu->bezt) || (a < 2) /*|| ELEM(fcu->ipo, BEZT_IPO_CONST, BEZT_IPO_LIN)*/) 
373                 return;
374         
375         /* get initial pointers */
376         bezt= fcu->bezt;
377         prev= NULL;
378         next= (bezt + 1);
379         
380         /* loop over all beztriples, adjusting handles */
381         while (a--) {
382                 /* clamp timing of handles to be on either side of beztriple */
383                 if (bezt->vec[0][0] > bezt->vec[1][0]) bezt->vec[0][0]= bezt->vec[1][0];
384                 if (bezt->vec[2][0] < bezt->vec[1][0]) bezt->vec[2][0]= bezt->vec[1][0];
385                 
386                 /* calculate auto-handles */
387                 if (fcu->flag & FCURVE_AUTO_HANDLES) 
388                         calchandleNurb(bezt, prev, next, 2);    /* 2==special autohandle && keep extrema horizontal */
389                 else
390                         calchandleNurb(bezt, prev, next, 1);    /* 1==special autohandle */
391                 
392                 /* for automatic ease in and out */
393                 if ((bezt->h1==HD_AUTO) && (bezt->h2==HD_AUTO)) {
394                         /* only do this on first or last beztriple */
395                         if ((a == 0) || (a == fcu->totvert-1)) {
396                                 /* set both handles to have same horizontal value as keyframe */
397                                 if (fcu->extend == FCURVE_EXTRAPOLATE_CONSTANT) {
398                                         bezt->vec[0][1]= bezt->vec[2][1]= bezt->vec[1][1];
399                                 }
400                         }
401                 }
402                 
403                 /* advance pointers for next iteration */
404                 prev= bezt;
405                 if (a == 1) next= NULL;
406                 else next++;
407                 bezt++;
408         }
409 }
410
411 /* Use when F-Curve with handles has changed
412  * It treats all BezTriples with the following rules:
413  *  - PHASE 1: do types have to be altered?
414  *              -> Auto handles: become aligned when selection status is NOT(000 || 111)
415  *              -> Vector handles: become 'nothing' when (one half selected AND other not)
416  *  - PHASE 2: recalculate handles
417 */
418 void testhandles_fcurve (FCurve *fcu)
419 {
420         BezTriple *bezt;
421         int a;
422
423         /* only beztriples have handles (bpoints don't though) */
424         if ELEM(NULL, fcu, fcu->bezt)
425                 return;
426         
427         /* loop over beztriples */
428         for (a=0, bezt=fcu->bezt; a < fcu->totvert; a++, bezt++) {
429                 short flag= 0;
430                 
431                 /* flag is initialised as selection status
432                  * of beztriple control-points (labelled 0,1,2)
433                  */
434                 if (bezt->f1 & SELECT) flag |= (1<<0); // == 1
435                 if (bezt->f2 & SELECT) flag |= (1<<1); // == 2
436                 if (bezt->f3 & SELECT) flag |= (1<<2); // == 4
437                 
438                 /* one or two handles selected only */
439                 if (ELEM(flag, 0, 7)==0) {
440                         /* auto handles become aligned */
441                         if (bezt->h1==HD_AUTO)
442                                 bezt->h1= HD_ALIGN;
443                         if (bezt->h2==HD_AUTO)
444                                 bezt->h2= HD_ALIGN;
445                         
446                         /* vector handles become 'free' when only one half selected */
447                         if (bezt->h1==HD_VECT) {
448                                 /* only left half (1 or 2 or 1+2) */
449                                 if (flag < 4) 
450                                         bezt->h1= 0;
451                         }
452                         if (bezt->h2==HD_VECT) {
453                                 /* only right half (4 or 2+4) */
454                                 if (flag > 3) 
455                                         bezt->h2= 0;
456                         }
457                 }
458         }
459
460         /* recalculate handles */
461         calchandles_fcurve(fcu);
462 }
463
464 /* This function sorts BezTriples so that they are arranged in chronological order,
465  * as tools working on F-Curves expect that the BezTriples are in order.
466  */
467 void sort_time_fcurve (FCurve *fcu)
468 {
469         short ok= 1;
470         
471         /* keep adjusting order of beztriples until nothing moves (bubble-sort) */
472         while (ok) {
473                 ok= 0;
474                 
475                 /* currently, will only be needed when there are beztriples */
476                 if (fcu->bezt) {
477                         BezTriple *bezt;
478                         int a;
479                         
480                         /* loop over ALL points to adjust position in array and recalculate handles */
481                         for (a=0, bezt=fcu->bezt; a < fcu->totvert; a++, bezt++) {
482                                 /* check if thee's a next beztriple which we could try to swap with current */
483                                 if (a < (fcu->totvert-1)) {
484                                         /* swap if one is after the other (and indicate that order has changed) */
485                                         if (bezt->vec[1][0] > (bezt+1)->vec[1][0]) {
486                                                 SWAP(BezTriple, *bezt, *(bezt+1));
487                                                 ok= 1;
488                                         }
489                                         
490                                         /* if either one of both of the points exceeds crosses over the keyframe time... */
491                                         if ( (bezt->vec[0][0] > bezt->vec[1][0]) && (bezt->vec[2][0] < bezt->vec[1][0]) ) {
492                                                 /* swap handles if they have switched sides for some reason */
493                                                 SWAP(float, bezt->vec[0][0], bezt->vec[2][0]);
494                                                 SWAP(float, bezt->vec[0][1], bezt->vec[2][1]);
495                                         }
496                                         else {
497                                                 /* clamp handles */
498                                                 if (bezt->vec[0][0] > bezt->vec[1][0]) 
499                                                         bezt->vec[0][0]= bezt->vec[1][0];
500                                                 if (bezt->vec[2][0] < bezt->vec[1][0]) 
501                                                         bezt->vec[2][0]= bezt->vec[1][0];
502                                         }
503                                 }
504                         }
505                 }
506         }
507 }
508
509 /* This function tests if any BezTriples are out of order, thus requiring a sort */
510 short test_time_fcurve (FCurve *fcu)
511 {
512         int a;
513         
514         /* sanity checks */
515         if (fcu == NULL)
516                 return 0;
517         
518         /* currently, only need to test beztriples */
519         if (fcu->bezt) {
520                 BezTriple *bezt;
521                 
522                 /* loop through all BezTriples, stopping when one exceeds the one after it */
523                 for (a=0, bezt= fcu->bezt; a < (fcu->totvert - 1); a++, bezt++) {
524                         if (bezt->vec[1][0] > (bezt+1)->vec[1][0])
525                                 return 1;
526                 }
527         }
528         else if (fcu->fpt) {
529                 FPoint *fpt;
530                 
531                 /* loop through all FPoints, stopping when one exceeds the one after it */
532                 for (a=0, fpt= fcu->fpt; a < (fcu->totvert - 1); a++, fpt++) {
533                         if (fpt->vec[0] > (fpt+1)->vec[0])
534                                 return 1;
535                 }
536         }
537         
538         /* none need any swapping */
539         return 0;
540 }
541
542 /* ***************************** Drivers ********************************* */
543
544 /* Driver API --------------------------------- */
545
546 /* This frees the driver itself */
547 void fcurve_free_driver(FCurve *fcu)
548 {
549         ChannelDriver *driver;
550         
551         /* sanity checks */
552         if ELEM(NULL, fcu, fcu->driver)
553                 return;
554         driver= fcu->driver;
555         
556         /* free RNA-paths, as these were allocated when getting the path string */
557         if (driver->rna_path) MEM_freeN(driver->rna_path);
558         if (driver->rna_path2) MEM_freeN(driver->rna_path2);
559         
560         /* free driver itself, then set F-Curve's point to this to NULL (as the curve may still be used) */
561         MEM_freeN(driver);
562         fcu->driver= NULL;
563 }
564
565 /* This makes a copy of the given driver */
566 ChannelDriver *fcurve_copy_driver (ChannelDriver *driver)
567 {
568         ChannelDriver *ndriver;
569         
570         /* sanity checks */
571         if (driver == NULL)
572                 return NULL;
573                 
574         /* copy all data */
575         ndriver= MEM_dupallocN(driver);
576         ndriver->rna_path= MEM_dupallocN(ndriver->rna_path);
577         ndriver->rna_path2= MEM_dupallocN(ndriver->rna_path2);
578         
579         /* return the new driver */
580         return ndriver;
581 }
582
583 /* Driver Evaluation -------------------------- */
584
585 /* Helper function to obtain a value using RNA from the specified source (for evaluating drivers) 
586  *      - target: used to specify which of the two driver-targets to use
587  */
588 static float driver_get_driver_value (ChannelDriver *driver, short target)
589 {
590         PointerRNA id_ptr, ptr;
591         PropertyRNA *prop;
592         ID *id;
593         char *path;
594         int index;
595         float value= 0.0f;
596         
597         /* get RNA-pointer for the ID-block given in driver */
598         if (target == 1) {
599                 /* second target */
600                 RNA_id_pointer_create(driver->id2, &id_ptr);
601                 id= driver->id2;
602                 path= driver->rna_path2;
603                 index= driver->array_index2;
604         }
605         else {
606                 /* first/main target */
607                 RNA_id_pointer_create(driver->id, &id_ptr);
608                 id= driver->id;
609                 path= driver->rna_path;
610                 index= driver->array_index;
611         }
612         
613         /* error check for missing pointer... */
614         if (id == NULL) {
615                 printf("Error: driver doesn't have any valid target to use \n");
616                 if (G.f & G_DEBUG) printf("\tpath = %s [%d] \n", path, index);
617                 driver->flag |= DRIVER_FLAG_INVALID;
618                 return 0.0f;
619         }
620         
621         /* get property to read from, and get value as appropriate */
622         if (RNA_path_resolve(&id_ptr, path, &ptr, &prop)) {
623                 switch (RNA_property_type(&ptr, prop)) {
624                         case PROP_BOOLEAN:
625                                 if (RNA_property_array_length(&ptr, prop))
626                                         value= (float)RNA_property_boolean_get_index(&ptr, prop, index);
627                                 else
628                                         value= (float)RNA_property_boolean_get(&ptr, prop);
629                                 break;
630                         case PROP_INT:
631                                 if (RNA_property_array_length(&ptr, prop))
632                                         value= (float)RNA_property_int_get_index(&ptr, prop, index);
633                                 else
634                                         value= (float)RNA_property_int_get(&ptr, prop);
635                                 break;
636                         case PROP_FLOAT:
637                                 if (RNA_property_array_length(&ptr, prop))
638                                         value= RNA_property_float_get_index(&ptr, prop, index);
639                                 else
640                                         value= RNA_property_float_get(&ptr, prop);
641                                 break;
642                         case PROP_ENUM:
643                                 value= (float)RNA_property_enum_get(&ptr, prop);
644                                 break;
645                         default:
646                                 break;
647                 }
648         }
649         
650         return value;
651 }
652
653 /* Evaluate an Channel-Driver to get a 'time' value to use instead of "evaltime"
654  *      - "evaltime" is the frame at which F-Curve is being evaluated
655  *      - has to return a float value 
656  */
657 static float evaluate_driver (ChannelDriver *driver, float evaltime)
658 {
659         /* check if driver can be evaluated */
660         if (driver->flag & DRIVER_FLAG_DISABLED)
661                 return 0.0f;
662         
663         switch (driver->type) {
664                 case DRIVER_TYPE_CHANNEL: /* channel/setting drivers channel/setting */
665                         return driver_get_driver_value(driver, 0);
666                         
667
668                 case DRIVER_TYPE_PYTHON: /* expression */
669                 {
670 #ifndef DISABLE_PYTHON
671                         /* check for empty or invalid expression */
672                         if ( (driver->expression[0] == '\0') ||
673                                  (driver->flag & DRIVER_FLAG_INVALID) )
674                         {
675                                 return 0.0f;
676                         }
677                         
678                         /* this evaluates the expression using Python,and returns its result:
679                          *      - on errors it reports, then returns 0.0f
680                          */
681                         return BPY_pydriver_eval(driver);
682 #endif /* DISABLE_PYTHON*/
683                 }
684                         break;
685
686                 
687                 case DRIVER_TYPE_ROTDIFF: /* difference of rotations of 2 bones (should be in same armature) */
688                 {
689                         /*
690                         float q1[4], q2[4], quat[4], angle;
691                         
692                         Mat4ToQuat(pchan->pose_mat, q1);
693                         Mat4ToQuat(pchan2->pose_mat, q2);
694                         
695                         QuatInv(q1);
696                         QuatMul(quat, q1, q2);
697                         angle = 2.0f * (saacos(quat[0]));
698                         angle= ABS(angle);
699                         
700                         return (angle > M_PI) ? (float)((2.0f * M_PI) - angle) : (float)(angle);
701                         */
702                 }
703                         break;
704                 
705                 default:
706                 {
707                         /* special 'hack' - just use stored value 
708                          *      This is currently used as the mechanism which allows animated settings to be able
709                          *      to be changed via the UI.
710                          */
711                         return driver->curval;
712                 }
713         }
714         
715         /* return 0.0f, as couldn't find relevant data to use */
716         return 0.0f;
717 }
718
719 /* ***************************** Curve Calculations ********************************* */
720
721 /* The total length of the handles is not allowed to be more
722  * than the horizontal distance between (v1-v4).
723  * This is to prevent curve loops.
724 */
725 void correct_bezpart (float *v1, float *v2, float *v3, float *v4)
726 {
727         float h1[2], h2[2], len1, len2, len, fac;
728         
729         /* calculate handle deltas */
730         h1[0]= v1[0] - v2[0];
731         h1[1]= v1[1] - v2[1];
732         
733         h2[0]= v4[0] - v3[0];
734         h2[1]= v4[1] - v3[1];
735         
736         /* calculate distances: 
737          *      - len   = span of time between keyframes 
738          *      - len1  = length of handle of start key
739          *      - len2  = length of handle of end key
740          */
741         len= v4[0]- v1[0];
742         len1= (float)fabs(h1[0]);
743         len2= (float)fabs(h2[0]);
744         
745         /* if the handles have no length, no need to do any corrections */
746         if ((len1+len2) == 0.0f) 
747                 return;
748                 
749         /* the two handles cross over each other, so force them
750          * apart using the proportion they overlap 
751          */
752         if ((len1+len2) > len) {
753                 fac= len / (len1+len2);
754                 
755                 v2[0]= (v1[0] - fac*h1[0]);
756                 v2[1]= (v1[1] - fac*h1[1]);
757                 
758                 v3[0]= (v4[0] - fac*h2[0]);
759                 v3[1]= (v4[1] - fac*h2[1]);
760         }
761 }
762
763 /* find root ('zero') */
764 int findzero (float x, float q0, float q1, float q2, float q3, float *o)
765 {
766         double c0, c1, c2, c3, a, b, c, p, q, d, t, phi;
767         int nr= 0;
768
769         c0= q0 - x;
770         c1= 3.0 * (q1 - q0);
771         c2= 3.0 * (q0 - 2.0*q1 + q2);
772         c3= q3 - q0 + 3.0 * (q1 - q2);
773         
774         if (c3 != 0.0) {
775                 a= c2/c3;
776                 b= c1/c3;
777                 c= c0/c3;
778                 a= a/3;
779                 
780                 p= b/3 - a*a;
781                 q= (2*a*a*a - a*b + c) / 2;
782                 d= q*q + p*p*p;
783                 
784                 if (d > 0.0) {
785                         t= sqrt(d);
786                         o[0]= (float)(Sqrt3d(-q+t) + Sqrt3d(-q-t) - a);
787                         
788                         if ((o[0] >= SMALL) && (o[0] <= 1.000001)) return 1;
789                         else return 0;
790                 }
791                 else if (d == 0.0) {
792                         t= Sqrt3d(-q);
793                         o[0]= (float)(2*t - a);
794                         
795                         if ((o[0] >= SMALL) && (o[0] <= 1.000001)) nr++;
796                         o[nr]= (float)(-t-a);
797                         
798                         if ((o[nr] >= SMALL) && (o[nr] <= 1.000001)) return nr+1;
799                         else return nr;
800                 }
801                 else {
802                         phi= acos(-q / sqrt(-(p*p*p)));
803                         t= sqrt(-p);
804                         p= cos(phi/3);
805                         q= sqrt(3 - 3*p*p);
806                         o[0]= (float)(2*t*p - a);
807                         
808                         if ((o[0] >= SMALL) && (o[0] <= 1.000001)) nr++;
809                         o[nr]= (float)(-t * (p + q) - a);
810                         
811                         if ((o[nr] >= SMALL) && (o[nr] <= 1.000001)) nr++;
812                         o[nr]= (float)(-t * (p - q) - a);
813                         
814                         if ((o[nr] >= SMALL) && (o[nr] <= 1.000001)) return nr+1;
815                         else return nr;
816                 }
817         }
818         else {
819                 a=c2;
820                 b=c1;
821                 c=c0;
822                 
823                 if (a != 0.0) {
824                         // discriminant
825                         p= b*b - 4*a*c;
826                         
827                         if (p > 0) {
828                                 p= sqrt(p);
829                                 o[0]= (float)((-b-p) / (2 * a));
830                                 
831                                 if ((o[0] >= SMALL) && (o[0] <= 1.000001)) nr++;
832                                 o[nr]= (float)((-b+p)/(2*a));
833                                 
834                                 if ((o[nr] >= SMALL) && (o[nr] <= 1.000001)) return nr+1;
835                                 else return nr;
836                         }
837                         else if (p == 0) {
838                                 o[0]= (float)(-b / (2 * a));
839                                 if ((o[0] >= SMALL) && (o[0] <= 1.000001)) return 1;
840                                 else return 0;
841                         }
842                 }
843                 else if (b != 0.0) {
844                         o[0]= (float)(-c/b);
845                         
846                         if ((o[0] >= SMALL) && (o[0] <= 1.000001)) return 1;
847                         else return 0;
848                 }
849                 else if (c == 0.0) {
850                         o[0]= 0.0;
851                         return 1;
852                 }
853                 
854                 return 0;       
855         }
856 }
857
858 void berekeny (float f1, float f2, float f3, float f4, float *o, int b)
859 {
860         float t, c0, c1, c2, c3;
861         int a;
862
863         c0= f1;
864         c1= 3.0f * (f2 - f1);
865         c2= 3.0f * (f1 - 2.0f*f2 + f3);
866         c3= f4 - f1 + 3.0f * (f2 - f3);
867         
868         for (a=0; a < b; a++) {
869                 t= o[a];
870                 o[a]= c0 + t*c1 + t*t*c2 + t*t*t*c3;
871         }
872 }
873
874 void berekenx (float *f, float *o, int b)
875 {
876         float t, c0, c1, c2, c3;
877         int a;
878
879         c0= f[0];
880         c1= 3.0f * (f[3] - f[0]);
881         c2= 3.0f * (f[0] - 2.0f*f[3] + f[6]);
882         c3= f[9] - f[0] + 3.0f * (f[3] - f[6]);
883         
884         for (a=0; a < b; a++) {
885                 t= o[a];
886                 o[a]= c0 + t*c1 + t*t*c2 + t*t*t*c3;
887         }
888 }
889
890
891 /* -------------------------- */
892
893 /* Calculate F-Curve value for 'evaltime' using BezTriple keyframes */
894 static float fcurve_eval_keyframes (FCurve *fcu, BezTriple *bezts, float evaltime)
895 {
896         BezTriple *bezt, *prevbezt, *lastbezt;
897         float v1[2], v2[2], v3[2], v4[2], opl[32], dx, fac;
898         int a, b;
899         float cvalue = 0.0f;
900         
901         /* get pointers */
902         a= fcu->totvert-1;
903         prevbezt= bezts;
904         bezt= prevbezt+1;
905         lastbezt= prevbezt + a;
906         
907         /* evaluation time at or past endpoints? */
908         if (prevbezt->vec[1][0] >= evaltime) {
909                 /* before or on first keyframe */
910                 if ((fcu->extend == FCURVE_EXTRAPOLATE_LINEAR) && (prevbezt->ipo != BEZT_IPO_CONST)) {
911                         /* linear or bezier interpolation */
912                         if (prevbezt->ipo==BEZT_IPO_LIN) {
913                                 /* Use the next center point instead of our own handle for
914                                  * linear interpolated extrapolate 
915                                  */
916                                 if (fcu->totvert == 1) 
917                                         cvalue= prevbezt->vec[1][1];
918                                 else {
919                                         bezt = prevbezt+1;
920                                         dx= prevbezt->vec[1][0] - evaltime;
921                                         fac= bezt->vec[1][0] - prevbezt->vec[1][0];
922                                         
923                                         /* prevent division by zero */
924                                         if (fac) {
925                                                 fac= (bezt->vec[1][1] - prevbezt->vec[1][1]) / fac;
926                                                 cvalue= prevbezt->vec[1][1] - (fac * dx);
927                                         }
928                                         else 
929                                                 cvalue= prevbezt->vec[1][1];
930                                 }
931                         } 
932                         else {
933                                 /* Use the first handle (earlier) of first BezTriple to calculate the
934                                  * gradient and thus the value of the curve at evaltime
935                                  */
936                                 dx= prevbezt->vec[1][0] - evaltime;
937                                 fac= prevbezt->vec[1][0] - prevbezt->vec[0][0];
938                                 
939                                 /* prevent division by zero */
940                                 if (fac) {
941                                         fac= (prevbezt->vec[1][1] - prevbezt->vec[0][1]) / fac;
942                                         cvalue= prevbezt->vec[1][1] - (fac * dx);
943                                 }
944                                 else 
945                                         cvalue= prevbezt->vec[1][1];
946                         }
947                 }
948                 else {
949                         /* constant (BEZT_IPO_HORIZ) extrapolation or constant interpolation, 
950                          * so just extend first keyframe's value 
951                          */
952                         cvalue= prevbezt->vec[1][1];
953                 }
954         }
955         else if (lastbezt->vec[1][0] <= evaltime) {
956                 /* after or on last keyframe */
957                 if ((fcu->extend == FCURVE_EXTRAPOLATE_LINEAR) && (lastbezt->ipo != BEZT_IPO_CONST)) {
958                         /* linear or bezier interpolation */
959                         if (lastbezt->ipo==BEZT_IPO_LIN) {
960                                 /* Use the next center point instead of our own handle for
961                                  * linear interpolated extrapolate 
962                                  */
963                                 if (fcu->totvert == 1) 
964                                         cvalue= lastbezt->vec[1][1];
965                                 else {
966                                         prevbezt = lastbezt - 1;
967                                         dx= evaltime - lastbezt->vec[1][0];
968                                         fac= lastbezt->vec[1][0] - prevbezt->vec[1][0];
969                                         
970                                         /* prevent division by zero */
971                                         if (fac) {
972                                                 fac= (lastbezt->vec[1][1] - prevbezt->vec[1][1]) / fac;
973                                                 cvalue= lastbezt->vec[1][1] + (fac * dx);
974                                         }
975                                         else 
976                                                 cvalue= lastbezt->vec[1][1];
977                                 }
978                         } 
979                         else {
980                                 /* Use the gradient of the second handle (later) of last BezTriple to calculate the
981                                  * gradient and thus the value of the curve at evaltime
982                                  */
983                                 dx= evaltime - lastbezt->vec[1][0];
984                                 fac= lastbezt->vec[2][0] - lastbezt->vec[1][0];
985                                 
986                                 /* prevent division by zero */
987                                 if (fac) {
988                                         fac= (lastbezt->vec[2][1] - lastbezt->vec[1][1]) / fac;
989                                         cvalue= lastbezt->vec[1][1] + (fac * dx);
990                                 }
991                                 else 
992                                         cvalue= lastbezt->vec[1][1];
993                         }
994                 }
995                 else {
996                         /* constant (BEZT_IPO_HORIZ) extrapolation or constant interpolation, 
997                          * so just extend last keyframe's value 
998                          */
999                         cvalue= lastbezt->vec[1][1];
1000                 }
1001         }
1002         else {
1003                 /* evaltime occurs somewhere in the middle of the curve */
1004                 for (a=0; prevbezt && bezt && (a < fcu->totvert-1); a++, prevbezt=bezt, bezt++) {  
1005                         /* evaltime occurs within the interval defined by these two keyframes */
1006                         if ((prevbezt->vec[1][0] <= evaltime) && (bezt->vec[1][0] >= evaltime)) {
1007                                 /* value depends on interpolation mode */
1008                                 if (prevbezt->ipo == BEZT_IPO_CONST) {
1009                                         /* constant (evaltime not relevant, so no interpolation needed) */
1010                                         cvalue= prevbezt->vec[1][1];
1011                                 }
1012                                 else if (prevbezt->ipo == BEZT_IPO_LIN) {
1013                                         /* linear - interpolate between values of the two keyframes */
1014                                         fac= bezt->vec[1][0] - prevbezt->vec[1][0];
1015                                         
1016                                         /* prevent division by zero */
1017                                         if (fac) {
1018                                                 fac= (evaltime - prevbezt->vec[1][0]) / fac;
1019                                                 cvalue= prevbezt->vec[1][1] + (fac * (bezt->vec[1][1] - prevbezt->vec[1][1]));
1020                                         }
1021                                         else
1022                                                 cvalue= prevbezt->vec[1][1];
1023                                 }
1024                                 else {
1025                                         /* bezier interpolation */
1026                                                 /* v1,v2 are the first keyframe and its 2nd handle */
1027                                         v1[0]= prevbezt->vec[1][0];
1028                                         v1[1]= prevbezt->vec[1][1];
1029                                         v2[0]= prevbezt->vec[2][0];
1030                                         v2[1]= prevbezt->vec[2][1];
1031                                                 /* v3,v4 are the last keyframe's 1st handle + the last keyframe */
1032                                         v3[0]= bezt->vec[0][0];
1033                                         v3[1]= bezt->vec[0][1];
1034                                         v4[0]= bezt->vec[1][0];
1035                                         v4[1]= bezt->vec[1][1];
1036                                         
1037                                         /* adjust handles so that they don't overlap (forming a loop) */
1038                                         correct_bezpart(v1, v2, v3, v4);
1039                                         
1040                                         /* try to get a value for this position - if failure, try another set of points */
1041                                         b= findzero(evaltime, v1[0], v2[0], v3[0], v4[0], opl);
1042                                         if (b) {
1043                                                 berekeny(v1[1], v2[1], v3[1], v4[1], opl, 1);
1044                                                 cvalue= opl[0];
1045                                                 break;
1046                                         }
1047                                 }
1048                         }
1049                 }
1050         }
1051         
1052         /* return value */
1053         return cvalue;
1054 }
1055
1056 /* Calculate F-Curve value for 'evaltime' using FPoint samples */
1057 static float fcurve_eval_samples (FCurve *fcu, FPoint *fpts, float evaltime)
1058 {
1059         FPoint *prevfpt, *lastfpt, *fpt;
1060         float cvalue= 0.0f;
1061         
1062         /* get pointers */
1063         prevfpt= fpts;
1064         lastfpt= prevfpt + fcu->totvert-1;
1065         
1066         /* evaluation time at or past endpoints? */
1067         if (prevfpt->vec[0] >= evaltime) {
1068                 /* before or on first sample, so just extend value */
1069                 cvalue= prevfpt->vec[1];
1070         }
1071         else if (lastfpt->vec[0] <= evaltime) {
1072                 /* after or on last sample, so just extend value */
1073                 cvalue= lastfpt->vec[1];
1074         }
1075         else {
1076                 /* find the one on the right frame (assume that these are spaced on 1-frame intervals) */
1077                 fpt= prevfpt + (int)(evaltime - prevfpt->vec[0]);
1078                 cvalue= fpt->vec[1];
1079         }
1080         
1081         /* return value */
1082         return cvalue;
1083 }
1084
1085 /* ******************************** F-Curve Modifiers ********************************* */
1086
1087 /* Template --------------------------- */
1088
1089 /* Each modifier defines a set of functions, which will be called at the appropriate
1090  * times. In addition to this, each modifier should have a type-info struct, where
1091  * its functions are attached for use. 
1092  */
1093  
1094 /* Template for type-info data:
1095  *      - make a copy of this when creating new modifiers, and just change the functions
1096  *        pointed to as necessary
1097  *      - although the naming of functions doesn't matter, it would help for code
1098  *        readability, to follow the same naming convention as is presented here
1099  *      - any functions that a constraint doesn't need to define, don't define
1100  *        for such cases, just use NULL 
1101  *      - these should be defined after all the functions have been defined, so that
1102  *        forward-definitions/prototypes don't need to be used!
1103  *      - keep this copy #if-def'd so that future constraints can get based off this
1104  */
1105 #if 0
1106 static FModifierTypeInfo FMI_MODNAME = {
1107         FMODIFIER_TYPE_MODNAME, /* type */
1108         sizeof(FMod_ModName), /* size */
1109         FMI_TYPE_SOME_ACTION, /* action type */
1110         FMI_REQUIRES_SOME_REQUIREMENT, /* requirements */
1111         "Modifier Name", /* name */
1112         "FMod_ModName", /* struct name */
1113         fcm_modname_free, /* free data */
1114         fcm_modname_relink, /* relink data */
1115         fcm_modname_copy, /* copy data */
1116         fcm_modname_new_data, /* new data */
1117         fcm_modname_verify, /* verify */
1118         fcm_modname_evaluate /* evaluate */
1119 };
1120 #endif
1121
1122 /* Generator F-Curve Modifier --------------------------- */
1123
1124 /* Generators available:
1125  *      1) simple polynomial generator:
1126  *              - Exanded form - (y = C[0]*(x^(n)) + C[1]*(x^(n-1)) + ... + C[n])  
1127  *              - Factorised form - (y = (C[0][0]*x + C[0][1]) * (C[1][0]*x + C[1][1]) * ... * (C[n][0]*x + C[n][1]))
1128  *      2) simple builin 'functions':
1129  *              of the form (y = C[0] * fn( C[1]*x + C[2] ) + C[3])
1130  *         where fn() can be any one of:
1131  *              sin, cos, tan, ln, sqrt
1132  *      3) expression...
1133  */
1134
1135 static void fcm_generator_free (FModifier *fcm)
1136 {
1137         FMod_Generator *data= (FMod_Generator *)fcm->data;
1138         
1139         /* free polynomial coefficients array */
1140         if (data->coefficients)
1141                 MEM_freeN(data->coefficients);
1142 }
1143
1144 static void fcm_generator_copy (FModifier *fcm, FModifier *src)
1145 {
1146         FMod_Generator *gen= (FMod_Generator *)fcm->data;
1147         FMod_Generator *ogen= (FMod_Generator *)src->data;
1148         
1149         /* copy coefficients array? */
1150         if (ogen->coefficients)
1151                 gen->coefficients= MEM_dupallocN(ogen->coefficients);
1152 }
1153
1154 static void fcm_generator_new_data (void *mdata)
1155 {
1156         FMod_Generator *data= (FMod_Generator *)mdata;
1157         float *cp;
1158         
1159         /* set default generator to be linear 0-1 (gradient = 1, y-offset = 0) */
1160         data->poly_order= 1;
1161         data->arraysize= 2;
1162         cp= data->coefficients= MEM_callocN(sizeof(float)*2, "FMod_Generator_Coefs");
1163         cp[0] = 0; // y-offset 
1164         cp[1] = 1; // gradient
1165 }
1166
1167 static void fcm_generator_verify (FModifier *fcm)
1168 {
1169         FMod_Generator *data= (FMod_Generator *)fcm->data;
1170         
1171         /* requirements depend on mode */
1172         switch (data->mode) {
1173                 case FCM_GENERATOR_POLYNOMIAL: /* expanded polynomial expression */
1174                 {
1175                         /* arraysize needs to be order+1, so resize if not */
1176                         if (data->arraysize != (data->poly_order+1)) {
1177                                 float *nc;
1178                                 
1179                                 /* make new coefficients array, and copy over as much data as can fit */
1180                                 nc= MEM_callocN(sizeof(float)*(data->poly_order+1), "FMod_Generator_Coefs");
1181                                 
1182                                 if (data->coefficients) {
1183                                         if (data->arraysize > (data->poly_order+1))
1184                                                 memcpy(nc, data->coefficients, sizeof(float)*(data->poly_order+1));
1185                                         else
1186                                                 memcpy(nc, data->coefficients, sizeof(float)*data->arraysize);
1187                                 }       
1188                                 
1189                                 /* free the old data, and set the new */
1190                                 if (data->coefficients) MEM_freeN(data->coefficients);
1191                                 
1192                                 data->coefficients= nc;
1193                                 data->arraysize= data->poly_order+1;
1194                         }
1195                 }
1196                         break;
1197                 
1198                 // FIXME: add checks for all others             
1199                 case FCM_GENERATOR_POLYNOMIAL_FACTORISED: /* expanded polynomial expression */
1200                 {
1201                         
1202                 }
1203                         break;
1204         }
1205 }
1206
1207 static void fcm_generator_evaluate (FCurve *fcu, FModifier *fcm, float *cvalue, float evaltime)
1208 {
1209         FMod_Generator *data= (FMod_Generator *)fcm->data;
1210         
1211         /* behaviour depends on mode 
1212          * NOTE: the data in its default state is fine too
1213          */
1214         switch (data->mode) {
1215                 case FCM_GENERATOR_POLYNOMIAL: /* expanded polynomial expression */
1216                 {
1217                         /* we overwrite cvalue with the sum of the polynomial */
1218                         float *powers = MEM_callocN(sizeof(float)*data->arraysize, "Poly Powers");
1219                         float value= 0.0f;
1220                         unsigned int i;
1221                         
1222                         /* for each x^n, precalculate value based on previous one first... this should be 
1223                          * faster that calling pow() for each entry
1224                          */
1225                         for (i=0; i < data->arraysize; i++) {
1226                                 /* first entry is x^0 = 1, otherwise, calculate based on previous */
1227                                 if (i)
1228                                         powers[i]= powers[i-1] * evaltime;
1229                                 else
1230                                         powers[0]= 1;
1231                         }
1232                         
1233                         /* for each coefficient, add to value, which we'll write to *cvalue in one go */
1234                         for (i=0; i < data->arraysize; i++)
1235                                 value += data->coefficients[i] * powers[i];
1236                         
1237                         /* only if something changed, write *cvalue in one go */
1238                         if (data->poly_order)
1239                                 *cvalue= value;
1240                                 
1241                         /* cleanup */
1242                         if (powers) 
1243                                 MEM_freeN(powers);
1244                 }
1245                         break;
1246                         
1247                 case FCM_GENERATOR_POLYNOMIAL_FACTORISED: /* factorised polynomial */
1248                 {
1249                         float value= 1.0f, *cp=NULL;
1250                         unsigned int i;
1251                         
1252                         /* for each coefficient pair, solve for that bracket before accumulating in value by multiplying */
1253                         for (cp=data->coefficients, i=0; (cp) && (i < data->poly_order); cp+=2, i++) 
1254                                 value *= (cp[0]*evaltime + cp[1]);
1255                                 
1256                         /* only if something changed, write *cvalue in one go */
1257                         if (data->poly_order)
1258                                 *cvalue= value;
1259                 }
1260                         break;
1261                         
1262                 case FCM_GENERATOR_FUNCTION: /* builtin function */
1263                 {
1264                         double arg= data->coefficients[1]*evaltime + data->coefficients[2];
1265                         double (*fn)(double v) = NULL;
1266                         
1267                         /* get function pointer to the func to use:
1268                          * WARNING: must perform special argument validation hereto guard against crashes  
1269                          */
1270                         switch (data->func_type)
1271                         {
1272                                 /* simple ones */                       
1273                                 case FCM_GENERATOR_FN_SIN: /* sine wave */
1274                                         fn= sin;
1275                                         break;
1276                                 case FCM_GENERATOR_FN_COS: /* cosine wave */
1277                                         fn= cos;
1278                                         break;
1279                                         
1280                                 /* validation required */
1281                                 case FCM_GENERATOR_FN_TAN: /* tangent wave */
1282                                 {
1283                                         /* check that argument is not on one of the discontinuities (i.e. 90deg, 270 deg, etc) */
1284                                         if IS_EQ(fmod((arg - M_PI_2), M_PI), 0.0)
1285                                                 *cvalue= 0.0f; /* no value possible here */
1286                                         else
1287                                                 fn= tan;
1288                                 }
1289                                         break;
1290                                 case FCM_GENERATOR_FN_LN: /* natural log */
1291                                 {
1292                                         /* check that value is greater than 1? */
1293                                         if (arg > 1.0f)
1294                                                 fn= log;
1295                                         else
1296                                                 *cvalue= 0.0f; /* no value possible here */
1297                                 }
1298                                         break;
1299                                 case FCM_GENERATOR_FN_SQRT: /* square root */
1300                                 {
1301                                         /* no negative numbers */
1302                                         if (arg > 0.0f)
1303                                                 fn= sqrt;
1304                                         else
1305                                                 *cvalue= 0.0f; /* no vlaue possible here */
1306                                 }
1307                                         break;
1308                                         
1309                                 default:
1310                                         printf("Invalid Function-Generator for F-Modifier - %d \n", data->func_type);
1311                         }
1312                         
1313                         /* execute function callback to set value if appropriate */
1314                         if (fn)
1315                                 *cvalue= data->coefficients[0]*fn(arg) + data->coefficients[3];
1316                 }
1317                         break;
1318
1319 #ifndef DISABLE_PYTHON
1320                 case FCM_GENERATOR_EXPRESSION: /* py-expression */
1321                         // TODO...
1322                         break;
1323 #endif /* DISABLE_PYTHON */
1324         }
1325 }
1326
1327 static FModifierTypeInfo FMI_GENERATOR = {
1328         FMODIFIER_TYPE_GENERATOR, /* type */
1329         sizeof(FMod_Generator), /* size */
1330         FMI_TYPE_GENERATE_CURVE, /* action type */
1331         FMI_REQUIRES_NOTHING, /* requirements */
1332         "Generator", /* name */
1333         "FMod_Generator", /* struct name */
1334         fcm_generator_free, /* free data */
1335         fcm_generator_copy, /* copy data */
1336         fcm_generator_new_data, /* new data */
1337         fcm_generator_verify, /* verify */
1338         fcm_generator_evaluate /* evaluate */
1339 };
1340
1341 /* Envelope F-Curve Modifier --------------------------- */
1342
1343 static void fcm_envelope_free (FModifier *fcm)
1344 {
1345         FMod_Envelope *data= (FMod_Envelope *)fcm->data;
1346         
1347         /* free envelope data array */
1348         if (data->data)
1349                 MEM_freeN(data->data);
1350 }
1351
1352 static void fcm_envelope_copy (FModifier *fcm, FModifier *src)
1353 {
1354         FMod_Envelope *gen= (FMod_Envelope *)fcm->data;
1355         FMod_Envelope *ogen= (FMod_Envelope *)src->data;
1356         
1357         /* copy envelope data array */
1358         if (ogen->data)
1359                 gen->data= MEM_dupallocN(ogen->data);
1360 }
1361
1362 static void fcm_envelope_evaluate (FCurve *fcu, FModifier *fcm, float *cvalue, float evaltime)
1363 {
1364         FMod_Envelope *env= (FMod_Envelope *)fcm->data;
1365         FCM_EnvelopeData *fed, *prevfed, *lastfed;
1366         float min=0.0f, max=0.0f, fac=0.0f;
1367         int a;
1368         
1369         /* get pointers */
1370         if (env->data == NULL) return;
1371         prevfed= env->data;
1372         fed= prevfed + 1;
1373         lastfed= prevfed + env->totvert-1;
1374         
1375         /* get min/max values for envelope at evaluation time (relative to mid-value) */
1376         if (prevfed->time >= evaltime) {
1377                 /* before or on first sample, so just extend value */
1378                 min= prevfed->min;
1379                 max= prevfed->max;
1380         }
1381         else if (lastfed->time <= evaltime) {
1382                 /* after or on last sample, so just extend value */
1383                 min= lastfed->min;
1384                 max= lastfed->max;
1385         }
1386         else {
1387                 /* evaltime occurs somewhere between segments */
1388                 for (a=0; prevfed && fed && (a < env->totvert-1); a++, prevfed=fed, fed++) {  
1389                         /* evaltime occurs within the interval defined by these two envelope points */
1390                         if ((prevfed->time <= evaltime) && (fed->time >= evaltime)) {
1391                                 float afac, bfac, diff;
1392                                 
1393                                 diff= fed->time - prevfed->time;
1394                                 afac= (evaltime - prevfed->time) / diff;
1395                                 bfac= (fed->time - evaltime)/(diff);
1396                                 
1397                                 min= afac*prevfed->min + bfac*fed->min;
1398                                 max= afac*prevfed->max + bfac*fed->max;
1399                                 
1400                                 break;
1401                         }
1402                 }
1403         }
1404         
1405         /* adjust *cvalue 
1406          * NOTE: env->min/max are relative to env->midval, and can be either +ve OR -ve, so we add...
1407          */
1408         fac= (*cvalue - min) / (max - min);
1409         *cvalue= (env->midval + env->min) + (fac * (env->max - env->min)); 
1410 }
1411
1412 static FModifierTypeInfo FMI_ENVELOPE = {
1413         FMODIFIER_TYPE_ENVELOPE, /* type */
1414         sizeof(FMod_Envelope), /* size */
1415         FMI_TYPE_REPLACE_VALUES, /* action type */
1416         0, /* requirements */
1417         "Envelope", /* name */
1418         "FMod_Envelope", /* struct name */
1419         fcm_envelope_free, /* free data */
1420         fcm_envelope_copy, /* copy data */
1421         NULL, /* new data */
1422         NULL /*fcm_envelope_verify*/, /* verify */
1423         fcm_envelope_evaluate /* evaluate */
1424 };
1425
1426 /* Cycles F-Curve Modifier  --------------------------- */
1427
1428 /* This modifier changes evaltime to something that exists within the curve's frame-range, 
1429  * then re-evaluates modifier stack up to this point using the new time. This re-entrant behaviour
1430  * is very likely to be more time-consuming than the original approach... (which was tighly integrated into 
1431  * the calculation code...).
1432  *
1433  * NOTE: this needs to be at the start of the stack to be of use, as it needs to know the extents of the keyframes/sample-data
1434  * Possible TODO - store length of cycle information that can be initialised from the extents of the keyframes/sample-data, and adjusted
1435  *                              as appropriate
1436  */
1437
1438 static void fcm_cycles_evaluate (FCurve *fcu, FModifier *fcm, float *cvalue, float evaltime)
1439 {
1440         FMod_Cycles *data= (FMod_Cycles *)fcm->data;
1441         ListBase mods = {NULL, NULL};
1442         float prevkey[2], lastkey[2], cycyofs=0.0f;
1443         float new_value;
1444         short side=0, mode=0;
1445         int cycles=0;
1446         
1447         /* check if modifier is first in stack, otherwise disable ourself... */
1448         // FIXME...
1449         if (fcm->prev) {
1450                 fcm->flag |= FMODIFIER_FLAG_DISABLED;
1451                 return;
1452         }
1453         
1454         /* calculate new evaltime due to cyclic interpolation */
1455         if (fcu && fcu->bezt) {
1456                 BezTriple *prevbezt= fcu->bezt;
1457                 BezTriple *lastbezt= prevbezt + fcu->totvert-1;
1458                 
1459                 prevkey[0]= prevbezt->vec[1][0];
1460                 prevkey[1]= prevbezt->vec[1][1];
1461                 
1462                 lastkey[0]= lastbezt->vec[1][0];
1463                 lastkey[1]= lastbezt->vec[1][1];
1464         }
1465         else if (fcu && fcu->fpt) {
1466                 FPoint *prevfpt= fcu->fpt;
1467                 FPoint *lastfpt= prevfpt + fcu->totvert-1;
1468                 
1469                 prevkey[0]= prevfpt->vec[0];
1470                 prevkey[1]= prevfpt->vec[1];
1471                 
1472                 lastkey[0]= lastfpt->vec[0];
1473                 lastkey[1]= lastfpt->vec[1];
1474         }
1475         else
1476                 return;
1477                 
1478         /* check if modifier will do anything
1479          *      1) if in data range, definitely don't do anything
1480          *      2) if before first frame or after last frame, make sure some cycling is in use
1481          */
1482         if (evaltime < prevkey[0]) {
1483                 if (data->before_mode) {
1484                         side= -1;
1485                         mode= data->before_mode;
1486                         cycles= data->before_cycles;
1487                 }
1488         }
1489         else if (evaltime > lastkey[0]) {
1490                 if (data->after_mode) {
1491                         side= 1;
1492                         mode= data->after_mode;
1493                         cycles= data->after_cycles;
1494                 }
1495         }
1496         if ELEM(0, side, mode)
1497                 return;
1498                 
1499         /* extrapolation mode is 'cyclic' - find relative place within a cycle */
1500         // FIXME: adding the more fine-grained control of extrpolation mode
1501         {
1502                 float cycdx=0, cycdy=0, ofs=0;
1503                 
1504                 /* ofs is start frame of cycle */
1505                 ofs= prevkey[0];
1506                 
1507                 /* calculate period and amplitude (total height) of a cycle */
1508                 cycdx= lastkey[0] - prevkey[0];
1509                 cycdy= lastkey[1] - prevkey[1];
1510                 
1511                 /* check if cycle is infinitely small, to be point of being impossible to use */
1512                 if (cycdx == 0)
1513                         return;
1514                 /* check that cyclic is still enabled for the specified time */
1515                 if (cycles == 0) {
1516                         /* catch this case so that we don't exit when we have cycles=0
1517                          * as this indicates infinite cycles...
1518                          */
1519                 }
1520                 else if ( ((float)side * (evaltime - ofs) / cycdx) > cycles )
1521                         return;
1522                 
1523                 
1524                 /* check if 'cyclic extrapolation', and thus calculate y-offset for this cycle */
1525                 if (mode == FCM_EXTRAPOLATE_CYCLIC_OFFSET) {
1526                         cycyofs = (float)floor((evaltime - ofs) / cycdx);
1527                         cycyofs *= cycdy;
1528                 }
1529                 
1530                 /* calculate where in the cycle we are (overwrite evaltime to reflect this) */
1531                 evaltime= (float)(fmod(evaltime-ofs, cycdx) + ofs);
1532                 if (evaltime < ofs) evaltime += cycdx;
1533         }
1534         
1535         
1536         /* store modifiers after (and including ourself) before recalculating curve with new evaltime */
1537         mods= fcu->modifiers;
1538         fcu->modifiers.first= fcu->modifiers.last= NULL;
1539         
1540         /* re-enter the evaluation loop (but without the burden of evaluating any modifiers, so 'should' be relatively quick) */
1541         new_value= evaluate_fcurve(fcu, evaltime);
1542         
1543         /* restore modifiers, and set new value (don't assume everything is still ok after being re-entrant) */
1544         fcu->modifiers= mods;
1545         *cvalue= new_value + cycyofs;
1546 }
1547
1548 static FModifierTypeInfo FMI_CYCLES = {
1549         FMODIFIER_TYPE_CYCLES, /* type */
1550         sizeof(FMod_Cycles), /* size */
1551         FMI_TYPE_EXTRAPOLATION, /* action type */
1552         FMI_REQUIRES_ORIGINAL_DATA, /* requirements */
1553         "Cycles", /* name */
1554         "FMod_Cycles", /* struct name */
1555         NULL, /* free data */
1556         NULL, /* copy data */
1557         NULL, /* new data */
1558         NULL /*fcm_cycles_verify*/, /* verify */
1559         fcm_cycles_evaluate /* evaluate */
1560 };
1561
1562 /* Noise F-Curve Modifier  --------------------------- */
1563
1564 #if 0 // XXX not yet implemented 
1565 static FModifierTypeInfo FMI_NOISE = {
1566         FMODIFIER_TYPE_NOISE, /* type */
1567         sizeof(FMod_Noise), /* size */
1568         FMI_TYPE_REPLACE_VALUES, /* action type */
1569         0, /* requirements */
1570         "Noise", /* name */
1571         "FMod_Noise", /* struct name */
1572         NULL, /* free data */
1573         NULL, /* copy data */
1574         fcm_noise_new_data, /* new data */
1575         NULL /*fcm_noise_verify*/, /* verify */
1576         fcm_noise_evaluate /* evaluate */
1577 };
1578 #endif // XXX not yet implemented
1579
1580 /* Filter F-Curve Modifier --------------------------- */
1581
1582 #if 0 // XXX not yet implemented 
1583 static FModifierTypeInfo FMI_FILTER = {
1584         FMODIFIER_TYPE_FILTER, /* type */
1585         sizeof(FMod_Filter), /* size */
1586         FMI_TYPE_REPLACE_VALUES, /* action type */
1587         0, /* requirements */
1588         "Filter", /* name */
1589         "FMod_Filter", /* struct name */
1590         NULL, /* free data */
1591         NULL, /* copy data */
1592         NULL, /* new data */
1593         NULL /*fcm_filter_verify*/, /* verify */
1594         fcm_filter_evaluate /* evaluate */
1595 };
1596 #endif // XXX not yet implemented
1597
1598
1599 /* Python F-Curve Modifier --------------------------- */
1600
1601 static void fcm_python_free (FModifier *fcm)
1602 {
1603         FMod_Python *data= (FMod_Python *)fcm->data;
1604         
1605         /* id-properties */
1606         IDP_FreeProperty(data->prop);
1607         MEM_freeN(data->prop);
1608 }
1609
1610 static void fcm_python_new_data (void *mdata) 
1611 {
1612         FMod_Python *data= (FMod_Python *)mdata;
1613         
1614         /* everything should be set correctly by calloc, except for the prop->type constant.*/
1615         data->prop = MEM_callocN(sizeof(IDProperty), "PyFModifierProps");
1616         data->prop->type = IDP_GROUP;
1617 }
1618
1619 static void fcm_python_copy (FModifier *fcm, FModifier *src)
1620 {
1621         FMod_Python *pymod = (FMod_Python *)fcm->data;
1622         FMod_Python *opymod = (FMod_Python *)src->data;
1623         
1624         pymod->prop = IDP_CopyProperty(opymod->prop);
1625 }
1626
1627 static void fcm_python_evaluate (FCurve *fcu, FModifier *fcm, float *cvalue, float evaltime)
1628 {
1629 #ifndef DISABLE_PYTHON
1630         //FMod_Python *data= (FMod_Python *)fcm->data;
1631         
1632         /* FIXME... need to implement this modifier...
1633          *      It will need it execute a script using the custom properties 
1634          */
1635 #endif /* DISABLE_PYTHON */
1636 }
1637
1638 static FModifierTypeInfo FMI_PYTHON = {
1639         FMODIFIER_TYPE_PYTHON, /* type */
1640         sizeof(FMod_Python), /* size */
1641         FMI_TYPE_GENERATE_CURVE, /* action type */
1642         FMI_REQUIRES_RUNTIME_CHECK, /* requirements */
1643         "Python", /* name */
1644         "FMod_Python", /* struct name */
1645         fcm_python_free, /* free data */
1646         fcm_python_copy, /* copy data */
1647         fcm_python_new_data, /* new data */
1648         NULL /*fcm_python_verify*/, /* verify */
1649         fcm_python_evaluate /* evaluate */
1650 };
1651
1652
1653 /* F-Curve Modifier API --------------------------- */
1654 /* All of the F-Curve Modifier api functions use FModifierTypeInfo structs to carry out
1655  * and operations that involve F-Curve modifier specifc code.
1656  */
1657
1658 /* These globals only ever get directly accessed in this file */
1659 static FModifierTypeInfo *fmodifiersTypeInfo[FMODIFIER_NUM_TYPES];
1660 static short FMI_INIT= 1; /* when non-zero, the list needs to be updated */
1661
1662 /* This function only gets called when FMI_INIT is non-zero */
1663 static void fmods_init_typeinfo () 
1664 {
1665         fmodifiersTypeInfo[0]=  NULL;                                   /* 'Null' F-Curve Modifier */
1666         fmodifiersTypeInfo[1]=  &FMI_GENERATOR;                 /* Generator F-Curve Modifier */
1667         fmodifiersTypeInfo[2]=  &FMI_ENVELOPE;                  /* Envelope F-Curve Modifier */
1668         fmodifiersTypeInfo[3]=  &FMI_CYCLES;                    /* Cycles F-Curve Modifier */
1669         fmodifiersTypeInfo[4]=  NULL/*&FMI_NOISE*/;                             /* Apply-Noise F-Curve Modifier */ // XXX unimplemented
1670         fmodifiersTypeInfo[5]=  NULL/*&FMI_FILTER*/;                    /* Filter F-Curve Modifier */  // XXX unimplemented
1671         fmodifiersTypeInfo[6]=  &FMI_PYTHON;                    /* Custom Python F-Curve Modifier */
1672 }
1673
1674 /* This function should be used for getting the appropriate type-info when only
1675  * a F-Curve modifier type is known
1676  */
1677 FModifierTypeInfo *get_fmodifier_typeinfo (int type)
1678 {
1679         /* initialise the type-info list? */
1680         if (FMI_INIT) {
1681                 fmods_init_typeinfo();
1682                 FMI_INIT = 0;
1683         }
1684         
1685         /* only return for valid types */
1686         if ( (type >= FMODIFIER_TYPE_NULL) && 
1687                  (type <= FMODIFIER_NUM_TYPES ) ) 
1688         {
1689                 /* there shouldn't be any segfaults here... */
1690                 return fmodifiersTypeInfo[type];
1691         }
1692         else {
1693                 printf("No valid F-Curve Modifier type-info data available. Type = %i \n", type);
1694         }
1695         
1696         return NULL;
1697
1698  
1699 /* This function should always be used to get the appropriate type-info, as it
1700  * has checks which prevent segfaults in some weird cases.
1701  */
1702 FModifierTypeInfo *fmodifier_get_typeinfo (FModifier *fcm)
1703 {
1704         /* only return typeinfo for valid modifiers */
1705         if (fcm)
1706                 return get_fmodifier_typeinfo(fcm->type);
1707         else
1708                 return NULL;
1709 }
1710
1711 /* API --------------------------- */
1712
1713 /* Add a new F-Curve Modifier to the given F-Curve of a certain type */
1714 FModifier *fcurve_add_modifier (FCurve *fcu, int type)
1715 {
1716         FModifierTypeInfo *fmi= get_fmodifier_typeinfo(type);
1717         FModifier *fcm;
1718         
1719         /* sanity checks */
1720         if ELEM(NULL, fcu, fmi)
1721                 return NULL;
1722         
1723         /* special checks for whether modifier can be added */
1724         if ((fcu->modifiers.first) && (type == FMODIFIER_TYPE_CYCLES)) {
1725                 /* cycles modifier must be first in stack, so for now, don't add if it can't be */
1726                 // TODO: perhaps there is some better way, but for now, 
1727                 printf("Error: Cannot add 'Cycles' modifier to F-Curve, as 'Cycles' modifier can only be first in stack. \n");
1728                 return NULL;
1729         }
1730         
1731         /* add modifier itself */
1732         fcm= MEM_callocN(sizeof(FModifier), "F-Curve Modifier");
1733         fcm->type = type;
1734         fcm->flag = FMODIFIER_FLAG_EXPANDED;
1735         BLI_addtail(&fcu->modifiers, fcm);
1736         
1737         /* add modifier's data */
1738         fcm->data= MEM_callocN(fmi->size, fmi->structName);
1739                 
1740         /* init custom settings if necessary */
1741         if (fmi->new_data)      
1742                 fmi->new_data(fcm->data);
1743                 
1744         /* return modifier for further editing */
1745         return fcm;
1746 }
1747
1748 /* Duplicate all of the F-Curve Modifiers in the Modifier stacks */
1749 void fcurve_copy_modifiers (ListBase *dst, ListBase *src)
1750 {
1751         FModifier *fcm, *srcfcm;
1752         
1753         if ELEM(NULL, dst, src)
1754                 return;
1755         
1756         dst->first= dst->last= NULL;
1757         BLI_duplicatelist(dst, src);
1758         
1759         for (fcm=dst->first, srcfcm=src->first; fcm && srcfcm; srcfcm=srcfcm->next, fcm=fcm->next) {
1760                 FModifierTypeInfo *fmi= fmodifier_get_typeinfo(fcm);
1761                 
1762                 /* make a new copy of the F-Modifier's data */
1763                 fcm->data = MEM_dupallocN(fcm->data);
1764                 
1765                 /* only do specific constraints if required */
1766                 if (fmi && fmi->copy_data)
1767                         fmi->copy_data(fcm, srcfcm);
1768         }
1769 }
1770
1771 /* Remove and free the given F-Curve Modifier from the given F-Curve's stack  */
1772 void fcurve_remove_modifier (FCurve *fcu, FModifier *fcm)
1773 {
1774         FModifierTypeInfo *fmi= fmodifier_get_typeinfo(fcm);
1775         
1776         /* sanity check */
1777         if (fcm == NULL)
1778                 return;
1779         
1780         /* free modifier's special data (stored inside fcm->data) */
1781         if (fmi && fmi->free_data)
1782                 fmi->free_data(fcm);
1783                 
1784         /* free modifier's data (fcm->data) */
1785         MEM_freeN(fcm->data);
1786         
1787         /* remove modifier from stack */
1788         if (fcu)
1789                 BLI_freelinkN(&fcu->modifiers, fcm);
1790         else {
1791                 // XXX this case can probably be removed some day, as it shouldn't happen...
1792                 printf("fcurve_remove_modifier() - no fcurve \n");
1793                 MEM_freeN(fcm);
1794         }
1795 }
1796
1797 /* Remove all of a given F-Curve's modifiers */
1798 void fcurve_free_modifiers (FCurve *fcu)
1799 {
1800         FModifier *fcm, *fmn;
1801         
1802         /* sanity check */
1803         if (fcu == NULL)
1804                 return;
1805         
1806         /* free each modifier in order - modifier is unlinked from list and freed */
1807         for (fcm= fcu->modifiers.first; fcm; fcm= fmn) {
1808                 fmn= fcm->next;
1809                 fcurve_remove_modifier(fcu, fcm);
1810         }
1811 }
1812
1813 /* Bake modifiers for given F-Curve to curve sample data, in the frame range defined
1814  * by start and end (inclusive).
1815  */
1816 void fcurve_bake_modifiers (FCurve *fcu, int start, int end)
1817 {
1818         ChannelDriver *driver;
1819         
1820         /* sanity checks */
1821         // TODO: make these tests report errors using reports not printf's
1822         if ELEM(NULL, fcu, fcu->modifiers.first) {
1823                 printf("Error: No F-Curve with F-Curve Modifiers to Bake\n");
1824                 return;
1825         }
1826         
1827         /* temporarily, disable driver while we sample, so that they don't influence the outcome */
1828         driver= fcu->driver;
1829         fcu->driver= NULL;
1830         
1831         /* bake the modifiers, by sampling the curve at each frame */
1832         fcurve_store_samples(fcu, NULL, start, end, fcurve_samplingcb_evalcurve);
1833         
1834         /* free the modifiers now */
1835         fcurve_free_modifiers(fcu);
1836         
1837         /* restore driver */
1838         fcu->driver= driver;
1839 }
1840
1841 /* Find the active F-Curve Modifier */
1842 FModifier *fcurve_active_modifier (FCurve *fcu)
1843 {
1844         FModifier *fcm;
1845         
1846         /* sanity checks */
1847         if ELEM(NULL, fcu, fcu->modifiers.first)
1848                 return NULL;
1849         
1850         /* loop over modifiers until 'active' one is found */
1851         for (fcm= fcu->modifiers.first; fcm; fcm= fcm->next) {
1852                 if (fcm->flag & FMODIFIER_FLAG_ACTIVE)
1853                         return fcm;
1854         }
1855         
1856         /* no modifier is active */
1857         return NULL;
1858 }
1859
1860 /* ***************************** F-Curve - Evaluation ********************************* */
1861
1862 /* Evaluate and return the value of the given F-Curve at the specified frame ("evaltime") 
1863  * Note: this is also used for drivers
1864  */
1865 float evaluate_fcurve (FCurve *fcu, float evaltime) 
1866 {
1867         FModifier *fcm;
1868         float cvalue = 0.0f;
1869         
1870         /* if there is a driver (only if this F-Curve is acting as 'driver'), evaluate it to find value to use as "evaltime" 
1871          *      - this value will also be returned as the value of the 'curve', if there are no keyframes
1872          */
1873         if (fcu->driver) {
1874                 /* evaltime now serves as input for the curve */
1875                 evaltime= cvalue= evaluate_driver(fcu->driver, evaltime);
1876         }
1877         
1878         /* evaluate curve-data */
1879         if (fcu->bezt)
1880                 cvalue= fcurve_eval_keyframes(fcu, fcu->bezt, evaltime);
1881         else if (fcu->fpt)
1882                 cvalue= fcurve_eval_samples(fcu, fcu->fpt, evaltime);
1883         
1884         /* evaluate modifiers */
1885         for (fcm= fcu->modifiers.first; fcm; fcm= fcm->next) {
1886                 FModifierTypeInfo *fmi= fmodifier_get_typeinfo(fcm);
1887                 
1888                 /* only evaluate if there's a callback for this */
1889                 // TODO: implement the 'influence' control feature...
1890                 if (fmi && fmi->evaluate_modifier) {
1891                         if ((fcm->flag & FMODIFIER_FLAG_DISABLED) == 0)
1892                                 fmi->evaluate_modifier(fcu, fcm, &cvalue, evaltime);
1893                 }
1894         }
1895         
1896         /* return evaluated value */
1897         return cvalue;
1898 }
1899
1900 /* Calculate the value of the given F-Curve at the given frame, and set its curval */
1901 // TODO: will this be necessary?
1902 void calculate_fcurve (FCurve *fcu, float ctime)
1903 {
1904         /* calculate and set curval (evaluates driver too) */
1905         fcu->curval= evaluate_fcurve(fcu, ctime);
1906 }
1907