2dfa1db171fdef2acf01f622d0fd3ea0130e2342
[blender-staging.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-curve 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                                         /* free the old data */
1189                                         MEM_freeN(data->coefficients);
1190                                 }       
1191                                 
1192                                 /* set the new data */
1193                                 data->coefficients= nc;
1194                                 data->arraysize= data->poly_order+1;
1195                         }
1196                 }
1197                         break;
1198                 
1199                 case FCM_GENERATOR_POLYNOMIAL_FACTORISED: /* expanded polynomial expression */
1200                 {
1201                         /* arraysize needs to be 2*order, so resize if not */
1202                         if (data->arraysize != (data->poly_order * 2)) {
1203                                 float *nc;
1204                                 
1205                                 /* make new coefficients array, and copy over as much data as can fit */
1206                                 nc= MEM_callocN(sizeof(float)*(data->poly_order*2), "FMod_Generator_Coefs");
1207                                 
1208                                 if (data->coefficients) {
1209                                         if (data->arraysize > (data->poly_order * 2))
1210                                                 memcpy(nc, data->coefficients, sizeof(float)*(data->poly_order * 2));
1211                                         else
1212                                                 memcpy(nc, data->coefficients, sizeof(float)*data->arraysize);
1213                                                 
1214                                         /* free the old data */
1215                                         MEM_freeN(data->coefficients);
1216                                 }       
1217                                 
1218                                 /* set the new data */
1219                                 data->coefficients= nc;
1220                                 data->arraysize= data->poly_order * 2;
1221                         }
1222                 }
1223                         break;
1224                         
1225                 case FCM_GENERATOR_FUNCTION: /* builtin function */
1226                 {
1227                         /* arraysize needs to be 4*/
1228                         if (data->arraysize != 4) {
1229                                 float *nc;
1230                                 
1231                                 /* free the old data */
1232                                 if (data->coefficients)
1233                                         MEM_freeN(data->coefficients);
1234                                 
1235                                 /* make new coefficients array, and init using default values */
1236                                 nc= data->coefficients= MEM_callocN(sizeof(float)*4, "FMod_Generator_Coefs");
1237                                 data->arraysize= 4;
1238                                 
1239                                 nc[0]= 1.0f;
1240                                 nc[1]= 1.0f;
1241                                 nc[2]= 0.0f;
1242                                 nc[3]= 0.0f;
1243                         }
1244                 }
1245                         break;  
1246         }
1247 }
1248
1249 static void fcm_generator_evaluate (FCurve *fcu, FModifier *fcm, float *cvalue, float evaltime)
1250 {
1251         FMod_Generator *data= (FMod_Generator *)fcm->data;
1252         
1253         /* behaviour depends on mode 
1254          * NOTE: the data in its default state is fine too
1255          */
1256         switch (data->mode) {
1257                 case FCM_GENERATOR_POLYNOMIAL: /* expanded polynomial expression */
1258                 {
1259                         /* we overwrite cvalue with the sum of the polynomial */
1260                         float *powers = MEM_callocN(sizeof(float)*data->arraysize, "Poly Powers");
1261                         float value= 0.0f;
1262                         unsigned int i;
1263                         
1264                         /* for each x^n, precalculate value based on previous one first... this should be 
1265                          * faster that calling pow() for each entry
1266                          */
1267                         for (i=0; i < data->arraysize; i++) {
1268                                 /* first entry is x^0 = 1, otherwise, calculate based on previous */
1269                                 if (i)
1270                                         powers[i]= powers[i-1] * evaltime;
1271                                 else
1272                                         powers[0]= 1;
1273                         }
1274                         
1275                         /* for each coefficient, add to value, which we'll write to *cvalue in one go */
1276                         for (i=0; i < data->arraysize; i++)
1277                                 value += data->coefficients[i] * powers[i];
1278                         
1279                         /* only if something changed, write *cvalue in one go */
1280                         if (data->poly_order) {
1281                                 if (data->flag & FCM_GENERATOR_ADDITIVE)
1282                                         *cvalue += value;
1283                                 else
1284                                         *cvalue= value;
1285                         }
1286                                 
1287                         /* cleanup */
1288                         if (powers) 
1289                                 MEM_freeN(powers);
1290                 }
1291                         break;
1292                         
1293                 case FCM_GENERATOR_POLYNOMIAL_FACTORISED: /* factorised polynomial */
1294                 {
1295                         float value= 1.0f, *cp=NULL;
1296                         unsigned int i;
1297                         
1298                         /* for each coefficient pair, solve for that bracket before accumulating in value by multiplying */
1299                         for (cp=data->coefficients, i=0; (cp) && (i < data->poly_order); cp+=2, i++) 
1300                                 value *= (cp[0]*evaltime + cp[1]);
1301                                 
1302                         /* only if something changed, write *cvalue in one go */
1303                         if (data->poly_order) {
1304                                 if (data->flag & FCM_GENERATOR_ADDITIVE)
1305                                         *cvalue += value;
1306                                 else
1307                                         *cvalue= value;
1308                         }
1309                 }
1310                         break;
1311                         
1312                 case FCM_GENERATOR_FUNCTION: /* builtin function */
1313                 {
1314                         double arg= data->coefficients[1]*evaltime + data->coefficients[2];
1315                         double (*fn)(double v) = NULL;
1316                         
1317                         /* get function pointer to the func to use:
1318                          * WARNING: must perform special argument validation hereto guard against crashes  
1319                          */
1320                         switch (data->func_type)
1321                         {
1322                                 /* simple ones */                       
1323                                 case FCM_GENERATOR_FN_SIN: /* sine wave */
1324                                         fn= sin;
1325                                         break;
1326                                 case FCM_GENERATOR_FN_COS: /* cosine wave */
1327                                         fn= cos;
1328                                         break;
1329                                         
1330                                 /* validation required */
1331                                 case FCM_GENERATOR_FN_TAN: /* tangent wave */
1332                                 {
1333                                         /* check that argument is not on one of the discontinuities (i.e. 90deg, 270 deg, etc) */
1334                                         if IS_EQ(fmod((arg - M_PI_2), M_PI), 0.0) {
1335                                                 if ((data->flag & FCM_GENERATOR_ADDITIVE) == 0)
1336                                                         *cvalue = 0.0f; /* no value possible here */
1337                                         }
1338                                         else
1339                                                 fn= tan;
1340                                 }
1341                                         break;
1342                                 case FCM_GENERATOR_FN_LN: /* natural log */
1343                                 {
1344                                         /* check that value is greater than 1? */
1345                                         if (arg > 1.0f) {
1346                                                 fn= log;
1347                                         }
1348                                         else {
1349                                                 if ((data->flag & FCM_GENERATOR_ADDITIVE) == 0)
1350                                                         *cvalue = 0.0f; /* no value possible here */
1351                                         }
1352                                 }
1353                                         break;
1354                                 case FCM_GENERATOR_FN_SQRT: /* square root */
1355                                 {
1356                                         /* no negative numbers */
1357                                         if (arg > 0.0f) {
1358                                                 fn= sqrt;
1359                                         }
1360                                         else {
1361                                                 if ((data->flag & FCM_GENERATOR_ADDITIVE) == 0)
1362                                                         *cvalue = 0.0f; /* no value possible here */
1363                                         }
1364                                 }
1365                                         break;
1366                                         
1367                                 default:
1368                                         printf("Invalid Function-Generator for F-Modifier - %d \n", data->func_type);
1369                         }
1370                         
1371                         /* execute function callback to set value if appropriate */
1372                         if (fn) {
1373                                 float value= data->coefficients[0]*fn(arg) + data->coefficients[3];
1374                                 
1375                                 if (data->flag & FCM_GENERATOR_ADDITIVE)
1376                                         *cvalue += value;
1377                                 else
1378                                         *cvalue= value;
1379                         }
1380                 }
1381                         break;
1382
1383 #ifndef DISABLE_PYTHON
1384                 case FCM_GENERATOR_EXPRESSION: /* py-expression */
1385                         // TODO...
1386                         break;
1387 #endif /* DISABLE_PYTHON */
1388         }
1389 }
1390
1391 static FModifierTypeInfo FMI_GENERATOR = {
1392         FMODIFIER_TYPE_GENERATOR, /* type */
1393         sizeof(FMod_Generator), /* size */
1394         FMI_TYPE_GENERATE_CURVE, /* action type */
1395         FMI_REQUIRES_NOTHING, /* requirements */
1396         "Generator", /* name */
1397         "FMod_Generator", /* struct name */
1398         fcm_generator_free, /* free data */
1399         fcm_generator_copy, /* copy data */
1400         fcm_generator_new_data, /* new data */
1401         fcm_generator_verify, /* verify */
1402         fcm_generator_evaluate /* evaluate */
1403 };
1404
1405 /* Envelope F-Curve Modifier --------------------------- */
1406
1407 static void fcm_envelope_free (FModifier *fcm)
1408 {
1409         FMod_Envelope *env= (FMod_Envelope *)fcm->data;
1410         
1411         /* free envelope data array */
1412         if (env->data)
1413                 MEM_freeN(env->data);
1414 }
1415
1416 static void fcm_envelope_copy (FModifier *fcm, FModifier *src)
1417 {
1418         FMod_Envelope *env= (FMod_Envelope *)fcm->data;
1419         FMod_Envelope *oenv= (FMod_Envelope *)src->data;
1420         
1421         /* copy envelope data array */
1422         if (oenv->data)
1423                 env->data= MEM_dupallocN(oenv->data);
1424 }
1425
1426 static void fcm_envelope_new_data (void *mdata)
1427 {
1428         FMod_Envelope *env= (FMod_Envelope *)mdata;
1429         
1430         /* set default min/max ranges */
1431         env->min= -1.0f;
1432         env->max= 1.0f;
1433 }
1434
1435 static void fcm_envelope_verify (FModifier *fcm)
1436 {
1437         FMod_Envelope *env= (FMod_Envelope *)fcm->data;
1438         
1439         /* if the are points, perform bubble-sort on them, as user may have changed the order */
1440         if (env->data) {
1441                 // XXX todo...
1442         }
1443 }
1444
1445 static void fcm_envelope_evaluate (FCurve *fcu, FModifier *fcm, float *cvalue, float evaltime)
1446 {
1447         FMod_Envelope *env= (FMod_Envelope *)fcm->data;
1448         FCM_EnvelopeData *fed, *prevfed, *lastfed;
1449         float min=0.0f, max=0.0f, fac=0.0f;
1450         int a;
1451         
1452         /* get pointers */
1453         if (env->data == NULL) return;
1454         prevfed= env->data;
1455         fed= prevfed + 1;
1456         lastfed= prevfed + (env->totvert-1);
1457         
1458         /* get min/max values for envelope at evaluation time (relative to mid-value) */
1459         if (prevfed->time >= evaltime) {
1460                 /* before or on first sample, so just extend value */
1461                 min= prevfed->min;
1462                 max= prevfed->max;
1463         }
1464         else if (lastfed->time <= evaltime) {
1465                 /* after or on last sample, so just extend value */
1466                 min= lastfed->min;
1467                 max= lastfed->max;
1468         }
1469         else {
1470                 /* evaltime occurs somewhere between segments */
1471                 // TODO: implement binary search for this to make it faster?
1472                 for (a=0; prevfed && fed && (a < env->totvert-1); a++, prevfed=fed, fed++) {  
1473                         /* evaltime occurs within the interval defined by these two envelope points */
1474                         if ((prevfed->time <= evaltime) && (fed->time >= evaltime)) {
1475                                 float afac, bfac, diff;
1476                                 
1477                                 diff= fed->time - prevfed->time;
1478                                 afac= (evaltime - prevfed->time) / diff;
1479                                 bfac= (fed->time - evaltime) / diff;
1480                                 
1481                                 min= bfac*prevfed->min + afac*fed->min;
1482                                 max= bfac*prevfed->max + afac*fed->max;
1483                                 
1484                                 break;
1485                         }
1486                 }
1487         }
1488         
1489         /* adjust *cvalue 
1490          *      - fac is the ratio of how the current y-value corresponds to the reference range
1491          *      - thus, the new value is found by mapping the old range to the new!
1492          */
1493         fac= (*cvalue - (env->midval + env->min)) / (env->max - env->min);
1494         *cvalue= min + fac*(max - min); 
1495 }
1496
1497 static FModifierTypeInfo FMI_ENVELOPE = {
1498         FMODIFIER_TYPE_ENVELOPE, /* type */
1499         sizeof(FMod_Envelope), /* size */
1500         FMI_TYPE_REPLACE_VALUES, /* action type */
1501         0, /* requirements */
1502         "Envelope", /* name */
1503         "FMod_Envelope", /* struct name */
1504         fcm_envelope_free, /* free data */
1505         fcm_envelope_copy, /* copy data */
1506         fcm_envelope_new_data, /* new data */
1507         fcm_envelope_verify, /* verify */
1508         fcm_envelope_evaluate /* evaluate */
1509 };
1510
1511 /* Cycles F-Curve Modifier  --------------------------- */
1512
1513 /* This modifier changes evaltime to something that exists within the curve's frame-range, 
1514  * then re-evaluates modifier stack up to this point using the new time. This re-entrant behaviour
1515  * is very likely to be more time-consuming than the original approach... (which was tighly integrated into 
1516  * the calculation code...).
1517  *
1518  * 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
1519  * Possible TODO - store length of cycle information that can be initialised from the extents of the keyframes/sample-data, and adjusted
1520  *                              as appropriate
1521  */
1522
1523 static void fcm_cycles_new_data (void *mdata)
1524 {
1525         FMod_Cycles *data= (FMod_Cycles *)mdata;
1526         
1527         /* turn on cycles by default */
1528         data->before_mode= data->after_mode= FCM_EXTRAPOLATE_CYCLIC;
1529 }
1530  
1531 static void fcm_cycles_evaluate (FCurve *fcu, FModifier *fcm, float *cvalue, float evaltime)
1532 {
1533         FMod_Cycles *data= (FMod_Cycles *)fcm->data;
1534         ListBase mods = {NULL, NULL};
1535         float prevkey[2], lastkey[2], cycyofs=0.0f;
1536         float new_value;
1537         short side=0, mode=0;
1538         int cycles=0;
1539         
1540         /* check if modifier is first in stack, otherwise disable ourself... */
1541         // FIXME...
1542         if (fcm->prev) {
1543                 fcm->flag |= FMODIFIER_FLAG_DISABLED;
1544                 return;
1545         }
1546         
1547         /* calculate new evaltime due to cyclic interpolation */
1548         if (fcu && fcu->bezt) {
1549                 BezTriple *prevbezt= fcu->bezt;
1550                 BezTriple *lastbezt= prevbezt + fcu->totvert-1;
1551                 
1552                 prevkey[0]= prevbezt->vec[1][0];
1553                 prevkey[1]= prevbezt->vec[1][1];
1554                 
1555                 lastkey[0]= lastbezt->vec[1][0];
1556                 lastkey[1]= lastbezt->vec[1][1];
1557         }
1558         else if (fcu && fcu->fpt) {
1559                 FPoint *prevfpt= fcu->fpt;
1560                 FPoint *lastfpt= prevfpt + fcu->totvert-1;
1561                 
1562                 prevkey[0]= prevfpt->vec[0];
1563                 prevkey[1]= prevfpt->vec[1];
1564                 
1565                 lastkey[0]= lastfpt->vec[0];
1566                 lastkey[1]= lastfpt->vec[1];
1567         }
1568         else
1569                 return;
1570                 
1571         /* check if modifier will do anything
1572          *      1) if in data range, definitely don't do anything
1573          *      2) if before first frame or after last frame, make sure some cycling is in use
1574          */
1575         if (evaltime < prevkey[0]) {
1576                 if (data->before_mode)  {
1577                         side= -1;
1578                         mode= data->before_mode;
1579                         cycles= data->before_cycles;
1580                 }
1581         }
1582         else if (evaltime > lastkey[0]) {
1583                 if (data->after_mode) {
1584                         side= 1;
1585                         mode= data->after_mode;
1586                         cycles= data->after_cycles;
1587                 }
1588         }
1589         if ELEM(0, side, mode)
1590                 return;
1591                 
1592         /* find relative place within a cycle */
1593         {
1594                 float cycdx=0, cycdy=0, ofs=0;
1595                 
1596                 /* ofs is start frame of cycle */
1597                 ofs= prevkey[0];
1598                 
1599                 /* calculate period and amplitude (total height) of a cycle */
1600                 cycdx= lastkey[0] - prevkey[0];
1601                 cycdy= lastkey[1] - prevkey[1];
1602                 
1603                 /* check if cycle is infinitely small, to be point of being impossible to use */
1604                 if (cycdx == 0)
1605                         return;
1606                         
1607                 /* check that cyclic is still enabled for the specified time */
1608                 if (cycles == 0) {
1609                         /* catch this case so that we don't exit when we have cycles=0
1610                          * as this indicates infinite cycles...
1611                          */
1612                 }
1613                 else if ( ((float)side * (evaltime - ofs) / cycdx) > (cycles+1) ) {
1614                         /* we are too far away from range to evaluate
1615                          * TODO: but we should still hold last value... 
1616                          */
1617                         return;
1618                 }
1619                 
1620                 /* check if 'cyclic extrapolation', and thus calculate y-offset for this cycle */
1621                 if (mode == FCM_EXTRAPOLATE_CYCLIC_OFFSET) {
1622                         cycyofs = (float)floor((evaltime - ofs) / cycdx);
1623                         cycyofs *= cycdy;
1624                 }
1625                 
1626                 /* calculate where in the cycle we are (overwrite evaltime to reflect this) */
1627                 evaltime= (float)(fmod(evaltime-ofs, cycdx) + ofs);
1628                 if (evaltime < ofs) evaltime += cycdx;
1629         }
1630         
1631         
1632         /* store modifiers after (and including ourself) before recalculating curve with new evaltime */
1633         mods= fcu->modifiers;
1634         fcu->modifiers.first= fcu->modifiers.last= NULL;
1635         
1636         /* re-enter the evaluation loop (but without the burden of evaluating any modifiers, so 'should' be relatively quick) */
1637         new_value= evaluate_fcurve(fcu, evaltime);
1638         
1639         /* restore modifiers, and set new value (don't assume everything is still ok after being re-entrant) */
1640         fcu->modifiers= mods;
1641         *cvalue= new_value + cycyofs;
1642 }
1643
1644 static FModifierTypeInfo FMI_CYCLES = {
1645         FMODIFIER_TYPE_CYCLES, /* type */
1646         sizeof(FMod_Cycles), /* size */
1647         FMI_TYPE_EXTRAPOLATION, /* action type */
1648         FMI_REQUIRES_ORIGINAL_DATA, /* requirements */
1649         "Cycles", /* name */
1650         "FMod_Cycles", /* struct name */
1651         NULL, /* free data */
1652         NULL, /* copy data */
1653         fcm_cycles_new_data, /* new data */
1654         NULL /*fcm_cycles_verify*/, /* verify */
1655         fcm_cycles_evaluate /* evaluate */
1656 };
1657
1658 /* Noise F-Curve Modifier  --------------------------- */
1659
1660 #if 0 // XXX not yet implemented 
1661 static FModifierTypeInfo FMI_NOISE = {
1662         FMODIFIER_TYPE_NOISE, /* type */
1663         sizeof(FMod_Noise), /* size */
1664         FMI_TYPE_REPLACE_VALUES, /* action type */
1665         0, /* requirements */
1666         "Noise", /* name */
1667         "FMod_Noise", /* struct name */
1668         NULL, /* free data */
1669         NULL, /* copy data */
1670         fcm_noise_new_data, /* new data */
1671         NULL /*fcm_noise_verify*/, /* verify */
1672         fcm_noise_evaluate /* evaluate */
1673 };
1674 #endif // XXX not yet implemented
1675
1676 /* Filter F-Curve Modifier --------------------------- */
1677
1678 #if 0 // XXX not yet implemented 
1679 static FModifierTypeInfo FMI_FILTER = {
1680         FMODIFIER_TYPE_FILTER, /* type */
1681         sizeof(FMod_Filter), /* size */
1682         FMI_TYPE_REPLACE_VALUES, /* action type */
1683         0, /* requirements */
1684         "Filter", /* name */
1685         "FMod_Filter", /* struct name */
1686         NULL, /* free data */
1687         NULL, /* copy data */
1688         NULL, /* new data */
1689         NULL /*fcm_filter_verify*/, /* verify */
1690         fcm_filter_evaluate /* evaluate */
1691 };
1692 #endif // XXX not yet implemented
1693
1694
1695 /* Python F-Curve Modifier --------------------------- */
1696
1697 static void fcm_python_free (FModifier *fcm)
1698 {
1699         FMod_Python *data= (FMod_Python *)fcm->data;
1700         
1701         /* id-properties */
1702         IDP_FreeProperty(data->prop);
1703         MEM_freeN(data->prop);
1704 }
1705
1706 static void fcm_python_new_data (void *mdata) 
1707 {
1708         FMod_Python *data= (FMod_Python *)mdata;
1709         
1710         /* everything should be set correctly by calloc, except for the prop->type constant.*/
1711         data->prop = MEM_callocN(sizeof(IDProperty), "PyFModifierProps");
1712         data->prop->type = IDP_GROUP;
1713 }
1714
1715 static void fcm_python_copy (FModifier *fcm, FModifier *src)
1716 {
1717         FMod_Python *pymod = (FMod_Python *)fcm->data;
1718         FMod_Python *opymod = (FMod_Python *)src->data;
1719         
1720         pymod->prop = IDP_CopyProperty(opymod->prop);
1721 }
1722
1723 static void fcm_python_evaluate (FCurve *fcu, FModifier *fcm, float *cvalue, float evaltime)
1724 {
1725 #ifndef DISABLE_PYTHON
1726         //FMod_Python *data= (FMod_Python *)fcm->data;
1727         
1728         /* FIXME... need to implement this modifier...
1729          *      It will need it execute a script using the custom properties 
1730          */
1731 #endif /* DISABLE_PYTHON */
1732 }
1733
1734 static FModifierTypeInfo FMI_PYTHON = {
1735         FMODIFIER_TYPE_PYTHON, /* type */
1736         sizeof(FMod_Python), /* size */
1737         FMI_TYPE_GENERATE_CURVE, /* action type */
1738         FMI_REQUIRES_RUNTIME_CHECK, /* requirements */
1739         "Python", /* name */
1740         "FMod_Python", /* struct name */
1741         fcm_python_free, /* free data */
1742         fcm_python_copy, /* copy data */
1743         fcm_python_new_data, /* new data */
1744         NULL /*fcm_python_verify*/, /* verify */
1745         fcm_python_evaluate /* evaluate */
1746 };
1747
1748
1749 /* F-Curve Modifier API --------------------------- */
1750 /* All of the F-Curve Modifier api functions use FModifierTypeInfo structs to carry out
1751  * and operations that involve F-Curve modifier specific code.
1752  */
1753
1754 /* These globals only ever get directly accessed in this file */
1755 static FModifierTypeInfo *fmodifiersTypeInfo[FMODIFIER_NUM_TYPES];
1756 static short FMI_INIT= 1; /* when non-zero, the list needs to be updated */
1757
1758 /* This function only gets called when FMI_INIT is non-zero */
1759 static void fmods_init_typeinfo () 
1760 {
1761         fmodifiersTypeInfo[0]=  NULL;                                   /* 'Null' F-Curve Modifier */
1762         fmodifiersTypeInfo[1]=  &FMI_GENERATOR;                 /* Generator F-Curve Modifier */
1763         fmodifiersTypeInfo[2]=  &FMI_ENVELOPE;                  /* Envelope F-Curve Modifier */
1764         fmodifiersTypeInfo[3]=  &FMI_CYCLES;                    /* Cycles F-Curve Modifier */
1765         fmodifiersTypeInfo[4]=  NULL/*&FMI_NOISE*/;                             /* Apply-Noise F-Curve Modifier */ // XXX unimplemented
1766         fmodifiersTypeInfo[5]=  NULL/*&FMI_FILTER*/;                    /* Filter F-Curve Modifier */  // XXX unimplemented
1767         fmodifiersTypeInfo[6]=  &FMI_PYTHON;                    /* Custom Python F-Curve Modifier */
1768 }
1769
1770 /* This function should be used for getting the appropriate type-info when only
1771  * a F-Curve modifier type is known
1772  */
1773 FModifierTypeInfo *get_fmodifier_typeinfo (int type)
1774 {
1775         /* initialise the type-info list? */
1776         if (FMI_INIT) {
1777                 fmods_init_typeinfo();
1778                 FMI_INIT = 0;
1779         }
1780         
1781         /* only return for valid types */
1782         if ( (type >= FMODIFIER_TYPE_NULL) && 
1783                  (type <= FMODIFIER_NUM_TYPES ) ) 
1784         {
1785                 /* there shouldn't be any segfaults here... */
1786                 return fmodifiersTypeInfo[type];
1787         }
1788         else {
1789                 printf("No valid F-Curve Modifier type-info data available. Type = %i \n", type);
1790         }
1791         
1792         return NULL;
1793
1794  
1795 /* This function should always be used to get the appropriate type-info, as it
1796  * has checks which prevent segfaults in some weird cases.
1797  */
1798 FModifierTypeInfo *fmodifier_get_typeinfo (FModifier *fcm)
1799 {
1800         /* only return typeinfo for valid modifiers */
1801         if (fcm)
1802                 return get_fmodifier_typeinfo(fcm->type);
1803         else
1804                 return NULL;
1805 }
1806
1807 /* API --------------------------- */
1808
1809 /* Add a new F-Curve Modifier to the given F-Curve of a certain type */
1810 FModifier *fcurve_add_modifier (FCurve *fcu, int type)
1811 {
1812         FModifierTypeInfo *fmi= get_fmodifier_typeinfo(type);
1813         FModifier *fcm;
1814         
1815         /* sanity checks */
1816         if ELEM(NULL, fcu, fmi)
1817                 return NULL;
1818         
1819         /* special checks for whether modifier can be added */
1820         if ((fcu->modifiers.first) && (type == FMODIFIER_TYPE_CYCLES)) {
1821                 /* cycles modifier must be first in stack, so for now, don't add if it can't be */
1822                 // TODO: perhaps there is some better way, but for now, 
1823                 printf("Error: Cannot add 'Cycles' modifier to F-Curve, as 'Cycles' modifier can only be first in stack. \n");
1824                 return NULL;
1825         }
1826         
1827         /* add modifier itself */
1828         fcm= MEM_callocN(sizeof(FModifier), "F-Curve Modifier");
1829         fcm->type = type;
1830         fcm->flag = FMODIFIER_FLAG_EXPANDED;
1831         BLI_addtail(&fcu->modifiers, fcm);
1832         
1833         /* add modifier's data */
1834         fcm->data= MEM_callocN(fmi->size, fmi->structName);
1835                 
1836         /* init custom settings if necessary */
1837         if (fmi->new_data)      
1838                 fmi->new_data(fcm->data);
1839                 
1840         /* return modifier for further editing */
1841         return fcm;
1842 }
1843
1844 /* Duplicate all of the F-Curve Modifiers in the Modifier stacks */
1845 void fcurve_copy_modifiers (ListBase *dst, ListBase *src)
1846 {
1847         FModifier *fcm, *srcfcm;
1848         
1849         if ELEM(NULL, dst, src)
1850                 return;
1851         
1852         dst->first= dst->last= NULL;
1853         BLI_duplicatelist(dst, src);
1854         
1855         for (fcm=dst->first, srcfcm=src->first; fcm && srcfcm; srcfcm=srcfcm->next, fcm=fcm->next) {
1856                 FModifierTypeInfo *fmi= fmodifier_get_typeinfo(fcm);
1857                 
1858                 /* make a new copy of the F-Modifier's data */
1859                 fcm->data = MEM_dupallocN(fcm->data);
1860                 
1861                 /* only do specific constraints if required */
1862                 if (fmi && fmi->copy_data)
1863                         fmi->copy_data(fcm, srcfcm);
1864         }
1865 }
1866
1867 /* Remove and free the given F-Curve Modifier from the given F-Curve's stack  */
1868 void fcurve_remove_modifier (FCurve *fcu, FModifier *fcm)
1869 {
1870         FModifierTypeInfo *fmi= fmodifier_get_typeinfo(fcm);
1871         
1872         /* sanity check */
1873         if (fcm == NULL)
1874                 return;
1875         
1876         /* free modifier's special data (stored inside fcm->data) */
1877         if (fcm->data) {
1878                 if (fmi && fmi->free_data)
1879                         fmi->free_data(fcm);
1880                         
1881                 /* free modifier's data (fcm->data) */
1882                 MEM_freeN(fcm->data);
1883         }
1884         
1885         /* remove modifier from stack */
1886         if (fcu)
1887                 BLI_freelinkN(&fcu->modifiers, fcm);
1888         else {
1889                 // XXX this case can probably be removed some day, as it shouldn't happen...
1890                 printf("fcurve_remove_modifier() - no fcurve \n");
1891                 MEM_freeN(fcm);
1892         }
1893 }
1894
1895 /* Remove all of a given F-Curve's modifiers */
1896 void fcurve_free_modifiers (FCurve *fcu)
1897 {
1898         FModifier *fcm, *fmn;
1899         
1900         /* sanity check */
1901         if (fcu == NULL)
1902                 return;
1903         
1904         /* free each modifier in order - modifier is unlinked from list and freed */
1905         for (fcm= fcu->modifiers.first; fcm; fcm= fmn) {
1906                 fmn= fcm->next;
1907                 fcurve_remove_modifier(fcu, fcm);
1908         }
1909 }
1910
1911 /* Bake modifiers for given F-Curve to curve sample data, in the frame range defined
1912  * by start and end (inclusive).
1913  */
1914 void fcurve_bake_modifiers (FCurve *fcu, int start, int end)
1915 {
1916         ChannelDriver *driver;
1917         
1918         /* sanity checks */
1919         // TODO: make these tests report errors using reports not printf's
1920         if ELEM(NULL, fcu, fcu->modifiers.first) {
1921                 printf("Error: No F-Curve with F-Curve Modifiers to Bake\n");
1922                 return;
1923         }
1924         
1925         /* temporarily, disable driver while we sample, so that they don't influence the outcome */
1926         driver= fcu->driver;
1927         fcu->driver= NULL;
1928         
1929         /* bake the modifiers, by sampling the curve at each frame */
1930         fcurve_store_samples(fcu, NULL, start, end, fcurve_samplingcb_evalcurve);
1931         
1932         /* free the modifiers now */
1933         fcurve_free_modifiers(fcu);
1934         
1935         /* restore driver */
1936         fcu->driver= driver;
1937 }
1938
1939 /* Find the active F-Curve Modifier */
1940 FModifier *fcurve_find_active_modifier (FCurve *fcu)
1941 {
1942         FModifier *fcm;
1943         
1944         /* sanity checks */
1945         if ELEM(NULL, fcu, fcu->modifiers.first)
1946                 return NULL;
1947         
1948         /* loop over modifiers until 'active' one is found */
1949         for (fcm= fcu->modifiers.first; fcm; fcm= fcm->next) {
1950                 if (fcm->flag & FMODIFIER_FLAG_ACTIVE)
1951                         return fcm;
1952         }
1953         
1954         /* no modifier is active */
1955         return NULL;
1956 }
1957
1958 /* Set the active F-Curve Modifier */
1959 void fcurve_set_active_modifier (FCurve *fcu, FModifier *fcm)
1960 {
1961         FModifier *fm;
1962         
1963         /* sanity checks */
1964         if ELEM(NULL, fcu, fcu->modifiers.first)
1965                 return;
1966         
1967         /* deactivate all, and set current one active */
1968         for (fm= fcu->modifiers.first; fm; fm= fm->next)
1969                 fm->flag &= ~FMODIFIER_FLAG_ACTIVE;
1970         
1971         /* make given modifier active */
1972         if (fcm)
1973                 fcm->flag |= FMODIFIER_FLAG_ACTIVE;
1974 }
1975
1976 /* ***************************** F-Curve - Evaluation ********************************* */
1977
1978 /* Evaluate and return the value of the given F-Curve at the specified frame ("evaltime") 
1979  * Note: this is also used for drivers
1980  */
1981 float evaluate_fcurve (FCurve *fcu, float evaltime) 
1982 {
1983         FModifier *fcm;
1984         float cvalue = 0.0f;
1985         
1986         /* if there is a driver (only if this F-Curve is acting as 'driver'), evaluate it to find value to use as "evaltime" 
1987          *      - this value will also be returned as the value of the 'curve', if there are no keyframes
1988          */
1989         if (fcu->driver) {
1990                 /* evaltime now serves as input for the curve */
1991                 evaltime= cvalue= evaluate_driver(fcu->driver, evaltime);
1992         }
1993         
1994         /* evaluate curve-data */
1995         if (fcu->bezt)
1996                 cvalue= fcurve_eval_keyframes(fcu, fcu->bezt, evaltime);
1997         else if (fcu->fpt)
1998                 cvalue= fcurve_eval_samples(fcu, fcu->fpt, evaltime);
1999         
2000         /* evaluate modifiers */
2001         for (fcm= fcu->modifiers.first; fcm; fcm= fcm->next) {
2002                 FModifierTypeInfo *fmi= fmodifier_get_typeinfo(fcm);
2003                 
2004                 /* only evaluate if there's a callback for this */
2005                 // TODO: implement the 'influence' control feature...
2006                 if (fmi && fmi->evaluate_modifier) {
2007                         if ((fcm->flag & FMODIFIER_FLAG_DISABLED) == 0)
2008                                 fmi->evaluate_modifier(fcu, fcm, &cvalue, evaltime);
2009                 }
2010         }
2011         
2012         /* if curve can only have integral values, perform truncation (i.e. drop the decimal part)
2013          * here so that the curve can be sampled correctly
2014          */
2015         if (fcu->flag & FCURVE_INT_VALUES)
2016                 cvalue= (float)((int)cvalue);
2017         
2018         /* return evaluated value */
2019         return cvalue;
2020 }
2021
2022 /* Calculate the value of the given F-Curve at the given frame, and set its curval */
2023 // TODO: will this be necessary?
2024 void calculate_fcurve (FCurve *fcu, float ctime)
2025 {
2026         /* calculate and set curval (evaluates driver too) */
2027         fcu->curval= evaluate_fcurve(fcu, ctime);
2028 }
2029