Cleanup: comments (long lines) in blenkernel
[blender.git] / source / blender / blenkernel / intern / fmodifier.c
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  *
16  * The Original Code is Copyright (C) 2009 Blender Foundation, Joshua Leung
17  * All rights reserved.
18  */
19
20 /** \file
21  * \ingroup bke
22  */
23
24 #include <math.h>
25 #include <stdio.h>
26 #include <stddef.h>
27 #include <string.h>
28 #include <float.h>
29
30 #include "MEM_guardedalloc.h"
31
32 #include "CLG_log.h"
33
34 #include "DNA_anim_types.h"
35
36 #include "BLT_translation.h"
37
38 #include "BLI_blenlib.h"
39 #include "BLI_ghash.h"
40 #include "BLI_noise.h"
41 #include "BLI_math.h" /* windows needs for M_PI */
42 #include "BLI_utildefines.h"
43
44 #include "BKE_fcurve.h"
45 #include "BKE_idprop.h"
46
47 static CLG_LogRef LOG = {"bke.fmodifier"};
48
49 /* ******************************** F-Modifiers ********************************* */
50
51 /* Info ------------------------------- */
52
53 /* F-Modifiers are modifiers which operate on F-Curves. However, they can also be defined
54  * on NLA-Strips to affect all of the F-Curves referenced by the NLA-Strip.
55  */
56
57 /* Template --------------------------- */
58
59 /* Each modifier defines a set of functions, which will be called at the appropriate
60  * times. In addition to this, each modifier should have a type-info struct, where
61  * its functions are attached for use.
62  */
63
64 /* Template for type-info data:
65  * - make a copy of this when creating new modifiers, and just change the functions
66  *   pointed to as necessary
67  * - although the naming of functions doesn't matter, it would help for code
68  *   readability, to follow the same naming convention as is presented here
69  * - any functions that a constraint doesn't need to define, don't define
70  *   for such cases, just use NULL
71  * - these should be defined after all the functions have been defined, so that
72  *   forward-definitions/prototypes don't need to be used!
73  * - keep this copy #if-def'd so that future modifier can get based off this
74  */
75 #if 0
76 static FModifierTypeInfo FMI_MODNAME = {
77     FMODIFIER_TYPE_MODNAME,        /* type */
78     sizeof(FMod_ModName),          /* size */
79     FMI_TYPE_SOME_ACTION,          /* action type */
80     FMI_REQUIRES_SOME_REQUIREMENT, /* requirements */
81     "Modifier Name",               /* name */
82     "FMod_ModName",                /* struct name */
83     0,                             /* storage size */
84     fcm_modname_free,              /* free data */
85     fcm_modname_relink,            /* relink data */
86     fcm_modname_copy,              /* copy data */
87     fcm_modname_new_data,          /* new data */
88     fcm_modname_verify,            /* verify */
89     fcm_modname_time,              /* evaluate time */
90     fcm_modname_evaluate,          /* evaluate */
91 };
92 #endif
93
94 /* Generator F-Curve Modifier --------------------------- */
95
96 /* Generators available:
97  *  1) simple polynomial generator:
98  *     - Expanded form:
99  *       (y = C[0]*(x^(n)) + C[1]*(x^(n-1)) + ... + C[n])
100  *     - Factorized form:
101  *       (y = (C[0][0]*x + C[0][1]) * (C[1][0]*x + C[1][1]) * ... * (C[n][0]*x + C[n][1]))
102  */
103
104 static void fcm_generator_free(FModifier *fcm)
105 {
106   FMod_Generator *data = (FMod_Generator *)fcm->data;
107
108   /* free polynomial coefficients array */
109   if (data->coefficients) {
110     MEM_freeN(data->coefficients);
111   }
112 }
113
114 static void fcm_generator_copy(FModifier *fcm, const FModifier *src)
115 {
116   FMod_Generator *gen = (FMod_Generator *)fcm->data;
117   FMod_Generator *ogen = (FMod_Generator *)src->data;
118
119   /* copy coefficients array? */
120   if (ogen->coefficients) {
121     gen->coefficients = MEM_dupallocN(ogen->coefficients);
122   }
123 }
124
125 static void fcm_generator_new_data(void *mdata)
126 {
127   FMod_Generator *data = (FMod_Generator *)mdata;
128   float *cp;
129
130   /* set default generator to be linear 0-1 (gradient = 1, y-offset = 0) */
131   data->poly_order = 1;
132   data->arraysize = 2;
133   cp = data->coefficients = MEM_callocN(sizeof(float) * 2, "FMod_Generator_Coefs");
134   cp[0] = 0;  // y-offset
135   cp[1] = 1;  // gradient
136 }
137
138 static void fcm_generator_verify(FModifier *fcm)
139 {
140   FMod_Generator *data = (FMod_Generator *)fcm->data;
141
142   /* requirements depend on mode */
143   switch (data->mode) {
144     case FCM_GENERATOR_POLYNOMIAL: /* expanded polynomial expression */
145     {
146       const int arraysize_new = data->poly_order + 1;
147       /* arraysize needs to be order+1, so resize if not */
148       if (data->arraysize != arraysize_new) {
149         data->coefficients = MEM_recallocN(data->coefficients, sizeof(float) * arraysize_new);
150         data->arraysize = arraysize_new;
151       }
152       break;
153     }
154     case FCM_GENERATOR_POLYNOMIAL_FACTORISED: /* expanded polynomial expression */
155     {
156       const int arraysize_new = data->poly_order * 2;
157       /* arraysize needs to be (2 * order), so resize if not */
158       if (data->arraysize != arraysize_new) {
159         data->coefficients = MEM_recallocN(data->coefficients, sizeof(float) * arraysize_new);
160         data->arraysize = arraysize_new;
161       }
162       break;
163     }
164   }
165 }
166
167 static void fcm_generator_evaluate(
168     FCurve *UNUSED(fcu), FModifier *fcm, float *cvalue, float evaltime, void *UNUSED(storage))
169 {
170   FMod_Generator *data = (FMod_Generator *)fcm->data;
171
172   /* behavior depends on mode
173    * NOTE: the data in its default state is fine too
174    */
175   switch (data->mode) {
176     case FCM_GENERATOR_POLYNOMIAL: /* expanded polynomial expression */
177     {
178       /* we overwrite cvalue with the sum of the polynomial */
179       float *powers = MEM_callocN(sizeof(float) * data->arraysize, "Poly Powers");
180       float value = 0.0f;
181       unsigned int i;
182
183       /* for each x^n, precalculate value based on previous one first... this should be
184        * faster that calling pow() for each entry
185        */
186       for (i = 0; i < data->arraysize; i++) {
187         /* first entry is x^0 = 1, otherwise, calculate based on previous */
188         if (i) {
189           powers[i] = powers[i - 1] * evaltime;
190         }
191         else {
192           powers[0] = 1;
193         }
194       }
195
196       /* for each coefficient, add to value, which we'll write to *cvalue in one go */
197       for (i = 0; i < data->arraysize; i++) {
198         value += data->coefficients[i] * powers[i];
199       }
200
201       /* only if something changed, write *cvalue in one go */
202       if (data->poly_order) {
203         if (data->flag & FCM_GENERATOR_ADDITIVE) {
204           *cvalue += value;
205         }
206         else {
207           *cvalue = value;
208         }
209       }
210
211       /* cleanup */
212       if (powers) {
213         MEM_freeN(powers);
214       }
215       break;
216     }
217     case FCM_GENERATOR_POLYNOMIAL_FACTORISED: /* Factorized polynomial */
218     {
219       float value = 1.0f, *cp = NULL;
220       unsigned int i;
221
222       /* For each coefficient pair,
223        * solve for that bracket before accumulating in value by multiplying. */
224       for (cp = data->coefficients, i = 0; (cp) && (i < (uint)data->poly_order); cp += 2, i++) {
225         value *= (cp[0] * evaltime + cp[1]);
226       }
227
228       /* only if something changed, write *cvalue in one go */
229       if (data->poly_order) {
230         if (data->flag & FCM_GENERATOR_ADDITIVE) {
231           *cvalue += value;
232         }
233         else {
234           *cvalue = value;
235         }
236       }
237       break;
238     }
239   }
240 }
241
242 static FModifierTypeInfo FMI_GENERATOR = {
243     FMODIFIER_TYPE_GENERATOR, /* type */
244     sizeof(FMod_Generator),   /* size */
245     FMI_TYPE_GENERATE_CURVE,  /* action type */
246     FMI_REQUIRES_NOTHING,     /* requirements */
247     N_("Generator"),          /* name */
248     "FMod_Generator",         /* struct name */
249     0,                        /* storage size */
250     fcm_generator_free,       /* free data */
251     fcm_generator_copy,       /* copy data */
252     fcm_generator_new_data,   /* new data */
253     fcm_generator_verify,     /* verify */
254     NULL,                     /* evaluate time */
255     fcm_generator_evaluate,   /* evaluate */
256 };
257
258 /* Built-In Function Generator F-Curve Modifier --------------------------- */
259
260 /* This uses the general equation for equations:
261  *   y = amplitude * fn(phase_multiplier * x + phase_offset) + y_offset
262  *
263  * where amplitude, phase_multiplier/offset, y_offset are user-defined coefficients,
264  * x is the evaluation 'time', and 'y' is the resultant value
265  *
266  * Functions available are
267  * sin, cos, tan, sinc (normalized sin), natural log, square root
268  */
269
270 static void fcm_fn_generator_new_data(void *mdata)
271 {
272   FMod_FunctionGenerator *data = (FMod_FunctionGenerator *)mdata;
273
274   /* set amplitude and phase multiplier to 1.0f so that something is generated */
275   data->amplitude = 1.0f;
276   data->phase_multiplier = 1.0f;
277 }
278
279 /* Unary 'normalized sine' function
280  * y = sin(PI + x) / (PI * x),
281  * except for x = 0 when y = 1.
282  */
283 static double sinc(double x)
284 {
285   if (fabs(x) < 0.0001) {
286     return 1.0;
287   }
288   else {
289     return sin(M_PI * x) / (M_PI * x);
290   }
291 }
292
293 static void fcm_fn_generator_evaluate(
294     FCurve *UNUSED(fcu), FModifier *fcm, float *cvalue, float evaltime, void *UNUSED(storage))
295 {
296   FMod_FunctionGenerator *data = (FMod_FunctionGenerator *)fcm->data;
297   double arg = data->phase_multiplier * evaltime + data->phase_offset;
298   double (*fn)(double v) = NULL;
299
300   /* get function pointer to the func to use:
301    * WARNING: must perform special argument validation hereto guard against crashes
302    */
303   switch (data->type) {
304     /* simple ones */
305     case FCM_GENERATOR_FN_SIN: /* sine wave */
306       fn = sin;
307       break;
308     case FCM_GENERATOR_FN_COS: /* cosine wave */
309       fn = cos;
310       break;
311     case FCM_GENERATOR_FN_SINC: /* normalized sine wave */
312       fn = sinc;
313       break;
314
315     /* validation required */
316     case FCM_GENERATOR_FN_TAN: /* tangent wave */
317     {
318       /* check that argument is not on one of the discontinuities (i.e. 90deg, 270 deg, etc) */
319       if (IS_EQ(fmod((arg - M_PI_2), M_PI), 0.0)) {
320         if ((data->flag & FCM_GENERATOR_ADDITIVE) == 0) {
321           *cvalue = 0.0f; /* no value possible here */
322         }
323       }
324       else {
325         fn = tan;
326       }
327       break;
328     }
329     case FCM_GENERATOR_FN_LN: /* natural log */
330     {
331       /* check that value is greater than 1? */
332       if (arg > 1.0) {
333         fn = log;
334       }
335       else {
336         if ((data->flag & FCM_GENERATOR_ADDITIVE) == 0) {
337           *cvalue = 0.0f; /* no value possible here */
338         }
339       }
340       break;
341     }
342     case FCM_GENERATOR_FN_SQRT: /* square root */
343     {
344       /* no negative numbers */
345       if (arg > 0.0) {
346         fn = sqrt;
347       }
348       else {
349         if ((data->flag & FCM_GENERATOR_ADDITIVE) == 0) {
350           *cvalue = 0.0f; /* no value possible here */
351         }
352       }
353       break;
354     }
355     default:
356       CLOG_ERROR(&LOG, "Invalid Function-Generator for F-Modifier - %d", data->type);
357       break;
358   }
359
360   /* execute function callback to set value if appropriate */
361   if (fn) {
362     float value = (float)(data->amplitude * (float)fn(arg) + data->value_offset);
363
364     if (data->flag & FCM_GENERATOR_ADDITIVE) {
365       *cvalue += value;
366     }
367     else {
368       *cvalue = value;
369     }
370   }
371 }
372
373 static FModifierTypeInfo FMI_FN_GENERATOR = {
374     FMODIFIER_TYPE_FN_GENERATOR,    /* type */
375     sizeof(FMod_FunctionGenerator), /* size */
376     FMI_TYPE_GENERATE_CURVE,        /* action type */
377     FMI_REQUIRES_NOTHING,           /* requirements */
378     N_("Built-In Function"),        /* name */
379     "FMod_FunctionGenerator",       /* struct name */
380     0,                              /* storage size */
381     NULL,                           /* free data */
382     NULL,                           /* copy data */
383     fcm_fn_generator_new_data,      /* new data */
384     NULL,                           /* verify */
385     NULL,                           /* evaluate time */
386     fcm_fn_generator_evaluate,      /* evaluate */
387 };
388
389 /* Envelope F-Curve Modifier --------------------------- */
390
391 static void fcm_envelope_free(FModifier *fcm)
392 {
393   FMod_Envelope *env = (FMod_Envelope *)fcm->data;
394
395   /* free envelope data array */
396   if (env->data) {
397     MEM_freeN(env->data);
398   }
399 }
400
401 static void fcm_envelope_copy(FModifier *fcm, const FModifier *src)
402 {
403   FMod_Envelope *env = (FMod_Envelope *)fcm->data;
404   FMod_Envelope *oenv = (FMod_Envelope *)src->data;
405
406   /* copy envelope data array */
407   if (oenv->data) {
408     env->data = MEM_dupallocN(oenv->data);
409   }
410 }
411
412 static void fcm_envelope_new_data(void *mdata)
413 {
414   FMod_Envelope *env = (FMod_Envelope *)mdata;
415
416   /* set default min/max ranges */
417   env->min = -1.0f;
418   env->max = 1.0f;
419 }
420
421 static void fcm_envelope_verify(FModifier *fcm)
422 {
423   FMod_Envelope *env = (FMod_Envelope *)fcm->data;
424
425   /* if the are points, perform bubble-sort on them, as user may have changed the order */
426   if (env->data) {
427     /* XXX todo... */
428   }
429 }
430
431 static void fcm_envelope_evaluate(
432     FCurve *UNUSED(fcu), FModifier *fcm, float *cvalue, float evaltime, void *UNUSED(storage))
433 {
434   FMod_Envelope *env = (FMod_Envelope *)fcm->data;
435   FCM_EnvelopeData *fed, *prevfed, *lastfed;
436   float min = 0.0f, max = 0.0f, fac = 0.0f;
437   int a;
438
439   /* get pointers */
440   if (env->data == NULL) {
441     return;
442   }
443   prevfed = env->data;
444   fed = prevfed + 1;
445   lastfed = prevfed + (env->totvert - 1);
446
447   /* get min/max values for envelope at evaluation time (relative to mid-value) */
448   if (prevfed->time >= evaltime) {
449     /* before or on first sample, so just extend value */
450     min = prevfed->min;
451     max = prevfed->max;
452   }
453   else if (lastfed->time <= evaltime) {
454     /* after or on last sample, so just extend value */
455     min = lastfed->min;
456     max = lastfed->max;
457   }
458   else {
459     /* evaltime occurs somewhere between segments */
460     /* TODO: implement binary search for this to make it faster? */
461     for (a = 0; prevfed && fed && (a < env->totvert - 1); a++, prevfed = fed, fed++) {
462       /* evaltime occurs within the interval defined by these two envelope points */
463       if ((prevfed->time <= evaltime) && (fed->time >= evaltime)) {
464         float afac, bfac, diff;
465
466         diff = fed->time - prevfed->time;
467         afac = (evaltime - prevfed->time) / diff;
468         bfac = (fed->time - evaltime) / diff;
469
470         min = bfac * prevfed->min + afac * fed->min;
471         max = bfac * prevfed->max + afac * fed->max;
472
473         break;
474       }
475     }
476   }
477
478   /* adjust *cvalue
479    * - fac is the ratio of how the current y-value corresponds to the reference range
480    * - thus, the new value is found by mapping the old range to the new!
481    */
482   fac = (*cvalue - (env->midval + env->min)) / (env->max - env->min);
483   *cvalue = min + fac * (max - min);
484 }
485
486 static FModifierTypeInfo FMI_ENVELOPE = {
487     FMODIFIER_TYPE_ENVELOPE, /* type */
488     sizeof(FMod_Envelope),   /* size */
489     FMI_TYPE_REPLACE_VALUES, /* action type */
490     0,                       /* requirements */
491     N_("Envelope"),          /* name */
492     "FMod_Envelope",         /* struct name */
493     0,                       /* storage size */
494     fcm_envelope_free,       /* free data */
495     fcm_envelope_copy,       /* copy data */
496     fcm_envelope_new_data,   /* new data */
497     fcm_envelope_verify,     /* verify */
498     NULL,                    /* evaluate time */
499     fcm_envelope_evaluate,   /* evaluate */
500 };
501
502 /* exported function for finding points */
503
504 /* Binary search algorithm for finding where to insert Envelope Data Point.
505  * Returns the index to insert at (data already at that index will be offset if replace is 0)
506  */
507 #define BINARYSEARCH_FRAMEEQ_THRESH 0.0001f
508
509 int BKE_fcm_envelope_find_index(FCM_EnvelopeData array[],
510                                 float frame,
511                                 int arraylen,
512                                 bool *r_exists)
513 {
514   int start = 0, end = arraylen;
515   int loopbreaker = 0, maxloop = arraylen * 2;
516
517   /* initialize exists-flag first */
518   *r_exists = false;
519
520   /* sneaky optimizations (don't go through searching process if...):
521    * - keyframe to be added is to be added out of current bounds
522    * - keyframe to be added would replace one of the existing ones on bounds
523    */
524   if ((arraylen <= 0) || (array == NULL)) {
525     CLOG_WARN(&LOG, "encountered invalid array");
526     return 0;
527   }
528   else {
529     /* check whether to add before/after/on */
530     float framenum;
531
532     /* 'First' Point (when only one point, this case is used) */
533     framenum = array[0].time;
534     if (IS_EQT(frame, framenum, BINARYSEARCH_FRAMEEQ_THRESH)) {
535       *r_exists = true;
536       return 0;
537     }
538     else if (frame < framenum) {
539       return 0;
540     }
541
542     /* 'Last' Point */
543     framenum = array[(arraylen - 1)].time;
544     if (IS_EQT(frame, framenum, BINARYSEARCH_FRAMEEQ_THRESH)) {
545       *r_exists = true;
546       return (arraylen - 1);
547     }
548     else if (frame > framenum) {
549       return arraylen;
550     }
551   }
552
553   /* most of the time, this loop is just to find where to put it
554    * - 'loopbreaker' is just here to prevent infinite loops
555    */
556   for (loopbreaker = 0; (start <= end) && (loopbreaker < maxloop); loopbreaker++) {
557     /* compute and get midpoint */
558     int mid = start + ((end - start) /
559                        2); /* we calculate the midpoint this way to avoid int overflows... */
560     float midfra = array[mid].time;
561
562     /* check if exactly equal to midpoint */
563     if (IS_EQT(frame, midfra, BINARYSEARCH_FRAMEEQ_THRESH)) {
564       *r_exists = true;
565       return mid;
566     }
567
568     /* repeat in upper/lower half */
569     if (frame > midfra) {
570       start = mid + 1;
571     }
572     else if (frame < midfra) {
573       end = mid - 1;
574     }
575   }
576
577   /* print error if loop-limit exceeded */
578   if (loopbreaker == (maxloop - 1)) {
579     CLOG_ERROR(&LOG, "binary search was taking too long");
580
581     // include debug info
582     CLOG_ERROR(&LOG,
583                "\tround = %d: start = %d, end = %d, arraylen = %d",
584                loopbreaker,
585                start,
586                end,
587                arraylen);
588   }
589
590   /* not found, so return where to place it */
591   return start;
592 }
593 #undef BINARYSEARCH_FRAMEEQ_THRESH
594
595 /* Cycles F-Curve Modifier  --------------------------- */
596
597 /* This modifier changes evaltime to something that exists within the curve's frame-range,
598  * then re-evaluates modifier stack up to this point using the new time. This re-entrant behavior
599  * is very likely to be more time-consuming than the original approach...
600  * (which was tightly integrated into the calculation code...).
601  *
602  * NOTE: this needs to be at the start of the stack to be of use,
603  * as it needs to know the extents of the keyframes/sample-data.
604  *
605  * Possible TODO - store length of cycle information that can be initialized from the extents of
606  * the keyframes/sample-data, and adjusted as appropriate.
607  */
608
609 /* temp data used during evaluation */
610 typedef struct tFCMED_Cycles {
611   float cycyofs; /* y-offset to apply */
612 } tFCMED_Cycles;
613
614 static void fcm_cycles_new_data(void *mdata)
615 {
616   FMod_Cycles *data = (FMod_Cycles *)mdata;
617
618   /* turn on cycles by default */
619   data->before_mode = data->after_mode = FCM_EXTRAPOLATE_CYCLIC;
620 }
621
622 static float fcm_cycles_time(
623     FCurve *fcu, FModifier *fcm, float UNUSED(cvalue), float evaltime, void *storage_)
624 {
625   FMod_Cycles *data = (FMod_Cycles *)fcm->data;
626   tFCMED_Cycles *storage = storage_;
627   float prevkey[2], lastkey[2], cycyofs = 0.0f;
628   short side = 0, mode = 0;
629   int cycles = 0;
630   float ofs = 0;
631
632   /* Initialize storage. */
633   storage->cycyofs = 0;
634
635   /* check if modifier is first in stack, otherwise disable ourself... */
636   /* FIXME... */
637   if (fcm->prev) {
638     fcm->flag |= FMODIFIER_FLAG_DISABLED;
639     return evaltime;
640   }
641
642   /* calculate new evaltime due to cyclic interpolation */
643   if (fcu && fcu->bezt) {
644     BezTriple *prevbezt = fcu->bezt;
645     BezTriple *lastbezt = prevbezt + fcu->totvert - 1;
646
647     prevkey[0] = prevbezt->vec[1][0];
648     prevkey[1] = prevbezt->vec[1][1];
649
650     lastkey[0] = lastbezt->vec[1][0];
651     lastkey[1] = lastbezt->vec[1][1];
652   }
653   else if (fcu && fcu->fpt) {
654     FPoint *prevfpt = fcu->fpt;
655     FPoint *lastfpt = prevfpt + fcu->totvert - 1;
656
657     prevkey[0] = prevfpt->vec[0];
658     prevkey[1] = prevfpt->vec[1];
659
660     lastkey[0] = lastfpt->vec[0];
661     lastkey[1] = lastfpt->vec[1];
662   }
663   else {
664     return evaltime;
665   }
666
667   /* check if modifier will do anything
668    * 1) if in data range, definitely don't do anything
669    * 2) if before first frame or after last frame, make sure some cycling is in use
670    */
671   if (evaltime < prevkey[0]) {
672     if (data->before_mode) {
673       side = -1;
674       mode = data->before_mode;
675       cycles = data->before_cycles;
676       ofs = prevkey[0];
677     }
678   }
679   else if (evaltime > lastkey[0]) {
680     if (data->after_mode) {
681       side = 1;
682       mode = data->after_mode;
683       cycles = data->after_cycles;
684       ofs = lastkey[0];
685     }
686   }
687   if ((ELEM(0, side, mode))) {
688     return evaltime;
689   }
690
691   /* find relative place within a cycle */
692   {
693     float cycdx = 0, cycdy = 0;
694     float cycle = 0, cyct = 0;
695
696     /* calculate period and amplitude (total height) of a cycle */
697     cycdx = lastkey[0] - prevkey[0];
698     cycdy = lastkey[1] - prevkey[1];
699
700     /* check if cycle is infinitely small, to be point of being impossible to use */
701     if (cycdx == 0) {
702       return evaltime;
703     }
704
705     /* calculate the 'number' of the cycle */
706     cycle = ((float)side * (evaltime - ofs) / cycdx);
707
708     /* calculate the time inside the cycle */
709     cyct = fmod(evaltime - ofs, cycdx);
710
711     /* check that cyclic is still enabled for the specified time */
712     if (cycles == 0) {
713       /* catch this case so that we don't exit when we have (cycles = 0)
714        * as this indicates infinite cycles...
715        */
716     }
717     else if (cycle > cycles) {
718       /* we are too far away from range to evaluate
719        * TODO: but we should still hold last value...
720        */
721       return evaltime;
722     }
723
724     /* check if 'cyclic extrapolation', and thus calculate y-offset for this cycle */
725     if (mode == FCM_EXTRAPOLATE_CYCLIC_OFFSET) {
726       if (side < 0) {
727         cycyofs = (float)floor((evaltime - ofs) / cycdx);
728       }
729       else {
730         cycyofs = (float)ceil((evaltime - ofs) / cycdx);
731       }
732       cycyofs *= cycdy;
733     }
734
735     /* special case for cycle start/end */
736     if (cyct == 0.0f) {
737       evaltime = (side == 1 ? lastkey[0] : prevkey[0]);
738
739       if ((mode == FCM_EXTRAPOLATE_MIRROR) && ((int)cycle % 2)) {
740         evaltime = (side == 1 ? prevkey[0] : lastkey[0]);
741       }
742     }
743     /* calculate where in the cycle we are (overwrite evaltime to reflect this) */
744     else if ((mode == FCM_EXTRAPOLATE_MIRROR) && ((int)(cycle + 1) % 2)) {
745       /* When 'mirror' option is used and cycle number is odd, this cycle is played in reverse
746        * - for 'before' extrapolation, we need to flip in a different way, otherwise values past
747        *   then end of the curve get referenced
748        *   (result of fmod will be negative, and with different phase).
749        */
750       if (side < 0) {
751         evaltime = prevkey[0] - cyct;
752       }
753       else {
754         evaltime = lastkey[0] - cyct;
755       }
756     }
757     else {
758       /* the cycle is played normally... */
759       evaltime = prevkey[0] + cyct;
760     }
761     if (evaltime < prevkey[0]) {
762       evaltime += cycdx;
763     }
764   }
765
766   /* store temp data if needed */
767   if (mode == FCM_EXTRAPOLATE_CYCLIC_OFFSET) {
768     storage->cycyofs = cycyofs;
769   }
770
771   /* return the new frame to evaluate */
772   return evaltime;
773 }
774
775 static void fcm_cycles_evaluate(FCurve *UNUSED(fcu),
776                                 FModifier *UNUSED(fcm),
777                                 float *cvalue,
778                                 float UNUSED(evaltime),
779                                 void *storage_)
780 {
781   tFCMED_Cycles *storage = storage_;
782   *cvalue += storage->cycyofs;
783 }
784
785 static FModifierTypeInfo FMI_CYCLES = {
786     FMODIFIER_TYPE_CYCLES,      /* type */
787     sizeof(FMod_Cycles),        /* size */
788     FMI_TYPE_EXTRAPOLATION,     /* action type */
789     FMI_REQUIRES_ORIGINAL_DATA, /* requirements */
790     N_("Cycles"),               /* name */
791     "FMod_Cycles",              /* struct name */
792     sizeof(tFCMED_Cycles),      /* storage size */
793     NULL,                       /* free data */
794     NULL,                       /* copy data */
795     fcm_cycles_new_data,        /* new data */
796     NULL /*fcm_cycles_verify*/, /* verify */
797     fcm_cycles_time,            /* evaluate time */
798     fcm_cycles_evaluate,        /* evaluate */
799 };
800
801 /* Noise F-Curve Modifier  --------------------------- */
802
803 static void fcm_noise_new_data(void *mdata)
804 {
805   FMod_Noise *data = (FMod_Noise *)mdata;
806
807   /* defaults */
808   data->size = 1.0f;
809   data->strength = 1.0f;
810   data->phase = 1.0f;
811   data->offset = 0.0f;
812   data->depth = 0;
813   data->modification = FCM_NOISE_MODIF_REPLACE;
814 }
815
816 static void fcm_noise_evaluate(
817     FCurve *UNUSED(fcu), FModifier *fcm, float *cvalue, float evaltime, void *UNUSED(storage))
818 {
819   FMod_Noise *data = (FMod_Noise *)fcm->data;
820   float noise;
821
822   /* generate noise using good ol' Blender Noise
823    * - 0.1 is passed as the 'z' value, otherwise evaluation fails for size = phase = 1
824    *   with evaltime being an integer (which happens when evaluating on frame by frame basis)
825    */
826   noise = BLI_turbulence(data->size, evaltime - data->offset, data->phase, 0.1f, data->depth);
827
828   /* combine the noise with existing motion data */
829   switch (data->modification) {
830     case FCM_NOISE_MODIF_ADD:
831       *cvalue = *cvalue + noise * data->strength;
832       break;
833     case FCM_NOISE_MODIF_SUBTRACT:
834       *cvalue = *cvalue - noise * data->strength;
835       break;
836     case FCM_NOISE_MODIF_MULTIPLY:
837       *cvalue = *cvalue * noise * data->strength;
838       break;
839     case FCM_NOISE_MODIF_REPLACE:
840     default:
841       *cvalue = *cvalue + (noise - 0.5f) * data->strength;
842       break;
843   }
844 }
845
846 static FModifierTypeInfo FMI_NOISE = {
847     FMODIFIER_TYPE_NOISE,      /* type */
848     sizeof(FMod_Noise),        /* size */
849     FMI_TYPE_REPLACE_VALUES,   /* action type */
850     0,                         /* requirements */
851     N_("Noise"),               /* name */
852     "FMod_Noise",              /* struct name */
853     0,                         /* storage size */
854     NULL,                      /* free data */
855     NULL,                      /* copy data */
856     fcm_noise_new_data,        /* new data */
857     NULL /*fcm_noise_verify*/, /* verify */
858     NULL,                      /* evaluate time */
859     fcm_noise_evaluate,        /* evaluate */
860 };
861
862 /* Python F-Curve Modifier --------------------------- */
863
864 static void fcm_python_free(FModifier *fcm)
865 {
866   FMod_Python *data = (FMod_Python *)fcm->data;
867
868   /* id-properties */
869   IDP_FreeProperty(data->prop);
870   MEM_freeN(data->prop);
871 }
872
873 static void fcm_python_new_data(void *mdata)
874 {
875   FMod_Python *data = (FMod_Python *)mdata;
876
877   /* everything should be set correctly by calloc, except for the prop->type constant.*/
878   data->prop = MEM_callocN(sizeof(IDProperty), "PyFModifierProps");
879   data->prop->type = IDP_GROUP;
880 }
881
882 static void fcm_python_copy(FModifier *fcm, const FModifier *src)
883 {
884   FMod_Python *pymod = (FMod_Python *)fcm->data;
885   FMod_Python *opymod = (FMod_Python *)src->data;
886
887   pymod->prop = IDP_CopyProperty(opymod->prop);
888 }
889
890 static void fcm_python_evaluate(FCurve *UNUSED(fcu),
891                                 FModifier *UNUSED(fcm),
892                                 float *UNUSED(cvalue),
893                                 float UNUSED(evaltime),
894                                 void *UNUSED(storage))
895 {
896 #ifdef WITH_PYTHON
897   //FMod_Python *data = (FMod_Python *)fcm->data;
898
899   /* FIXME... need to implement this modifier...
900    * It will need it execute a script using the custom properties
901    */
902 #endif /* WITH_PYTHON */
903 }
904
905 static FModifierTypeInfo FMI_PYTHON = {
906     FMODIFIER_TYPE_PYTHON,      /* type */
907     sizeof(FMod_Python),        /* size */
908     FMI_TYPE_GENERATE_CURVE,    /* action type */
909     FMI_REQUIRES_RUNTIME_CHECK, /* requirements */
910     N_("Python"),               /* name */
911     "FMod_Python",              /* struct name */
912     0,                          /* storage size */
913     fcm_python_free,            /* free data */
914     fcm_python_copy,            /* copy data */
915     fcm_python_new_data,        /* new data */
916     NULL /*fcm_python_verify*/, /* verify */
917     NULL /*fcm_python_time*/,   /* evaluate time */
918     fcm_python_evaluate,        /* evaluate */
919 };
920
921 /* Limits F-Curve Modifier --------------------------- */
922
923 static float fcm_limits_time(FCurve *UNUSED(fcu),
924                              FModifier *fcm,
925                              float UNUSED(cvalue),
926                              float evaltime,
927                              void *UNUSED(storage))
928 {
929   FMod_Limits *data = (FMod_Limits *)fcm->data;
930
931   /* check for the time limits */
932   if ((data->flag & FCM_LIMIT_XMIN) && (evaltime < data->rect.xmin)) {
933     return data->rect.xmin;
934   }
935   if ((data->flag & FCM_LIMIT_XMAX) && (evaltime > data->rect.xmax)) {
936     return data->rect.xmax;
937   }
938
939   /* modifier doesn't change time */
940   return evaltime;
941 }
942
943 static void fcm_limits_evaluate(FCurve *UNUSED(fcu),
944                                 FModifier *fcm,
945                                 float *cvalue,
946                                 float UNUSED(evaltime),
947                                 void *UNUSED(storage))
948 {
949   FMod_Limits *data = (FMod_Limits *)fcm->data;
950
951   /* value limits now */
952   if ((data->flag & FCM_LIMIT_YMIN) && (*cvalue < data->rect.ymin)) {
953     *cvalue = data->rect.ymin;
954   }
955   if ((data->flag & FCM_LIMIT_YMAX) && (*cvalue > data->rect.ymax)) {
956     *cvalue = data->rect.ymax;
957   }
958 }
959
960 static FModifierTypeInfo FMI_LIMITS = {
961     FMODIFIER_TYPE_LIMITS, /* type */
962     sizeof(FMod_Limits),   /* size */
963     FMI_TYPE_GENERATE_CURVE,
964     /* action type */           /* XXX... err... */
965     FMI_REQUIRES_RUNTIME_CHECK, /* requirements */
966     N_("Limits"),               /* name */
967     "FMod_Limits",              /* struct name */
968     0,                          /* storage size */
969     NULL,                       /* free data */
970     NULL,                       /* copy data */
971     NULL,                       /* new data */
972     NULL,                       /* verify */
973     fcm_limits_time,            /* evaluate time */
974     fcm_limits_evaluate,        /* evaluate */
975 };
976
977 /* Stepped F-Curve Modifier --------------------------- */
978
979 static void fcm_stepped_new_data(void *mdata)
980 {
981   FMod_Stepped *data = (FMod_Stepped *)mdata;
982
983   /* just need to set the step-size to 2-frames by default */
984   /* XXX: or would 5 be more normal? */
985   data->step_size = 2.0f;
986 }
987
988 static float fcm_stepped_time(FCurve *UNUSED(fcu),
989                               FModifier *fcm,
990                               float UNUSED(cvalue),
991                               float evaltime,
992                               void *UNUSED(storage))
993 {
994   FMod_Stepped *data = (FMod_Stepped *)fcm->data;
995   int snapblock;
996
997   /* check range clamping to see if we should alter the timing to achieve the desired results */
998   if (data->flag & FCM_STEPPED_NO_BEFORE) {
999     if (evaltime < data->start_frame) {
1000       return evaltime;
1001     }
1002   }
1003   if (data->flag & FCM_STEPPED_NO_AFTER) {
1004     if (evaltime > data->end_frame) {
1005       return evaltime;
1006     }
1007   }
1008
1009   /* we snap to the start of the previous closest block of 'step_size' frames
1010    * after the start offset has been discarded
1011    * - i.e. round down
1012    */
1013   snapblock = (int)((evaltime - data->offset) / data->step_size);
1014
1015   /* reapply the offset, and multiple the snapblock by the size of the steps to get
1016    * the new time to evaluate at
1017    */
1018   return ((float)snapblock * data->step_size) + data->offset;
1019 }
1020
1021 static FModifierTypeInfo FMI_STEPPED = {
1022     FMODIFIER_TYPE_STEPPED, /* type */
1023     sizeof(FMod_Limits),    /* size */
1024     FMI_TYPE_GENERATE_CURVE,
1025     /* action type */           /* XXX... err... */
1026     FMI_REQUIRES_RUNTIME_CHECK, /* requirements */
1027     N_("Stepped"),              /* name */
1028     "FMod_Stepped",             /* struct name */
1029     0,                          /* storage size */
1030     NULL,                       /* free data */
1031     NULL,                       /* copy data */
1032     fcm_stepped_new_data,       /* new data */
1033     NULL,                       /* verify */
1034     fcm_stepped_time,           /* evaluate time */
1035     NULL,                       /* evaluate */
1036 };
1037
1038 /* F-Curve Modifier API --------------------------- */
1039 /* All of the F-Curve Modifier api functions use FModifierTypeInfo structs to carry out
1040  * and operations that involve F-Curve modifier specific code.
1041  */
1042
1043 /* These globals only ever get directly accessed in this file */
1044 static FModifierTypeInfo *fmodifiersTypeInfo[FMODIFIER_NUM_TYPES];
1045 static short FMI_INIT = 1; /* when non-zero, the list needs to be updated */
1046
1047 /* This function only gets called when FMI_INIT is non-zero */
1048 static void fmods_init_typeinfo(void)
1049 {
1050   fmodifiersTypeInfo[0] = NULL;              /* 'Null' F-Curve Modifier */
1051   fmodifiersTypeInfo[1] = &FMI_GENERATOR;    /* Generator F-Curve Modifier */
1052   fmodifiersTypeInfo[2] = &FMI_FN_GENERATOR; /* Built-In Function Generator F-Curve Modifier */
1053   fmodifiersTypeInfo[3] = &FMI_ENVELOPE;     /* Envelope F-Curve Modifier */
1054   fmodifiersTypeInfo[4] = &FMI_CYCLES;       /* Cycles F-Curve Modifier */
1055   fmodifiersTypeInfo[5] = &FMI_NOISE;        /* Apply-Noise F-Curve Modifier */
1056   fmodifiersTypeInfo[6] = NULL /*&FMI_FILTER*/; /* Filter F-Curve Modifier */  // XXX unimplemented
1057   fmodifiersTypeInfo[7] = &FMI_PYTHON;  /* Custom Python F-Curve Modifier */
1058   fmodifiersTypeInfo[8] = &FMI_LIMITS;  /* Limits F-Curve Modifier */
1059   fmodifiersTypeInfo[9] = &FMI_STEPPED; /* Stepped F-Curve Modifier */
1060 }
1061
1062 /* This function should be used for getting the appropriate type-info when only
1063  * a F-Curve modifier type is known
1064  */
1065 const FModifierTypeInfo *get_fmodifier_typeinfo(const int type)
1066 {
1067   /* initialize the type-info list? */
1068   if (FMI_INIT) {
1069     fmods_init_typeinfo();
1070     FMI_INIT = 0;
1071   }
1072
1073   /* only return for valid types */
1074   if ((type >= FMODIFIER_TYPE_NULL) && (type < FMODIFIER_NUM_TYPES)) {
1075     /* there shouldn't be any segfaults here... */
1076     return fmodifiersTypeInfo[type];
1077   }
1078   else {
1079     CLOG_ERROR(&LOG, "No valid F-Curve Modifier type-info data available. Type = %i", type);
1080   }
1081
1082   return NULL;
1083 }
1084
1085 /* This function should always be used to get the appropriate type-info, as it
1086  * has checks which prevent segfaults in some weird cases.
1087  */
1088 const FModifierTypeInfo *fmodifier_get_typeinfo(const FModifier *fcm)
1089 {
1090   /* only return typeinfo for valid modifiers */
1091   if (fcm) {
1092     return get_fmodifier_typeinfo(fcm->type);
1093   }
1094   else {
1095     return NULL;
1096   }
1097 }
1098
1099 /* API --------------------------- */
1100
1101 /* Add a new F-Curve Modifier to the given F-Curve of a certain type */
1102 FModifier *add_fmodifier(ListBase *modifiers, int type, FCurve *owner_fcu)
1103 {
1104   const FModifierTypeInfo *fmi = get_fmodifier_typeinfo(type);
1105   FModifier *fcm;
1106
1107   /* sanity checks */
1108   if (ELEM(NULL, modifiers, fmi)) {
1109     return NULL;
1110   }
1111
1112   /* special checks for whether modifier can be added */
1113   if ((modifiers->first) && (type == FMODIFIER_TYPE_CYCLES)) {
1114     /* cycles modifier must be first in stack, so for now, don't add if it can't be */
1115     /* TODO: perhaps there is some better way, but for now, */
1116     CLOG_STR_ERROR(&LOG,
1117                    "Cannot add 'Cycles' modifier to F-Curve, as 'Cycles' modifier can only be "
1118                    "first in stack.");
1119     return NULL;
1120   }
1121
1122   /* add modifier itself */
1123   fcm = MEM_callocN(sizeof(FModifier), "F-Curve Modifier");
1124   fcm->type = type;
1125   fcm->flag = FMODIFIER_FLAG_EXPANDED;
1126   fcm->curve = owner_fcu;
1127   fcm->influence = 1.0f;
1128   BLI_addtail(modifiers, fcm);
1129
1130   /* tag modifier as "active" if no other modifiers exist in the stack yet */
1131   if (BLI_listbase_is_single(modifiers)) {
1132     fcm->flag |= FMODIFIER_FLAG_ACTIVE;
1133   }
1134
1135   /* add modifier's data */
1136   fcm->data = MEM_callocN(fmi->size, fmi->structName);
1137
1138   /* init custom settings if necessary */
1139   if (fmi->new_data) {
1140     fmi->new_data(fcm->data);
1141   }
1142
1143   /* update the fcurve if the Cycles modifier is added */
1144   if ((owner_fcu) && (type == FMODIFIER_TYPE_CYCLES)) {
1145     calchandles_fcurve(owner_fcu);
1146   }
1147
1148   /* return modifier for further editing */
1149   return fcm;
1150 }
1151
1152 /* Make a copy of the specified F-Modifier */
1153 FModifier *copy_fmodifier(const FModifier *src)
1154 {
1155   const FModifierTypeInfo *fmi = fmodifier_get_typeinfo(src);
1156   FModifier *dst;
1157
1158   /* sanity check */
1159   if (src == NULL) {
1160     return NULL;
1161   }
1162
1163   /* copy the base data, clearing the links */
1164   dst = MEM_dupallocN(src);
1165   dst->next = dst->prev = NULL;
1166   dst->curve = NULL;
1167
1168   /* make a new copy of the F-Modifier's data */
1169   dst->data = MEM_dupallocN(src->data);
1170
1171   /* only do specific constraints if required */
1172   if (fmi && fmi->copy_data) {
1173     fmi->copy_data(dst, src);
1174   }
1175
1176   /* return the new modifier */
1177   return dst;
1178 }
1179
1180 /* Duplicate all of the F-Modifiers in the Modifier stacks */
1181 void copy_fmodifiers(ListBase *dst, const ListBase *src)
1182 {
1183   FModifier *fcm, *srcfcm;
1184
1185   if (ELEM(NULL, dst, src)) {
1186     return;
1187   }
1188
1189   BLI_listbase_clear(dst);
1190   BLI_duplicatelist(dst, src);
1191
1192   for (fcm = dst->first, srcfcm = src->first; fcm && srcfcm;
1193        srcfcm = srcfcm->next, fcm = fcm->next) {
1194     const FModifierTypeInfo *fmi = fmodifier_get_typeinfo(fcm);
1195
1196     /* make a new copy of the F-Modifier's data */
1197     fcm->data = MEM_dupallocN(fcm->data);
1198     fcm->curve = NULL;
1199
1200     /* only do specific constraints if required */
1201     if (fmi && fmi->copy_data) {
1202       fmi->copy_data(fcm, srcfcm);
1203     }
1204   }
1205 }
1206
1207 /* Remove and free the given F-Modifier from the given stack  */
1208 bool remove_fmodifier(ListBase *modifiers, FModifier *fcm)
1209 {
1210   const FModifierTypeInfo *fmi = fmodifier_get_typeinfo(fcm);
1211
1212   /* sanity check */
1213   if (fcm == NULL) {
1214     return false;
1215   }
1216
1217   /* removing the cycles modifier requires a handle update */
1218   FCurve *update_fcu = (fcm->type == FMODIFIER_TYPE_CYCLES) ? fcm->curve : NULL;
1219
1220   /* free modifier's special data (stored inside fcm->data) */
1221   if (fcm->data) {
1222     if (fmi && fmi->free_data) {
1223       fmi->free_data(fcm);
1224     }
1225
1226     /* free modifier's data (fcm->data) */
1227     MEM_freeN(fcm->data);
1228   }
1229
1230   /* remove modifier from stack */
1231   if (modifiers) {
1232     BLI_freelinkN(modifiers, fcm);
1233
1234     /* update the fcurve if the Cycles modifier is removed */
1235     if (update_fcu) {
1236       calchandles_fcurve(update_fcu);
1237     }
1238
1239     return true;
1240   }
1241   else {
1242     /* XXX this case can probably be removed some day, as it shouldn't happen... */
1243     CLOG_STR_ERROR(&LOG, "no modifier stack given");
1244     MEM_freeN(fcm);
1245     return false;
1246   }
1247 }
1248
1249 /* Remove all of a given F-Curve's modifiers */
1250 void free_fmodifiers(ListBase *modifiers)
1251 {
1252   FModifier *fcm, *fmn;
1253
1254   /* sanity check */
1255   if (modifiers == NULL) {
1256     return;
1257   }
1258
1259   /* free each modifier in order - modifier is unlinked from list and freed */
1260   for (fcm = modifiers->first; fcm; fcm = fmn) {
1261     fmn = fcm->next;
1262     remove_fmodifier(modifiers, fcm);
1263   }
1264 }
1265
1266 /* Find the active F-Modifier */
1267 FModifier *find_active_fmodifier(ListBase *modifiers)
1268 {
1269   FModifier *fcm;
1270
1271   /* sanity checks */
1272   if (ELEM(NULL, modifiers, modifiers->first)) {
1273     return NULL;
1274   }
1275
1276   /* loop over modifiers until 'active' one is found */
1277   for (fcm = modifiers->first; fcm; fcm = fcm->next) {
1278     if (fcm->flag & FMODIFIER_FLAG_ACTIVE) {
1279       return fcm;
1280     }
1281   }
1282
1283   /* no modifier is active */
1284   return NULL;
1285 }
1286
1287 /* Set the active F-Modifier */
1288 void set_active_fmodifier(ListBase *modifiers, FModifier *fcm)
1289 {
1290   FModifier *fm;
1291
1292   /* sanity checks */
1293   if (ELEM(NULL, modifiers, modifiers->first)) {
1294     return;
1295   }
1296
1297   /* deactivate all, and set current one active */
1298   for (fm = modifiers->first; fm; fm = fm->next) {
1299     fm->flag &= ~FMODIFIER_FLAG_ACTIVE;
1300   }
1301
1302   /* make given modifier active */
1303   if (fcm) {
1304     fcm->flag |= FMODIFIER_FLAG_ACTIVE;
1305   }
1306 }
1307
1308 /* Do we have any modifiers which match certain criteria
1309  * - mtype - type of modifier (if 0, doesn't matter)
1310  * - acttype - type of action to perform (if -1, doesn't matter)
1311  */
1312 bool list_has_suitable_fmodifier(ListBase *modifiers, int mtype, short acttype)
1313 {
1314   FModifier *fcm;
1315
1316   /* if there are no specific filtering criteria, just skip */
1317   if ((mtype == 0) && (acttype == 0)) {
1318     return (modifiers && modifiers->first);
1319   }
1320
1321   /* sanity checks */
1322   if (ELEM(NULL, modifiers, modifiers->first)) {
1323     return false;
1324   }
1325
1326   /* find the first mdifier fitting these criteria */
1327   for (fcm = modifiers->first; fcm; fcm = fcm->next) {
1328     const FModifierTypeInfo *fmi = fmodifier_get_typeinfo(fcm);
1329     short mOk = 1, aOk = 1; /* by default 1, so that when only one test, won't fail */
1330
1331     /* check if applicable ones are fulfilled */
1332     if (mtype) {
1333       mOk = (fcm->type == mtype);
1334     }
1335     if (acttype > -1) {
1336       aOk = (fmi->acttype == acttype);
1337     }
1338
1339     /* if both are ok, we've found a hit */
1340     if (mOk && aOk) {
1341       return true;
1342     }
1343   }
1344
1345   /* no matches */
1346   return false;
1347 }
1348
1349 /* Evaluation API --------------------------- */
1350
1351 uint evaluate_fmodifiers_storage_size_per_modifier(ListBase *modifiers)
1352 {
1353   /* Sanity checks. */
1354   if (ELEM(NULL, modifiers, modifiers->first)) {
1355     return 0;
1356   }
1357
1358   uint max_size = 0;
1359
1360   for (FModifier *fcm = modifiers->first; fcm; fcm = fcm->next) {
1361     const FModifierTypeInfo *fmi = fmodifier_get_typeinfo(fcm);
1362
1363     if (fmi == NULL) {
1364       continue;
1365     }
1366
1367     max_size = MAX2(max_size, fmi->storage_size);
1368   }
1369
1370   return max_size;
1371 }
1372
1373 /* helper function - calculate influence of FModifier */
1374 static float eval_fmodifier_influence(FModifier *fcm, float evaltime)
1375 {
1376   float influence;
1377
1378   /* sanity check */
1379   if (fcm == NULL) {
1380     return 0.0f;
1381   }
1382
1383   /* should we use influence stored in modifier or not
1384    * NOTE: this is really just a hack so that we don't need to version patch old files ;)
1385    */
1386   if (fcm->flag & FMODIFIER_FLAG_USEINFLUENCE) {
1387     influence = fcm->influence;
1388   }
1389   else {
1390     influence = 1.0f;
1391   }
1392
1393   /* restricted range or full range? */
1394   if (fcm->flag & FMODIFIER_FLAG_RANGERESTRICT) {
1395     if ((evaltime <= fcm->sfra) || (evaltime >= fcm->efra)) {
1396       /* out of range */
1397       return 0.0f;
1398     }
1399     else if ((evaltime > fcm->sfra) && (evaltime < fcm->sfra + fcm->blendin)) {
1400       /* blend in range */
1401       float a = fcm->sfra;
1402       float b = fcm->sfra + fcm->blendin;
1403       return influence * (evaltime - a) / (b - a);
1404     }
1405     else if ((evaltime < fcm->efra) && (evaltime > fcm->efra - fcm->blendout)) {
1406       /* blend out range */
1407       float a = fcm->efra;
1408       float b = fcm->efra - fcm->blendout;
1409       return influence * (evaltime - a) / (b - a);
1410     }
1411   }
1412
1413   /* just return the influence of the modifier */
1414   return influence;
1415 }
1416
1417 /* evaluate time modifications imposed by some F-Curve Modifiers
1418  * - this step acts as an optimization to prevent the F-Curve stack being evaluated
1419  *   several times by modifiers requesting the time be modified, as the final result
1420  *   would have required using the modified time
1421  * - modifiers only ever receive the unmodified time, as subsequent modifiers should be
1422  *   working on the 'global' result of the modified curve, not some localised segment,
1423  *   so nevaltime gets set to whatever the last time-modifying modifier likes...
1424  * - we start from the end of the stack, as only the last one matters for now
1425  *
1426  * Note: *fcu might be NULL
1427  */
1428 float evaluate_time_fmodifiers(FModifiersStackStorage *storage,
1429                                ListBase *modifiers,
1430                                FCurve *fcu,
1431                                float cvalue,
1432                                float evaltime)
1433 {
1434   /* sanity checks */
1435   if (ELEM(NULL, modifiers, modifiers->last)) {
1436     return evaltime;
1437   }
1438
1439   if (fcu && fcu->flag & FCURVE_MOD_OFF) {
1440     return evaltime;
1441   }
1442
1443   /* Starting from the end of the stack, calculate the time effects of various stacked modifiers
1444    * on the time the F-Curve should be evaluated at.
1445    *
1446    * This is done in reverse order to standard evaluation, as when this is done in standard
1447    * order, each modifier would cause jumps to other points in the curve, forcing all
1448    * previous ones to be evaluated again for them to be correct. However, if we did in the
1449    * reverse order as we have here, we can consider them a macro to micro type of waterfall
1450    * effect, which should get us the desired effects when using layered time manipulations
1451    * (such as multiple 'stepped' modifiers in sequence, causing different stepping rates)
1452    */
1453   uint fcm_index = storage->modifier_count - 1;
1454   for (FModifier *fcm = modifiers->last; fcm; fcm = fcm->prev, fcm_index--) {
1455     const FModifierTypeInfo *fmi = fmodifier_get_typeinfo(fcm);
1456
1457     if (fmi == NULL) {
1458       continue;
1459     }
1460
1461     /* If modifier cannot be applied on this frame
1462      * (whatever scale it is on, it won't affect the results)
1463      * hence we shouldn't bother seeing what it would do given the chance. */
1464     if ((fcm->flag & FMODIFIER_FLAG_RANGERESTRICT) == 0 ||
1465         ((fcm->sfra <= evaltime) && (fcm->efra >= evaltime))) {
1466       /* only evaluate if there's a callback for this */
1467       if (fmi->evaluate_modifier_time) {
1468         if ((fcm->flag & (FMODIFIER_FLAG_DISABLED | FMODIFIER_FLAG_MUTED)) == 0) {
1469           void *storage_ptr = POINTER_OFFSET(storage->buffer,
1470                                              fcm_index * storage->size_per_modifier);
1471
1472           float nval = fmi->evaluate_modifier_time(fcu, fcm, cvalue, evaltime, storage_ptr);
1473
1474           float influence = eval_fmodifier_influence(fcm, evaltime);
1475           evaltime = interpf(nval, evaltime, influence);
1476         }
1477       }
1478     }
1479   }
1480
1481   /* return the modified evaltime */
1482   return evaltime;
1483 }
1484
1485 /* Evaluates the given set of F-Curve Modifiers using the given data
1486  * Should only be called after evaluate_time_fmodifiers() has been called...
1487  */
1488 void evaluate_value_fmodifiers(FModifiersStackStorage *storage,
1489                                ListBase *modifiers,
1490                                FCurve *fcu,
1491                                float *cvalue,
1492                                float evaltime)
1493 {
1494   FModifier *fcm;
1495
1496   /* sanity checks */
1497   if (ELEM(NULL, modifiers, modifiers->first)) {
1498     return;
1499   }
1500
1501   if (fcu->flag & FCURVE_MOD_OFF) {
1502     return;
1503   }
1504
1505   /* evaluate modifiers */
1506   uint fcm_index = 0;
1507   for (fcm = modifiers->first; fcm; fcm = fcm->next, fcm_index++) {
1508     const FModifierTypeInfo *fmi = fmodifier_get_typeinfo(fcm);
1509
1510     if (fmi == NULL) {
1511       continue;
1512     }
1513
1514     /* Only evaluate if there's a callback for this,
1515      * and if F-Modifier can be evaluated on this frame. */
1516     if ((fcm->flag & FMODIFIER_FLAG_RANGERESTRICT) == 0 ||
1517         ((fcm->sfra <= evaltime) && (fcm->efra >= evaltime))) {
1518       if (fmi->evaluate_modifier) {
1519         if ((fcm->flag & (FMODIFIER_FLAG_DISABLED | FMODIFIER_FLAG_MUTED)) == 0) {
1520           void *storage_ptr = POINTER_OFFSET(storage->buffer,
1521                                              fcm_index * storage->size_per_modifier);
1522
1523           float nval = *cvalue;
1524           fmi->evaluate_modifier(fcu, fcm, &nval, evaltime, storage_ptr);
1525
1526           float influence = eval_fmodifier_influence(fcm, evaltime);
1527           *cvalue = interpf(nval, *cvalue, influence);
1528         }
1529       }
1530     }
1531   }
1532 }
1533
1534 /* ---------- */
1535
1536 /* Bake modifiers for given F-Curve to curve sample data, in the frame range defined
1537  * by start and end (inclusive).
1538  */
1539 void fcurve_bake_modifiers(FCurve *fcu, int start, int end)
1540 {
1541   ChannelDriver *driver;
1542
1543   /* sanity checks */
1544   /* TODO: make these tests report errors using reports not CLOG's */
1545   if (ELEM(NULL, fcu, fcu->modifiers.first)) {
1546     CLOG_ERROR(&LOG, "No F-Curve with F-Curve Modifiers to Bake");
1547     return;
1548   }
1549
1550   /* temporarily, disable driver while we sample, so that they don't influence the outcome */
1551   driver = fcu->driver;
1552   fcu->driver = NULL;
1553
1554   /* bake the modifiers, by sampling the curve at each frame */
1555   fcurve_store_samples(fcu, NULL, start, end, fcurve_samplingcb_evalcurve);
1556
1557   /* free the modifiers now */
1558   free_fmodifiers(&fcu->modifiers);
1559
1560   /* restore driver */
1561   fcu->driver = driver;
1562 }