Merging with trunk up to r38631.
[blender.git] / source / blender / blenkernel / intern / fmodifier.c
index 5a10f93ac7246ab341b287432858c37d44b37349..dcf81c194798573be58e030038684c5d137517aa 100644 (file)
@@ -1,4 +1,4 @@
-/**
+/*
  * $Id$
  *
  * ***** BEGIN GPL LICENSE BLOCK *****
  * ***** END GPL LICENSE BLOCK *****
  */
 
+/** \file blender/blenkernel/intern/fmodifier.c
+ *  \ingroup bke
+ */
+
+
 
 #include <math.h>
 #include <stdio.h>
 
 #include "BLI_blenlib.h"
 #include "BLI_math.h" /* windows needs for M_PI */
+#include "BLI_utildefines.h"
 
 #include "BKE_fcurve.h"
 #include "BKE_idprop.h"
-#include "BKE_utildefines.h"
+
 
 #define SMALL -1.0e-10
 #define SELECT 1
@@ -146,7 +152,7 @@ static void fcm_generator_verify (FModifier *fcm)
                                nc= MEM_callocN(sizeof(float)*(data->poly_order+1), "FMod_Generator_Coefs");
                                
                                if (data->coefficients) {
-                                       if (data->arraysize > (data->poly_order+1))
+                                       if ((int)data->arraysize > (data->poly_order+1))
                                                memcpy(nc, data->coefficients, sizeof(float)*(data->poly_order+1));
                                        else
                                                memcpy(nc, data->coefficients, sizeof(float)*data->arraysize);
@@ -172,7 +178,7 @@ static void fcm_generator_verify (FModifier *fcm)
                                nc= MEM_callocN(sizeof(float)*(data->poly_order*2), "FMod_Generator_Coefs");
                                
                                if (data->coefficients) {
-                                       if (data->arraysize > (data->poly_order * 2))
+                                       if (data->arraysize > (unsigned int)(data->poly_order * 2))
                                                memcpy(nc, data->coefficients, sizeof(float)*(data->poly_order * 2));
                                        else
                                                memcpy(nc, data->coefficients, sizeof(float)*data->arraysize);
@@ -190,7 +196,7 @@ static void fcm_generator_verify (FModifier *fcm)
        }
 }
 
-static void fcm_generator_evaluate (FCurve *fcu, FModifier *fcm, float *cvalue, float evaltime)
+static void fcm_generator_evaluate (FCurve *UNUSED(fcu), FModifier *fcm, float *cvalue, float evaltime)
 {
        FMod_Generator *data= (FMod_Generator *)fcm->data;
        
@@ -240,7 +246,7 @@ static void fcm_generator_evaluate (FCurve *fcu, FModifier *fcm, float *cvalue,
                        unsigned int i;
                        
                        /* for each coefficient pair, solve for that bracket before accumulating in value by multiplying */
-                       for (cp=data->coefficients, i=0; (cp) && (i < data->poly_order); cp+=2, i++) 
+                       for (cp=data->coefficients, i=0; (cp) && (i < (unsigned int)data->poly_order); cp+=2, i++) 
                                value *= (cp[0]*evaltime + cp[1]);
                                
                        /* only if something changed, write *cvalue in one go */
@@ -303,7 +309,7 @@ static double sinc (double x)
                return sin(M_PI * x) / (M_PI * x);
 }
 
-static void fcm_fn_generator_evaluate (FCurve *fcu, FModifier *fcm, float *cvalue, float evaltime)
+static void fcm_fn_generator_evaluate (FCurve *UNUSED(fcu), FModifier *fcm, float *cvalue, float evaltime)
 {
        FMod_FunctionGenerator *data= (FMod_FunctionGenerator *)fcm->data;
        double arg= data->phase_multiplier*evaltime + data->phase_offset;
@@ -340,7 +346,7 @@ static void fcm_fn_generator_evaluate (FCurve *fcu, FModifier *fcm, float *cvalu
                case FCM_GENERATOR_FN_LN: /* natural log */
                {
                        /* check that value is greater than 1? */
-                       if (arg > 1.0f) {
+                       if (arg > 1.0) {
                                fn= log;
                        }
                        else {
@@ -352,7 +358,7 @@ static void fcm_fn_generator_evaluate (FCurve *fcu, FModifier *fcm, float *cvalu
                case FCM_GENERATOR_FN_SQRT: /* square root */
                {
                        /* no negative numbers */
-                       if (arg > 0.0f) {
+                       if (arg > 0.0) {
                                fn= sqrt;
                        }
                        else {
@@ -368,7 +374,7 @@ static void fcm_fn_generator_evaluate (FCurve *fcu, FModifier *fcm, float *cvalu
        
        /* execute function callback to set value if appropriate */
        if (fn) {
-               float value= (float)(data->amplitude*fn(arg) + data->value_offset);
+               float value= (float)(data->amplitude*(float)fn(arg) + data->value_offset);
                
                if (data->flag & FCM_GENERATOR_ADDITIVE)
                        *cvalue += value;
@@ -432,7 +438,7 @@ static void fcm_envelope_verify (FModifier *fcm)
        }
 }
 
-static void fcm_envelope_evaluate (FCurve *fcu, FModifier *fcm, float *cvalue, float evaltime)
+static void fcm_envelope_evaluate (FCurve *UNUSED(fcu), FModifier *fcm, float *cvalue, float evaltime)
 {
        FMod_Envelope *env= (FMod_Envelope *)fcm->data;
        FCM_EnvelopeData *fed, *prevfed, *lastfed;
@@ -524,7 +530,7 @@ static void fcm_cycles_new_data (void *mdata)
        data->before_mode= data->after_mode= FCM_EXTRAPOLATE_CYCLIC;
 }
 
-static float fcm_cycles_time (FCurve *fcu, FModifier *fcm, float cvalue, float evaltime)
+static float fcm_cycles_time (FCurve *fcu, FModifier *fcm, float UNUSED(cvalue), float evaltime)
 {
        FMod_Cycles *data= (FMod_Cycles *)fcm->data;
        float prevkey[2], lastkey[2], cycyofs=0.0f;
@@ -664,7 +670,7 @@ static float fcm_cycles_time (FCurve *fcu, FModifier *fcm, float cvalue, float e
        return evaltime;
 }
  
-static void fcm_cycles_evaluate (FCurve *fcu, FModifier *fcm, float *cvalue, float evaltime)
+static void fcm_cycles_evaluate (FCurve *UNUSED(fcu), FModifier *fcm, float *cvalue, float UNUSED(evaltime))
 {
        tFCMED_Cycles *edata= (tFCMED_Cycles *)fcm->edata;
        
@@ -708,7 +714,7 @@ static void fcm_noise_new_data (void *mdata)
        data->modification = FCM_NOISE_MODIF_REPLACE;
 }
  
-static void fcm_noise_evaluate (FCurve *fcu, FModifier *fcm, float *cvalue, float evaltime)
+static void fcm_noise_evaluate (FCurve *UNUSED(fcu), FModifier *fcm, float *cvalue, float evaltime)
 {
        FMod_Noise *data= (FMod_Noise *)fcm->data;
        float noise;
@@ -800,15 +806,15 @@ static void fcm_python_copy (FModifier *fcm, FModifier *src)
        pymod->prop = IDP_CopyProperty(opymod->prop);
 }
 
-static void fcm_python_evaluate (FCurve *fcu, FModifier *fcm, float *cvalue, float evaltime)
+static void fcm_python_evaluate (FCurve *UNUSED(fcu), FModifier *UNUSED(fcm), float *UNUSED(cvalue), float UNUSED(evaltime))
 {
-#ifndef DISABLE_PYTHON
+#ifdef WITH_PYTHON
        //FMod_Python *data= (FMod_Python *)fcm->data;
        
        /* FIXME... need to implement this modifier...
         *      It will need it execute a script using the custom properties 
         */
-#endif /* DISABLE_PYTHON */
+#endif /* WITH_PYTHON */
 }
 
 static FModifierTypeInfo FMI_PYTHON = {
@@ -829,7 +835,7 @@ static FModifierTypeInfo FMI_PYTHON = {
 
 /* Limits F-Curve Modifier --------------------------- */
 
-static float fcm_limits_time (FCurve *fcu, FModifier *fcm, float cvalue, float evaltime)
+static float fcm_limits_time (FCurve *UNUSED(fcu), FModifier *fcm, float UNUSED(cvalue), float evaltime)
 {
        FMod_Limits *data= (FMod_Limits *)fcm->data;
        
@@ -843,7 +849,7 @@ static float fcm_limits_time (FCurve *fcu, FModifier *fcm, float cvalue, float e
        return evaltime;
 }
 
-static void fcm_limits_evaluate (FCurve *fcu, FModifier *fcm, float *cvalue, float evaltime)
+static void fcm_limits_evaluate (FCurve *UNUSED(fcu), FModifier *fcm, float *cvalue, float UNUSED(evaltime))
 {
        FMod_Limits *data= (FMod_Limits *)fcm->data;
        
@@ -880,7 +886,7 @@ static void fcm_stepped_new_data (void *mdata)
        data->step_size = 2.0f;
 }
 
-static float fcm_stepped_time (FCurve *fcu, FModifier *fcm, float cvalue, float evaltime)
+static float fcm_stepped_time (FCurve *UNUSED(fcu), FModifier *fcm, float UNUSED(cvalue), float evaltime)
 {
        FMod_Stepped *data= (FMod_Stepped *)fcm->data;
        int snapblock;
@@ -932,7 +938,7 @@ static FModifierTypeInfo *fmodifiersTypeInfo[FMODIFIER_NUM_TYPES];
 static short FMI_INIT= 1; /* when non-zero, the list needs to be updated */
 
 /* This function only gets called when FMI_INIT is non-zero */
-static void fmods_init_typeinfo () 
+static void fmods_init_typeinfo (void
 {
        fmodifiersTypeInfo[0]=  NULL;                                   /* 'Null' F-Curve Modifier */
        fmodifiersTypeInfo[1]=  &FMI_GENERATOR;                 /* Generator F-Curve Modifier */
@@ -1007,11 +1013,16 @@ FModifier *add_fmodifier (ListBase *modifiers, int type)
        fcm= MEM_callocN(sizeof(FModifier), "F-Curve Modifier");
        fcm->type = type;
        fcm->flag = FMODIFIER_FLAG_EXPANDED;
+       fcm->influence = 1.0f;
        BLI_addtail(modifiers, fcm);
        
+       /* tag modifier as "active" if no other modifiers exist in the stack yet */
+       if (modifiers->first == modifiers->last)
+               fcm->flag |= FMODIFIER_FLAG_ACTIVE;
+       
        /* add modifier's data */
        fcm->data= MEM_callocN(fmi->size, fmi->structName);
-               
+       
        /* init custom settings if necessary */
        if (fmi->new_data)      
                fmi->new_data(fcm->data);
@@ -1190,6 +1201,47 @@ short list_has_suitable_fmodifier (ListBase *modifiers, int mtype, short acttype
 
 /* Evaluation API --------------------------- */
 
+/* helper function - calculate influence of FModifier */
+static float eval_fmodifier_influence (FModifier *fcm, float evaltime)
+{
+       float influence;
+       
+       /* sanity check */
+       if (fcm == NULL) 
+               return 0.0f;
+       
+       /* should we use influence stored in modifier or not 
+        * NOTE: this is really just a hack so that we don't need to version patch old files ;)
+        */
+       if (fcm->flag & FMODIFIER_FLAG_USEINFLUENCE)
+               influence = fcm->influence;
+       else
+               influence = 1.0f;
+               
+       /* restricted range or full range? */
+       if (fcm->flag & FMODIFIER_FLAG_RANGERESTRICT) {
+               if ((evaltime <= fcm->sfra) || (evaltime >= fcm->efra)) {
+                       /* out of range */
+                       return 0.0f;
+               }
+               else if ((evaltime > fcm->sfra) && (evaltime < fcm->sfra + fcm->blendin)) {
+                       /* blend in range */
+                       float a = fcm->sfra;
+                       float b = fcm->sfra + fcm->blendin;
+                       return influence * (evaltime - a) / (b - a);
+               }
+               else if ((evaltime < fcm->efra) && (evaltime > fcm->efra - fcm->blendout)) {
+                       /* blend out range */
+                       float a = fcm->efra;
+                       float b = fcm->efra - fcm->blendout;
+                       return influence * (evaltime - a) / (b - a);
+               }
+       }
+       
+       /* just return the influence of the modifier */
+       return influence;
+}
+
 /* evaluate time modifications imposed by some F-Curve Modifiers
  *     - this step acts as an optimisation to prevent the F-Curve stack being evaluated 
  *       several times by modifiers requesting the time be modified, as the final result
@@ -1220,11 +1272,24 @@ float evaluate_time_fmodifiers (ListBase *modifiers, FCurve *fcu, float cvalue,
        for (fcm= modifiers->last; fcm; fcm= fcm->prev) {
                FModifierTypeInfo *fmi= fmodifier_get_typeinfo(fcm);
                
-               /* only evaluate if there's a callback for this */
-               // TODO: implement the 'influence' control feature...
-               if (fmi && fmi->evaluate_modifier_time) {
-                       if ((fcm->flag & (FMODIFIER_FLAG_DISABLED|FMODIFIER_FLAG_MUTED)) == 0)
-                               evaltime= fmi->evaluate_modifier_time(fcu, fcm, cvalue, evaltime);
+               if (fmi == NULL) 
+                       continue;
+               
+               /* if modifier cannot be applied on this frame (whatever scale it is on, it won't affect the results)
+                * hence we shouldn't bother seeing what it would do given the chance
+                */
+               if ((fcm->flag & FMODIFIER_FLAG_RANGERESTRICT)==0 || 
+                       ((fcm->sfra <= evaltime) && (fcm->efra >= evaltime)) )
+               {
+                       /* only evaluate if there's a callback for this */
+                       if (fmi->evaluate_modifier_time) {
+                               if ((fcm->flag & (FMODIFIER_FLAG_DISABLED|FMODIFIER_FLAG_MUTED)) == 0) {
+                                       float influence = eval_fmodifier_influence(fcm, evaltime);
+                                       float nval = fmi->evaluate_modifier_time(fcu, fcm, cvalue, evaltime);
+                                       
+                                       evaltime = interpf(nval, evaltime, influence);
+                               }
+                       }
                }
        }
        
@@ -1247,11 +1312,22 @@ void evaluate_value_fmodifiers (ListBase *modifiers, FCurve *fcu, float *cvalue,
        for (fcm= modifiers->first; fcm; fcm= fcm->next) {
                FModifierTypeInfo *fmi= fmodifier_get_typeinfo(fcm);
                
-               /* only evaluate if there's a callback for this */
-               // TODO: implement the 'influence' control feature...
-               if (fmi && fmi->evaluate_modifier) {
-                       if ((fcm->flag & (FMODIFIER_FLAG_DISABLED|FMODIFIER_FLAG_MUTED)) == 0)
-                               fmi->evaluate_modifier(fcu, fcm, cvalue, evaltime);
+               if (fmi == NULL) 
+                       continue;
+               
+               /* only evaluate if there's a callback for this, and if F-Modifier can be evaluated on this frame */
+               if ((fcm->flag & FMODIFIER_FLAG_RANGERESTRICT)==0 || 
+                       ((fcm->sfra <= evaltime) && (fcm->efra >= evaltime)) )
+               {
+                       if (fmi->evaluate_modifier) {
+                               if ((fcm->flag & (FMODIFIER_FLAG_DISABLED|FMODIFIER_FLAG_MUTED)) == 0) {
+                                       float influence = eval_fmodifier_influence(fcm, evaltime);
+                                       float nval = *cvalue;
+                                       
+                                       fmi->evaluate_modifier(fcu, fcm, &nval, evaltime);
+                                       *cvalue = interpf(nval, *cvalue, influence);
+                               }
+                       }
                }
        }
 }