NLA SoC: Separating out F-Modifier API
[blender-staging.git] / source / blender / blenkernel / intern / fcurve.c
1 /**
2  * $Id$
3  *
4  * ***** BEGIN GPL LICENSE BLOCK *****
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * as published by the Free Software Foundation; either version 2
9  * of the License, or (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software Foundation,
18  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
19  *
20  * The Original Code is Copyright (C) 2009 Blender Foundation, Joshua Leung
21  * All rights reserved.
22  *
23  * The Original Code is: all of this file.
24  *
25  * Contributor(s): Joshua Leung (full recode)
26  *
27  * ***** END GPL LICENSE BLOCK *****
28  */
29  
30
31 #include <math.h>
32 #include <stdio.h>
33 #include <stddef.h>
34 #include <string.h>
35 #include <float.h>
36
37 #ifdef HAVE_CONFIG_H
38 #include <config.h>
39 #endif
40
41 #include "MEM_guardedalloc.h"
42
43 #include "DNA_anim_types.h"
44
45 #include "BLI_blenlib.h"
46 #include "BLI_arithb.h"
47 #include "BLI_noise.h"
48
49 #include "BKE_fcurve.h"
50 #include "BKE_curve.h" 
51 #include "BKE_global.h"
52 #include "BKE_idprop.h"
53 #include "BKE_utildefines.h"
54
55 #include "RNA_access.h"
56 #include "RNA_types.h"
57
58 #ifndef DISABLE_PYTHON
59 #include "BPY_extern.h" 
60 #endif
61
62 #define SMALL -1.0e-10
63 #define SELECT 1
64
65 /* ************************** Data-Level Functions ************************* */
66
67 /* ---------------------- Freeing --------------------------- */
68
69 /* Frees the F-Curve itself too, so make sure BLI_remlink is called before calling this... */
70 void free_fcurve (FCurve *fcu) 
71 {
72         if (fcu == NULL) 
73                 return;
74         
75         /* free curve data */
76         if (fcu) {
77                 if (fcu->bezt) MEM_freeN(fcu->bezt);
78                 if (fcu->fpt) MEM_freeN(fcu->fpt);
79         }
80         
81         /* free RNA-path, as this were allocated when getting the path string */
82         if (fcu->rna_path)
83                 MEM_freeN(fcu->rna_path);
84         
85         /* free extra data - i.e. modifiers, and driver */
86         fcurve_free_driver(fcu);
87         free_fmodifiers(&fcu->modifiers);
88         
89         /* free f-curve itself */
90         MEM_freeN(fcu);
91 }
92
93 /* Frees a list of F-Curves */
94 void free_fcurves (ListBase *list)
95 {
96         FCurve *fcu, *fcn;
97         
98         /* sanity check */
99         if (list == NULL)
100                 return;
101                 
102         /* free data - no need to call remlink before freeing each curve, 
103          * as we store reference to next, and freeing only touches the curve
104          * it's given
105          */
106         for (fcu= list->first; fcu; fcu= fcn) {
107                 fcn= fcu->next;
108                 free_fcurve(fcu);
109         }
110         
111         /* clear pointers just in case */
112         list->first= list->last= NULL;
113 }       
114
115 /* ---------------------- Copy --------------------------- */
116
117 /* duplicate an F-Curve */
118 FCurve *copy_fcurve (FCurve *fcu)
119 {
120         FCurve *fcu_d;
121         
122         /* sanity check */
123         if (fcu == NULL)
124                 return NULL;
125                 
126         /* make a copy */
127         fcu_d= MEM_dupallocN(fcu);
128         
129         fcu_d->next= fcu_d->prev= NULL;
130         fcu_d->grp= NULL;
131         
132         /* copy curve data */
133         fcu_d->bezt= MEM_dupallocN(fcu_d->bezt);
134         fcu_d->fpt= MEM_dupallocN(fcu_d->fpt);
135         
136         /* copy rna-path */
137         fcu_d->rna_path= MEM_dupallocN(fcu_d->rna_path);
138         
139         /* copy driver */
140         fcu_d->driver= fcurve_copy_driver(fcu_d->driver);
141         
142         /* copy modifiers */
143         copy_fmodifiers(&fcu_d->modifiers, &fcu->modifiers);
144         
145         /* return new data */
146         return fcu_d;
147 }
148
149 /* duplicate a list of F-Curves */
150 void copy_fcurves (ListBase *dst, ListBase *src)
151 {
152         FCurve *dfcu, *sfcu;
153         
154         /* sanity checks */
155         if ELEM(NULL, dst, src)
156                 return;
157         
158         /* clear destination list first */
159         dst->first= dst->last= NULL;
160         
161         /* copy one-by-one */
162         for (sfcu= src->first; sfcu; sfcu= sfcu->next) {
163                 dfcu= copy_fcurve(sfcu);
164                 BLI_addtail(dst, dfcu);
165         }
166 }
167
168 /* ---------------------- Relink --------------------------- */
169
170 #if 0
171 /* uses id->newid to match pointers with other copied data 
172  *      - called after single-user or other such
173  */
174                         if (icu->driver)
175                                 ID_NEW(icu->driver->ob);
176 #endif
177
178 /* --------------------- Finding -------------------------- */
179
180 /* Find the F-Curve affecting the given RNA-access path + index, in the list of F-Curves provided */
181 FCurve *list_find_fcurve (ListBase *list, const char rna_path[], const int array_index)
182 {
183         FCurve *fcu;
184         
185         /* sanity checks */
186         if ( ELEM(NULL, list, rna_path) || (array_index < 0) )
187                 return NULL;
188         
189         /* check paths of curves, then array indices... */
190         for (fcu= list->first; fcu; fcu= fcu->next) {
191                 /* simple string-compare (this assumes that they have the same root...) */
192                 if (fcu->rna_path && !strcmp(fcu->rna_path, rna_path)) {
193                         /* now check indicies */
194                         if (fcu->array_index == array_index)
195                                 return fcu;
196                 }
197         }
198         
199         /* return */
200         return NULL;
201 }
202
203 short on_keyframe_fcurve(FCurve *fcu, float cfra)
204 {
205         BezTriple *bezt;
206         unsigned i;
207
208         bezt= fcu->bezt;
209         for (i=0; i<fcu->totvert; i++, bezt++) {
210                 if (IS_EQ(bezt->vec[1][0], cfra))
211                         return 1;
212         }
213         
214         return 0;
215 }
216
217 /* Calculate the extents of F-Curve's data */
218 void calc_fcurve_bounds (FCurve *fcu, float *xmin, float *xmax, float *ymin, float *ymax)
219 {
220         float xminv=999999999.0f, xmaxv=-999999999.0f;
221         float yminv=999999999.0f, ymaxv=-999999999.0f;
222         short foundvert=0;
223         unsigned int i;
224         
225         if (fcu->totvert) {
226                 if (fcu->bezt) {
227                         /* frame range can be directly calculated from end verts */
228                         if (xmin || xmax) {
229                                 xminv= MIN2(xminv, fcu->bezt[0].vec[1][0]);
230                                 xmaxv= MAX2(xmaxv, fcu->bezt[fcu->totvert-1].vec[1][0]);
231                         }
232                         
233                         /* only loop over keyframes to find extents for values if needed */
234                         if (ymin || ymax) {
235                                 BezTriple *bezt;
236                                 
237                                 for (bezt=fcu->bezt, i=0; i < fcu->totvert; bezt++, i++) {
238                                         if (bezt->vec[1][1] < yminv)
239                                                 yminv= bezt->vec[1][1];
240                                         if (bezt->vec[1][1] > ymaxv)
241                                                 ymaxv= bezt->vec[1][1];
242                                 }
243                         }
244                 }
245                 else if (fcu->fpt) {
246                         /* frame range can be directly calculated from end verts */
247                         if (xmin || xmax) {
248                                 xminv= MIN2(xminv, fcu->fpt[0].vec[0]);
249                                 xmaxv= MAX2(xmaxv, fcu->fpt[fcu->totvert-1].vec[0]);
250                         }
251                         
252                         /* only loop over keyframes to find extents for values if needed */
253                         if (ymin || ymax) {
254                                 FPoint *fpt;
255                                 
256                                 for (fpt=fcu->fpt, i=0; i < fcu->totvert; fpt++, i++) {
257                                         if (fpt->vec[1] < yminv)
258                                                 yminv= fpt->vec[1];
259                                         if (fpt->vec[1] > ymaxv)
260                                                 ymaxv= fpt->vec[1];
261                                 }
262                         }
263                 }
264                 
265                 foundvert=1;
266         }
267         
268         /* minimum sizes are 1.0f */
269         if (foundvert) {
270                 if (xminv == xmaxv) xmaxv += 1.0f;
271                 if (yminv == ymaxv) ymaxv += 1.0f;
272                 
273                 if (xmin) *xmin= xminv;
274                 if (xmax) *xmax= xmaxv;
275                 
276                 if (ymin) *ymin= yminv;
277                 if (ymax) *ymax= ymaxv;
278         }
279         else {
280                 if (xmin) *xmin= 0.0f;
281                 if (xmax) *xmax= 0.0f;
282                 
283                 if (ymin) *ymin= 1.0f;
284                 if (ymax) *ymax= 1.0f;
285         }
286 }
287
288 /* Calculate the extents of F-Curve's keyframes */
289 void calc_fcurve_range (FCurve *fcu, float *start, float *end)
290 {
291         float min=999999999.0f, max=-999999999.0f;
292         short foundvert=0;
293
294         if (fcu->totvert) {
295                 if (fcu->bezt) {
296                         min= MIN2(min, fcu->bezt[0].vec[1][0]);
297                         max= MAX2(max, fcu->bezt[fcu->totvert-1].vec[1][0]);
298                 }
299                 else if (fcu->fpt) {
300                         min= MIN2(min, fcu->fpt[0].vec[0]);
301                         max= MAX2(max, fcu->fpt[fcu->totvert-1].vec[0]);
302                 }
303                 
304                 foundvert=1;
305         }
306         
307         /* minimum length is 1 frame */
308         if (foundvert) {
309                 if (min == max) max += 1.0f;
310                 *start= min;
311                 *end= max;
312         }
313         else {
314                 *start= 0.0f;
315                 *end= 1.0f;
316         }
317 }
318
319 /* ***************************** Keyframe Column Tools ********************************* */
320
321 /* add a BezTriple to a column */
322 void bezt_add_to_cfra_elem (ListBase *lb, BezTriple *bezt)
323 {
324         CfraElem *ce, *cen;
325         
326         for (ce= lb->first; ce; ce= ce->next) {
327                 /* double key? */
328                 if (ce->cfra == bezt->vec[1][0]) {
329                         if (bezt->f2 & SELECT) ce->sel= bezt->f2;
330                         return;
331                 }
332                 /* should key be inserted before this column? */
333                 else if (ce->cfra > bezt->vec[1][0]) break;
334         }
335         
336         /* create a new column */
337         cen= MEM_callocN(sizeof(CfraElem), "add_to_cfra_elem"); 
338         if (ce) BLI_insertlinkbefore(lb, ce, cen);
339         else BLI_addtail(lb, cen);
340
341         cen->cfra= bezt->vec[1][0];
342         cen->sel= bezt->f2;
343 }
344
345 /* ***************************** Samples Utilities ******************************* */
346 /* Some utilities for working with FPoints (i.e. 'sampled' animation curve data, such as
347  * data imported from BVH/Mocap files), which are specialised for use with high density datasets,
348  * which BezTriples/Keyframe data are ill equipped to do.
349  */
350  
351  
352 /* Basic sampling callback which acts as a wrapper for evaluate_fcurve() 
353  *      'data' arg here is unneeded here...
354  */
355 float fcurve_samplingcb_evalcurve (FCurve *fcu, void *data, float evaltime)
356 {
357         /* assume any interference from drivers on the curve is intended... */
358         return evaluate_fcurve(fcu, evaltime);
359
360
361  
362 /* Main API function for creating a set of sampled curve data, given some callback function 
363  * used to retrieve the values to store.
364  */
365 void fcurve_store_samples (FCurve *fcu, void *data, int start, int end, FcuSampleFunc sample_cb)
366 {
367         FPoint *fpt, *new_fpt;
368         int cfra;
369         
370         /* sanity checks */
371         // TODO: make these tests report errors using reports not printf's
372         if ELEM(NULL, fcu, sample_cb) {
373                 printf("Error: No F-Curve with F-Curve Modifiers to Bake\n");
374                 return;
375         }
376         if (start >= end) {
377                 printf("Error: Frame range for Sampled F-Curve creation is inappropriate \n");
378                 return;
379         }
380         
381         /* set up sample data */
382         fpt= new_fpt= MEM_callocN(sizeof(FPoint)*(end-start+1), "FPoint Samples");
383         
384         /* use the sampling callback at 1-frame intervals from start to end frames */
385         for (cfra= start; cfra <= end; cfra++, fpt++) {
386                 fpt->vec[0]= (float)cfra;
387                 fpt->vec[1]= sample_cb(fcu, data, (float)cfra);
388         }
389         
390         /* free any existing sample/keyframe data on curve  */
391         if (fcu->bezt) MEM_freeN(fcu->bezt);
392         if (fcu->fpt) MEM_freeN(fcu->fpt);
393         
394         /* store the samples */
395         fcu->bezt= NULL;
396         fcu->fpt= new_fpt;
397         fcu->totvert= end - start + 1;
398 }
399
400 /* ***************************** F-Curve Sanity ********************************* */
401 /* The functions here are used in various parts of Blender, usually after some editing
402  * of keyframe data has occurred. They ensure that keyframe data is properly ordered and
403  * that the handles are correctly 
404  */
405
406 /* This function recalculates the handles of an F-Curve 
407  * If the BezTriples have been rearranged, sort them first before using this.
408  */
409 void calchandles_fcurve (FCurve *fcu)
410 {
411         BezTriple *bezt, *prev, *next;
412         int a= fcu->totvert;
413
414         /* Error checking:
415          *      - need at least two points
416          *      - need bezier keys
417          *      - only bezier-interpolation has handles (for now)
418          */
419         if (ELEM(NULL, fcu, fcu->bezt) || (a < 2) /*|| ELEM(fcu->ipo, BEZT_IPO_CONST, BEZT_IPO_LIN)*/) 
420                 return;
421         
422         /* get initial pointers */
423         bezt= fcu->bezt;
424         prev= NULL;
425         next= (bezt + 1);
426         
427         /* loop over all beztriples, adjusting handles */
428         while (a--) {
429                 /* clamp timing of handles to be on either side of beztriple */
430                 if (bezt->vec[0][0] > bezt->vec[1][0]) bezt->vec[0][0]= bezt->vec[1][0];
431                 if (bezt->vec[2][0] < bezt->vec[1][0]) bezt->vec[2][0]= bezt->vec[1][0];
432                 
433                 /* calculate auto-handles */
434                 if (fcu->flag & FCURVE_AUTO_HANDLES) 
435                         calchandleNurb(bezt, prev, next, 2);    /* 2==special autohandle && keep extrema horizontal */
436                 else
437                         calchandleNurb(bezt, prev, next, 1);    /* 1==special autohandle */
438                 
439                 /* for automatic ease in and out */
440                 if ((bezt->h1==HD_AUTO) && (bezt->h2==HD_AUTO)) {
441                         /* only do this on first or last beztriple */
442                         if ((a == 0) || (a == fcu->totvert-1)) {
443                                 /* set both handles to have same horizontal value as keyframe */
444                                 if (fcu->extend == FCURVE_EXTRAPOLATE_CONSTANT) {
445                                         bezt->vec[0][1]= bezt->vec[2][1]= bezt->vec[1][1];
446                                 }
447                         }
448                 }
449                 
450                 /* advance pointers for next iteration */
451                 prev= bezt;
452                 if (a == 1) next= NULL;
453                 else next++;
454                 bezt++;
455         }
456 }
457
458 /* Use when F-Curve with handles has changed
459  * It treats all BezTriples with the following rules:
460  *  - PHASE 1: do types have to be altered?
461  *              -> Auto handles: become aligned when selection status is NOT(000 || 111)
462  *              -> Vector handles: become 'nothing' when (one half selected AND other not)
463  *  - PHASE 2: recalculate handles
464 */
465 void testhandles_fcurve (FCurve *fcu)
466 {
467         BezTriple *bezt;
468         unsigned int a;
469
470         /* only beztriples have handles (bpoints don't though) */
471         if ELEM(NULL, fcu, fcu->bezt)
472                 return;
473         
474         /* loop over beztriples */
475         for (a=0, bezt=fcu->bezt; a < fcu->totvert; a++, bezt++) {
476                 short flag= 0;
477                 
478                 /* flag is initialised as selection status
479                  * of beztriple control-points (labelled 0,1,2)
480                  */
481                 if (bezt->f1 & SELECT) flag |= (1<<0); // == 1
482                 if (bezt->f2 & SELECT) flag |= (1<<1); // == 2
483                 if (bezt->f3 & SELECT) flag |= (1<<2); // == 4
484                 
485                 /* one or two handles selected only */
486                 if (ELEM(flag, 0, 7)==0) {
487                         /* auto handles become aligned */
488                         if (bezt->h1==HD_AUTO)
489                                 bezt->h1= HD_ALIGN;
490                         if (bezt->h2==HD_AUTO)
491                                 bezt->h2= HD_ALIGN;
492                         
493                         /* vector handles become 'free' when only one half selected */
494                         if (bezt->h1==HD_VECT) {
495                                 /* only left half (1 or 2 or 1+2) */
496                                 if (flag < 4) 
497                                         bezt->h1= 0;
498                         }
499                         if (bezt->h2==HD_VECT) {
500                                 /* only right half (4 or 2+4) */
501                                 if (flag > 3) 
502                                         bezt->h2= 0;
503                         }
504                 }
505         }
506
507         /* recalculate handles */
508         calchandles_fcurve(fcu);
509 }
510
511 /* This function sorts BezTriples so that they are arranged in chronological order,
512  * as tools working on F-Curves expect that the BezTriples are in order.
513  */
514 void sort_time_fcurve (FCurve *fcu)
515 {
516         short ok= 1;
517         
518         /* keep adjusting order of beztriples until nothing moves (bubble-sort) */
519         while (ok) {
520                 ok= 0;
521                 
522                 /* currently, will only be needed when there are beztriples */
523                 if (fcu->bezt) {
524                         BezTriple *bezt;
525                         unsigned int a;
526                         
527                         /* loop over ALL points to adjust position in array and recalculate handles */
528                         for (a=0, bezt=fcu->bezt; a < fcu->totvert; a++, bezt++) {
529                                 /* check if thee's a next beztriple which we could try to swap with current */
530                                 if (a < (fcu->totvert-1)) {
531                                         /* swap if one is after the other (and indicate that order has changed) */
532                                         if (bezt->vec[1][0] > (bezt+1)->vec[1][0]) {
533                                                 SWAP(BezTriple, *bezt, *(bezt+1));
534                                                 ok= 1;
535                                         }
536                                         
537                                         /* if either one of both of the points exceeds crosses over the keyframe time... */
538                                         if ( (bezt->vec[0][0] > bezt->vec[1][0]) && (bezt->vec[2][0] < bezt->vec[1][0]) ) {
539                                                 /* swap handles if they have switched sides for some reason */
540                                                 SWAP(float, bezt->vec[0][0], bezt->vec[2][0]);
541                                                 SWAP(float, bezt->vec[0][1], bezt->vec[2][1]);
542                                         }
543                                         else {
544                                                 /* clamp handles */
545                                                 if (bezt->vec[0][0] > bezt->vec[1][0]) 
546                                                         bezt->vec[0][0]= bezt->vec[1][0];
547                                                 if (bezt->vec[2][0] < bezt->vec[1][0]) 
548                                                         bezt->vec[2][0]= bezt->vec[1][0];
549                                         }
550                                 }
551                         }
552                 }
553         }
554 }
555
556 /* This function tests if any BezTriples are out of order, thus requiring a sort */
557 short test_time_fcurve (FCurve *fcu)
558 {
559         unsigned int a;
560         
561         /* sanity checks */
562         if (fcu == NULL)
563                 return 0;
564         
565         /* currently, only need to test beztriples */
566         if (fcu->bezt) {
567                 BezTriple *bezt;
568                 
569                 /* loop through all BezTriples, stopping when one exceeds the one after it */
570                 for (a=0, bezt= fcu->bezt; a < (fcu->totvert - 1); a++, bezt++) {
571                         if (bezt->vec[1][0] > (bezt+1)->vec[1][0])
572                                 return 1;
573                 }
574         }
575         else if (fcu->fpt) {
576                 FPoint *fpt;
577                 
578                 /* loop through all FPoints, stopping when one exceeds the one after it */
579                 for (a=0, fpt= fcu->fpt; a < (fcu->totvert - 1); a++, fpt++) {
580                         if (fpt->vec[0] > (fpt+1)->vec[0])
581                                 return 1;
582                 }
583         }
584         
585         /* none need any swapping */
586         return 0;
587 }
588
589 /* ***************************** Drivers ********************************* */
590
591 /* Driver API --------------------------------- */
592
593 /* This frees the driver target itself */
594 void driver_free_target (ChannelDriver *driver, DriverTarget *dtar)
595 {
596         /* sanity checks */
597         if (dtar == NULL)
598                 return;
599                 
600         /* free target vars */
601         if (dtar->rna_path)
602                 MEM_freeN(dtar->rna_path);
603         
604         /* remove the target from the driver */
605         if (driver)
606                 BLI_freelinkN(&driver->targets, dtar);
607         else
608                 MEM_freeN(dtar);
609 }
610
611 /* Add a new driver target variable */
612 DriverTarget *driver_add_new_target (ChannelDriver *driver)
613 {
614         DriverTarget *dtar;
615         
616         /* sanity checks */
617         if (driver == NULL)
618                 return NULL;
619                 
620         /* make a new target */
621         dtar= MEM_callocN(sizeof(DriverTarget), "DriverTarget");
622         BLI_addtail(&driver->targets, dtar);
623         
624         /* give the target a 'unique' name */
625         strcpy(dtar->name, "var");
626         BLI_uniquename(&driver->targets, dtar, "var", '_', offsetof(DriverTarget, name), 64);
627         
628         /* return the target */
629         return dtar;
630 }
631
632 /* This frees the driver itself */
633 void fcurve_free_driver(FCurve *fcu)
634 {
635         ChannelDriver *driver;
636         DriverTarget *dtar, *dtarn;
637         
638         /* sanity checks */
639         if ELEM(NULL, fcu, fcu->driver)
640                 return;
641         driver= fcu->driver;
642         
643         /* free driver targets */
644         for (dtar= driver->targets.first; dtar; dtar= dtarn) {
645                 dtarn= dtar->next;
646                 driver_free_target(driver, dtar);
647         }
648         
649         /* free driver itself, then set F-Curve's point to this to NULL (as the curve may still be used) */
650         MEM_freeN(driver);
651         fcu->driver= NULL;
652 }
653
654 /* This makes a copy of the given driver */
655 ChannelDriver *fcurve_copy_driver (ChannelDriver *driver)
656 {
657         ChannelDriver *ndriver;
658         DriverTarget *dtar;
659         
660         /* sanity checks */
661         if (driver == NULL)
662                 return NULL;
663                 
664         /* copy all data */
665         ndriver= MEM_dupallocN(driver);
666         
667         /* copy targets */
668         ndriver->targets.first= ndriver->targets.last= NULL;
669         BLI_duplicatelist(&ndriver->targets, &driver->targets);
670         
671         for (dtar= ndriver->targets.first; dtar; dtar= dtar->next) {
672                 /* make a copy of target's rna path if available */
673                 if (dtar->rna_path)
674                         dtar->rna_path = MEM_dupallocN(dtar->rna_path);
675         }
676         
677         /* return the new driver */
678         return ndriver;
679 }
680
681 /* Driver Evaluation -------------------------- */
682
683 /* Helper function to obtain a value using RNA from the specified source (for evaluating drivers) */
684 float driver_get_target_value (ChannelDriver *driver, DriverTarget *dtar)
685 {
686         PointerRNA id_ptr, ptr;
687         PropertyRNA *prop;
688         ID *id;
689         char *path;
690         int index;
691         float value= 0.0f;
692         
693         /* sanity check */
694         if ELEM(NULL, driver, dtar)
695                 return 0.0f;
696         
697         /* get RNA-pointer for the ID-block given in target */
698         RNA_id_pointer_create(dtar->id, &id_ptr);
699         id= dtar->id;
700         path= dtar->rna_path;
701         index= dtar->array_index;
702         
703         /* error check for missing pointer... */
704         if (id == NULL) {
705                 printf("Error: driver doesn't have any valid target to use \n");
706                 if (G.f & G_DEBUG) printf("\tpath = %s [%d] \n", path, index);
707                 driver->flag |= DRIVER_FLAG_INVALID;
708                 return 0.0f;
709         }
710         
711         /* get property to read from, and get value as appropriate */
712         if (RNA_path_resolve(&id_ptr, path, &ptr, &prop)) {
713                 switch (RNA_property_type(prop)) {
714                         case PROP_BOOLEAN:
715                                 if (RNA_property_array_length(prop))
716                                         value= (float)RNA_property_boolean_get_index(&ptr, prop, index);
717                                 else
718                                         value= (float)RNA_property_boolean_get(&ptr, prop);
719                                 break;
720                         case PROP_INT:
721                                 if (RNA_property_array_length(prop))
722                                         value= (float)RNA_property_int_get_index(&ptr, prop, index);
723                                 else
724                                         value= (float)RNA_property_int_get(&ptr, prop);
725                                 break;
726                         case PROP_FLOAT:
727                                 if (RNA_property_array_length(prop))
728                                         value= RNA_property_float_get_index(&ptr, prop, index);
729                                 else
730                                         value= RNA_property_float_get(&ptr, prop);
731                                 break;
732                         case PROP_ENUM:
733                                 value= (float)RNA_property_enum_get(&ptr, prop);
734                                 break;
735                         default:
736                                 break;
737                 }
738         }
739         
740         return value;
741 }
742
743 /* Get two PoseChannels from the targets of the given Driver */
744 static void driver_get_target_pchans2 (ChannelDriver *driver, bPoseChannel **pchan1, bPoseChannel **pchan2)
745 {
746         DriverTarget *dtar;
747         short i = 0;
748         
749         /* before doing anything */
750         *pchan1= NULL;
751         *pchan2= NULL;
752         
753         /* only take the first two targets */
754         for (dtar= driver->targets.first; (dtar) && (i < 2); dtar=dtar->next, i++) {
755                 PointerRNA id_ptr, ptr;
756                 PropertyRNA *prop;
757                 
758                 /* get RNA-pointer for the ID-block given in target */
759                 if (dtar->id)
760                         RNA_id_pointer_create(dtar->id, &id_ptr);
761                 else
762                         continue;
763                 
764                 /* resolve path so that we have pointer to the right posechannel */
765                 if (RNA_path_resolve(&id_ptr, dtar->rna_path, &ptr, &prop)) {
766                         /* is pointer valid (i.e. pointing to an actual posechannel */
767                         if ((ptr.type == &RNA_PoseChannel) && (ptr.data)) {
768                                 /* first or second target? */
769                                 if (i)
770                                         *pchan1= ptr.data;
771                                 else
772                                         *pchan2= ptr.data;
773                         }
774                 }
775         }
776 }
777
778 /* Evaluate an Channel-Driver to get a 'time' value to use instead of "evaltime"
779  *      - "evaltime" is the frame at which F-Curve is being evaluated
780  *      - has to return a float value 
781  */
782 static float evaluate_driver (ChannelDriver *driver, float evaltime)
783 {
784         DriverTarget *dtar;
785         
786         /* check if driver can be evaluated */
787         if (driver->flag & DRIVER_FLAG_INVALID)
788                 return 0.0f;
789         
790         // TODO: the flags for individual targets need to be used too for more fine-grained support...
791         switch (driver->type) {
792                 case DRIVER_TYPE_AVERAGE: /* average values of driver targets */
793                 {
794                         /* check how many targets there are first (i.e. just one?) */
795                         if (driver->targets.first == driver->targets.last) {
796                                 /* just one target, so just use that */
797                                 dtar= driver->targets.first;
798                                 return driver_get_target_value(driver, dtar);
799                         }
800                         else {
801                                 /* more than one target, so average the values of the targets */
802                                 int tot = 0;
803                                 float value = 0.0f;
804                                 
805                                 /* loop through targets, adding (hopefully we don't get any overflow!) */
806                                 for (dtar= driver->targets.first; dtar; dtar=dtar->next) {
807                                         value += driver_get_target_value(driver, dtar); 
808                                         tot++;
809                                 }
810                                 
811                                 /* return the average of these */
812                                 return (value / (float)tot);
813                         }
814                 }
815                         break;
816                 
817                 case DRIVER_TYPE_PYTHON: /* expression */
818                 {
819 #ifndef DISABLE_PYTHON
820                         /* check for empty or invalid expression */
821                         if ( (driver->expression[0] == '\0') ||
822                                  (driver->flag & DRIVER_FLAG_INVALID) )
823                         {
824                                 return 0.0f;
825                         }
826                         
827                         /* this evaluates the expression using Python,and returns its result:
828                          *      - on errors it reports, then returns 0.0f
829                          */
830                         return BPY_pydriver_eval(driver);
831 #endif /* DISABLE_PYTHON*/
832                 }
833                         break;
834
835                 
836                 case DRIVER_TYPE_ROTDIFF: /* difference of rotations of 2 bones (should ideally be in same armature) */
837                 {
838                         bPoseChannel *pchan, *pchan2;
839                         float q1[4], q2[4], quat[4], angle;
840                         
841                         /* get pose channels, and check if we've got two */
842                         driver_get_target_pchans2(driver, &pchan, &pchan2);
843                         if (ELEM(NULL, pchan, pchan2)) {
844                                 /* disable this driver, since it doesn't work correctly... */
845                                 driver->flag |= DRIVER_FLAG_INVALID;
846                                 
847                                 /* check what the error was */
848                                 if ((pchan == NULL) && (pchan2 == NULL))
849                                         printf("Driver Evaluation Error: Rotational difference failed - first 2 targets invalid \n");
850                                 else if (pchan == NULL)
851                                         printf("Driver Evaluation Error: Rotational difference failed - first target not valid PoseChannel \n");
852                                 else if (pchan2 == NULL)
853                                         printf("Driver Evaluation Error: Rotational difference failed - second target not valid PoseChannel \n");
854                                         
855                                 /* stop here... */
856                                 return 0.0f;
857                         }                       
858                         
859                         /* use the final posed locations */
860                         Mat4ToQuat(pchan->pose_mat, q1);
861                         Mat4ToQuat(pchan2->pose_mat, q2);
862                         
863                         QuatInv(q1);
864                         QuatMul(quat, q1, q2);
865                         angle = 2.0f * (saacos(quat[0]));
866                         angle= ABS(angle);
867                         
868                         return (angle > M_PI) ? (float)((2.0f * M_PI) - angle) : (float)(angle);
869                 }
870                         break;
871                 
872                 default:
873                 {
874                         /* special 'hack' - just use stored value 
875                          *      This is currently used as the mechanism which allows animated settings to be able
876                          *      to be changed via the UI.
877                          */
878                         return driver->curval;
879                 }
880         }
881         
882         /* return 0.0f, as couldn't find relevant data to use */
883         return 0.0f;
884 }
885
886 /* ***************************** Curve Calculations ********************************* */
887
888 /* The total length of the handles is not allowed to be more
889  * than the horizontal distance between (v1-v4).
890  * This is to prevent curve loops.
891 */
892 void correct_bezpart (float *v1, float *v2, float *v3, float *v4)
893 {
894         float h1[2], h2[2], len1, len2, len, fac;
895         
896         /* calculate handle deltas */
897         h1[0]= v1[0] - v2[0];
898         h1[1]= v1[1] - v2[1];
899         
900         h2[0]= v4[0] - v3[0];
901         h2[1]= v4[1] - v3[1];
902         
903         /* calculate distances: 
904          *      - len   = span of time between keyframes 
905          *      - len1  = length of handle of start key
906          *      - len2  = length of handle of end key
907          */
908         len= v4[0]- v1[0];
909         len1= (float)fabs(h1[0]);
910         len2= (float)fabs(h2[0]);
911         
912         /* if the handles have no length, no need to do any corrections */
913         if ((len1+len2) == 0.0f) 
914                 return;
915                 
916         /* the two handles cross over each other, so force them
917          * apart using the proportion they overlap 
918          */
919         if ((len1+len2) > len) {
920                 fac= len / (len1+len2);
921                 
922                 v2[0]= (v1[0] - fac*h1[0]);
923                 v2[1]= (v1[1] - fac*h1[1]);
924                 
925                 v3[0]= (v4[0] - fac*h2[0]);
926                 v3[1]= (v4[1] - fac*h2[1]);
927         }
928 }
929
930 /* find root ('zero') */
931 int findzero (float x, float q0, float q1, float q2, float q3, float *o)
932 {
933         double c0, c1, c2, c3, a, b, c, p, q, d, t, phi;
934         int nr= 0;
935
936         c0= q0 - x;
937         c1= 3.0 * (q1 - q0);
938         c2= 3.0 * (q0 - 2.0*q1 + q2);
939         c3= q3 - q0 + 3.0 * (q1 - q2);
940         
941         if (c3 != 0.0) {
942                 a= c2/c3;
943                 b= c1/c3;
944                 c= c0/c3;
945                 a= a/3;
946                 
947                 p= b/3 - a*a;
948                 q= (2*a*a*a - a*b + c) / 2;
949                 d= q*q + p*p*p;
950                 
951                 if (d > 0.0) {
952                         t= sqrt(d);
953                         o[0]= (float)(Sqrt3d(-q+t) + Sqrt3d(-q-t) - a);
954                         
955                         if ((o[0] >= SMALL) && (o[0] <= 1.000001)) return 1;
956                         else return 0;
957                 }
958                 else if (d == 0.0) {
959                         t= Sqrt3d(-q);
960                         o[0]= (float)(2*t - a);
961                         
962                         if ((o[0] >= SMALL) && (o[0] <= 1.000001)) nr++;
963                         o[nr]= (float)(-t-a);
964                         
965                         if ((o[nr] >= SMALL) && (o[nr] <= 1.000001)) return nr+1;
966                         else return nr;
967                 }
968                 else {
969                         phi= acos(-q / sqrt(-(p*p*p)));
970                         t= sqrt(-p);
971                         p= cos(phi/3);
972                         q= sqrt(3 - 3*p*p);
973                         o[0]= (float)(2*t*p - a);
974                         
975                         if ((o[0] >= SMALL) && (o[0] <= 1.000001)) nr++;
976                         o[nr]= (float)(-t * (p + q) - a);
977                         
978                         if ((o[nr] >= SMALL) && (o[nr] <= 1.000001)) nr++;
979                         o[nr]= (float)(-t * (p - q) - a);
980                         
981                         if ((o[nr] >= SMALL) && (o[nr] <= 1.000001)) return nr+1;
982                         else return nr;
983                 }
984         }
985         else {
986                 a=c2;
987                 b=c1;
988                 c=c0;
989                 
990                 if (a != 0.0) {
991                         // discriminant
992                         p= b*b - 4*a*c;
993                         
994                         if (p > 0) {
995                                 p= sqrt(p);
996                                 o[0]= (float)((-b-p) / (2 * a));
997                                 
998                                 if ((o[0] >= SMALL) && (o[0] <= 1.000001)) nr++;
999                                 o[nr]= (float)((-b+p)/(2*a));
1000                                 
1001                                 if ((o[nr] >= SMALL) && (o[nr] <= 1.000001)) return nr+1;
1002                                 else return nr;
1003                         }
1004                         else if (p == 0) {
1005                                 o[0]= (float)(-b / (2 * a));
1006                                 if ((o[0] >= SMALL) && (o[0] <= 1.000001)) return 1;
1007                                 else return 0;
1008                         }
1009                 }
1010                 else if (b != 0.0) {
1011                         o[0]= (float)(-c/b);
1012                         
1013                         if ((o[0] >= SMALL) && (o[0] <= 1.000001)) return 1;
1014                         else return 0;
1015                 }
1016                 else if (c == 0.0) {
1017                         o[0]= 0.0;
1018                         return 1;
1019                 }
1020                 
1021                 return 0;       
1022         }
1023 }
1024
1025 void berekeny (float f1, float f2, float f3, float f4, float *o, int b)
1026 {
1027         float t, c0, c1, c2, c3;
1028         int a;
1029
1030         c0= f1;
1031         c1= 3.0f * (f2 - f1);
1032         c2= 3.0f * (f1 - 2.0f*f2 + f3);
1033         c3= f4 - f1 + 3.0f * (f2 - f3);
1034         
1035         for (a=0; a < b; a++) {
1036                 t= o[a];
1037                 o[a]= c0 + t*c1 + t*t*c2 + t*t*t*c3;
1038         }
1039 }
1040
1041 void berekenx (float *f, float *o, int b)
1042 {
1043         float t, c0, c1, c2, c3;
1044         int a;
1045
1046         c0= f[0];
1047         c1= 3.0f * (f[3] - f[0]);
1048         c2= 3.0f * (f[0] - 2.0f*f[3] + f[6]);
1049         c3= f[9] - f[0] + 3.0f * (f[3] - f[6]);
1050         
1051         for (a=0; a < b; a++) {
1052                 t= o[a];
1053                 o[a]= c0 + t*c1 + t*t*c2 + t*t*t*c3;
1054         }
1055 }
1056
1057
1058 /* -------------------------- */
1059
1060 /* Calculate F-Curve value for 'evaltime' using BezTriple keyframes */
1061 static float fcurve_eval_keyframes (FCurve *fcu, BezTriple *bezts, float evaltime)
1062 {
1063         BezTriple *bezt, *prevbezt, *lastbezt;
1064         float v1[2], v2[2], v3[2], v4[2], opl[32], dx, fac;
1065         unsigned int a;
1066         int b;
1067         float cvalue = 0.0f;
1068         
1069         /* get pointers */
1070         a= fcu->totvert-1;
1071         prevbezt= bezts;
1072         bezt= prevbezt+1;
1073         lastbezt= prevbezt + a;
1074         
1075         /* evaluation time at or past endpoints? */
1076         if (prevbezt->vec[1][0] >= evaltime) 
1077         {
1078                 /* before or on first keyframe */
1079                 if ( (fcu->extend == FCURVE_EXTRAPOLATE_LINEAR) && (prevbezt->ipo != BEZT_IPO_CONST) &&
1080                         !(fcu->flag & FCURVE_DISCRETE_VALUES) ) 
1081                 {
1082                         /* linear or bezier interpolation */
1083                         if (prevbezt->ipo==BEZT_IPO_LIN) 
1084                         {
1085                                 /* Use the next center point instead of our own handle for
1086                                  * linear interpolated extrapolate 
1087                                  */
1088                                 if (fcu->totvert == 1) 
1089                                         cvalue= prevbezt->vec[1][1];
1090                                 else 
1091                                 {
1092                                         bezt = prevbezt+1;
1093                                         dx= prevbezt->vec[1][0] - evaltime;
1094                                         fac= bezt->vec[1][0] - prevbezt->vec[1][0];
1095                                         
1096                                         /* prevent division by zero */
1097                                         if (fac) {
1098                                                 fac= (bezt->vec[1][1] - prevbezt->vec[1][1]) / fac;
1099                                                 cvalue= prevbezt->vec[1][1] - (fac * dx);
1100                                         }
1101                                         else 
1102                                                 cvalue= prevbezt->vec[1][1];
1103                                 }
1104                         } 
1105                         else 
1106                         {
1107                                 /* Use the first handle (earlier) of first BezTriple to calculate the
1108                                  * gradient and thus the value of the curve at evaltime
1109                                  */
1110                                 dx= prevbezt->vec[1][0] - evaltime;
1111                                 fac= prevbezt->vec[1][0] - prevbezt->vec[0][0];
1112                                 
1113                                 /* prevent division by zero */
1114                                 if (fac) {
1115                                         fac= (prevbezt->vec[1][1] - prevbezt->vec[0][1]) / fac;
1116                                         cvalue= prevbezt->vec[1][1] - (fac * dx);
1117                                 }
1118                                 else 
1119                                         cvalue= prevbezt->vec[1][1];
1120                         }
1121                 }
1122                 else 
1123                 {
1124                         /* constant (BEZT_IPO_HORIZ) extrapolation or constant interpolation, 
1125                          * so just extend first keyframe's value 
1126                          */
1127                         cvalue= prevbezt->vec[1][1];
1128                 }
1129         }
1130         else if (lastbezt->vec[1][0] <= evaltime) 
1131         {
1132                 /* after or on last keyframe */
1133                 if ( (fcu->extend == FCURVE_EXTRAPOLATE_LINEAR) && (lastbezt->ipo != BEZT_IPO_CONST) &&
1134                         !(fcu->flag & FCURVE_DISCRETE_VALUES) ) 
1135                 {
1136                         /* linear or bezier interpolation */
1137                         if (lastbezt->ipo==BEZT_IPO_LIN) 
1138                         {
1139                                 /* Use the next center point instead of our own handle for
1140                                  * linear interpolated extrapolate 
1141                                  */
1142                                 if (fcu->totvert == 1) 
1143                                         cvalue= lastbezt->vec[1][1];
1144                                 else 
1145                                 {
1146                                         prevbezt = lastbezt - 1;
1147                                         dx= evaltime - lastbezt->vec[1][0];
1148                                         fac= lastbezt->vec[1][0] - prevbezt->vec[1][0];
1149                                         
1150                                         /* prevent division by zero */
1151                                         if (fac) {
1152                                                 fac= (lastbezt->vec[1][1] - prevbezt->vec[1][1]) / fac;
1153                                                 cvalue= lastbezt->vec[1][1] + (fac * dx);
1154                                         }
1155                                         else 
1156                                                 cvalue= lastbezt->vec[1][1];
1157                                 }
1158                         } 
1159                         else 
1160                         {
1161                                 /* Use the gradient of the second handle (later) of last BezTriple to calculate the
1162                                  * gradient and thus the value of the curve at evaltime
1163                                  */
1164                                 dx= evaltime - lastbezt->vec[1][0];
1165                                 fac= lastbezt->vec[2][0] - lastbezt->vec[1][0];
1166                                 
1167                                 /* prevent division by zero */
1168                                 if (fac) {
1169                                         fac= (lastbezt->vec[2][1] - lastbezt->vec[1][1]) / fac;
1170                                         cvalue= lastbezt->vec[1][1] + (fac * dx);
1171                                 }
1172                                 else 
1173                                         cvalue= lastbezt->vec[1][1];
1174                         }
1175                 }
1176                 else 
1177                 {
1178                         /* constant (BEZT_IPO_HORIZ) extrapolation or constant interpolation, 
1179                          * so just extend last keyframe's value 
1180                          */
1181                         cvalue= lastbezt->vec[1][1];
1182                 }
1183         }
1184         else 
1185         {
1186                 /* evaltime occurs somewhere in the middle of the curve */
1187                 for (a=0; prevbezt && bezt && (a < fcu->totvert-1); a++, prevbezt=bezt, bezt++) 
1188                 {  
1189                         /* evaltime occurs within the interval defined by these two keyframes */
1190                         if ((prevbezt->vec[1][0] <= evaltime) && (bezt->vec[1][0] >= evaltime)) 
1191                         {
1192                                 /* value depends on interpolation mode */
1193                                 if ((prevbezt->ipo == BEZT_IPO_CONST) || (fcu->flag & FCURVE_DISCRETE_VALUES))
1194                                 {
1195                                         /* constant (evaltime not relevant, so no interpolation needed) */
1196                                         cvalue= prevbezt->vec[1][1];
1197                                 }
1198                                 else if (prevbezt->ipo == BEZT_IPO_LIN) 
1199                                 {
1200                                         /* linear - interpolate between values of the two keyframes */
1201                                         fac= bezt->vec[1][0] - prevbezt->vec[1][0];
1202                                         
1203                                         /* prevent division by zero */
1204                                         if (fac) {
1205                                                 fac= (evaltime - prevbezt->vec[1][0]) / fac;
1206                                                 cvalue= prevbezt->vec[1][1] + (fac * (bezt->vec[1][1] - prevbezt->vec[1][1]));
1207                                         }
1208                                         else
1209                                                 cvalue= prevbezt->vec[1][1];
1210                                 }
1211                                 else 
1212                                 {
1213                                         /* bezier interpolation */
1214                                                 /* v1,v2 are the first keyframe and its 2nd handle */
1215                                         v1[0]= prevbezt->vec[1][0];
1216                                         v1[1]= prevbezt->vec[1][1];
1217                                         v2[0]= prevbezt->vec[2][0];
1218                                         v2[1]= prevbezt->vec[2][1];
1219                                                 /* v3,v4 are the last keyframe's 1st handle + the last keyframe */
1220                                         v3[0]= bezt->vec[0][0];
1221                                         v3[1]= bezt->vec[0][1];
1222                                         v4[0]= bezt->vec[1][0];
1223                                         v4[1]= bezt->vec[1][1];
1224                                         
1225                                         /* adjust handles so that they don't overlap (forming a loop) */
1226                                         correct_bezpart(v1, v2, v3, v4);
1227                                         
1228                                         /* try to get a value for this position - if failure, try another set of points */
1229                                         b= findzero(evaltime, v1[0], v2[0], v3[0], v4[0], opl);
1230                                         if (b) {
1231                                                 berekeny(v1[1], v2[1], v3[1], v4[1], opl, 1);
1232                                                 cvalue= opl[0];
1233                                                 break;
1234                                         }
1235                                 }
1236                         }
1237                 }
1238         }
1239         
1240         /* return value */
1241         return cvalue;
1242 }
1243
1244 /* Calculate F-Curve value for 'evaltime' using FPoint samples */
1245 static float fcurve_eval_samples (FCurve *fcu, FPoint *fpts, float evaltime)
1246 {
1247         FPoint *prevfpt, *lastfpt, *fpt;
1248         float cvalue= 0.0f;
1249         
1250         /* get pointers */
1251         prevfpt= fpts;
1252         lastfpt= prevfpt + fcu->totvert-1;
1253         
1254         /* evaluation time at or past endpoints? */
1255         if (prevfpt->vec[0] >= evaltime) {
1256                 /* before or on first sample, so just extend value */
1257                 cvalue= prevfpt->vec[1];
1258         }
1259         else if (lastfpt->vec[0] <= evaltime) {
1260                 /* after or on last sample, so just extend value */
1261                 cvalue= lastfpt->vec[1];
1262         }
1263         else {
1264                 /* find the one on the right frame (assume that these are spaced on 1-frame intervals) */
1265                 fpt= prevfpt + (int)(evaltime - prevfpt->vec[0]);
1266                 cvalue= fpt->vec[1];
1267         }
1268         
1269         /* return value */
1270         return cvalue;
1271 }
1272
1273 /* ***************************** F-Curve - Evaluation ********************************* */
1274
1275 /* Evaluate and return the value of the given F-Curve at the specified frame ("evaltime") 
1276  * Note: this is also used for drivers
1277  */
1278 float evaluate_fcurve (FCurve *fcu, float evaltime) 
1279 {
1280         float cvalue= 0.0f;
1281         float devaltime;
1282         
1283         /* if there is a driver (only if this F-Curve is acting as 'driver'), evaluate it to find value to use as "evaltime" 
1284          * since drivers essentially act as alternative input (i.e. in place of 'time') for F-Curves
1285          *      - this value will also be returned as the value of the 'curve', if there are no keyframes
1286          */
1287         if (fcu->driver) {
1288                 /* evaltime now serves as input for the curve */
1289                 evaltime= cvalue= evaluate_driver(fcu->driver, evaltime);
1290         }
1291         
1292         /* evaluate modifiers which modify time to evaluate the base curve at */
1293         devaltime= evaluate_time_fmodifiers(&fcu->modifiers, fcu, cvalue, evaltime);
1294         
1295         /* evaluate curve-data 
1296          *      - 'devaltime' instead of 'evaltime', as this is the time that the last time-modifying 
1297          *        F-Curve modifier on the stack requested the curve to be evaluated at
1298          */
1299         if (fcu->bezt)
1300                 cvalue= fcurve_eval_keyframes(fcu, fcu->bezt, devaltime);
1301         else if (fcu->fpt)
1302                 cvalue= fcurve_eval_samples(fcu, fcu->fpt, devaltime);
1303         
1304         /* evaluate modifiers */
1305         evaluate_value_fmodifiers(&fcu->modifiers, fcu, &cvalue, evaltime);
1306         
1307         /* if curve can only have integral values, perform truncation (i.e. drop the decimal part)
1308          * here so that the curve can be sampled correctly
1309          */
1310         if (fcu->flag & FCURVE_INT_VALUES)
1311                 cvalue= (float)((int)cvalue);
1312         
1313         /* return evaluated value */
1314         return cvalue;
1315 }
1316
1317 /* Calculate the value of the given F-Curve at the given frame, and set its curval */
1318 void calculate_fcurve (FCurve *fcu, float ctime)
1319 {
1320         /* only calculate + set curval (overriding the existing value) if curve has 
1321          * any data which warrants this...
1322          */
1323         if ( (fcu->totvert) || (fcu->driver && !(fcu->driver->flag & DRIVER_FLAG_INVALID)) ||
1324                  list_has_suitable_fmodifier(&fcu->modifiers, 0, FMI_TYPE_GENERATE_CURVE) )
1325         {
1326                 /* calculate and set curval (evaluates driver too if necessary) */
1327                 fcu->curval= evaluate_fcurve(fcu, ctime);
1328         }
1329 }
1330