code cleanup: function naming, use BKE_*type* prefix.
[blender.git] / source / blender / blenkernel / intern / fcurve.c
index 4bb9dc47fda8d74fc4502947e3ef31b2a35d6c1a..71c6c8d80aa93ae40b4cec0072854d7b89bdad35 100644 (file)
@@ -71,7 +71,7 @@
 /* ---------------------- Freeing --------------------------- */
 
 /* Frees the F-Curve itself too, so make sure BLI_remlink is called before calling this... */
-void free_fcurve (FCurve *fcu) 
+void free_fcurve(FCurve *fcu)
 {
        if (fcu == NULL) 
                return;
@@ -95,7 +95,7 @@ void free_fcurve (FCurve *fcu)
 }
 
 /* Frees a list of F-Curves */
-void free_fcurves (ListBase *list)
+void free_fcurves(ListBase *list)
 {
        FCurve *fcu, *fcn;
        
@@ -151,12 +151,12 @@ FCurve *copy_fcurve (FCurve *fcu)
 }
 
 /* duplicate a list of F-Curves */
-void copy_fcurves (ListBase *dst, ListBase *src)
+void copy_fcurves(ListBase *dst, ListBase *src)
 {
        FCurve *dfcu, *sfcu;
        
        /* sanity checks */
-       if ELEM(NULL, dst, src)
+       if (ELEM(NULL, dst, src))
                return;
        
        /* clear destination list first */
@@ -183,7 +183,7 @@ FCurve *id_data_find_fcurve(ID *id, void *data, StructRNA *type, const char *pro
        PropertyRNA *prop;
        char *path;
 
-       if(driven)
+       if (driven)
                *driven = FALSE;
        
        /* only use the current action ??? */
@@ -204,7 +204,7 @@ FCurve *id_data_find_fcurve(ID *id, void *data, StructRNA *type, const char *pro
                        /* if not animated, check if driven */
                        if ((fcu == NULL) && (adt->drivers.first)) {
                                fcu= list_find_fcurve(&adt->drivers, path, index);
-                               if(fcu && driven)
+                               if (fcu && driven)
                                        *driven = TRUE;
                                fcu = NULL;
                        }
@@ -270,7 +270,7 @@ FCurve *iter_step_fcurve (FCurve *fcu_iter, const char rna_path[])
  *     - dataPrefix: i.e. 'pose.bones[' or 'nodes['
  *     - dataName: name of entity within "" immediately following the prefix
  */
-int list_find_data_fcurves (ListBase *dst, ListBase *src, const char *dataPrefix, const char *dataName)
+int list_find_data_fcurves(ListBase *dst, ListBase *src, const char *dataPrefix, const char *dataName)
 {
        FCurve *fcu;
        int matches = 0;
@@ -357,12 +357,12 @@ FCurve *rna_get_fcurve (PointerRNA *ptr, PropertyRNA *prop, int rnaindex, bActio
 /* Binary search algorithm for finding where to insert BezTriple. (for use by insert_bezt_fcurve)
  * Returns the index to insert at (data already at that index will be offset if replace is 0)
  */
-int binarysearch_bezt_index (BezTriple array[], float frame, int arraylen, short *replace)
+int binarysearch_bezt_index(BezTriple array[], float frame, int arraylen, short *replace)
 {
        int start=0, end=arraylen;
        int loopbreaker= 0, maxloop= arraylen * 2;
        
-       /* initialise replace-flag first */
+       /* initialize replace-flag first */
        *replace= 0;
        
        /* sneaky optimisations (don't go through searching process if...):
@@ -370,7 +370,7 @@ int binarysearch_bezt_index (BezTriple array[], float frame, int arraylen, short
         *      - keyframe to be added would replace one of the existing ones on bounds
         */
        if ((arraylen <= 0) || (array == NULL)) {
-               printf("Warning: binarysearch_bezt_index() encountered invalid array \n");
+               printf("Warning: binarysearch_bezt_index() encountered invalid array\n");
                return 0;
        }
        else {
@@ -420,10 +420,10 @@ int binarysearch_bezt_index (BezTriple array[], float frame, int arraylen, short
        
        /* print error if loop-limit exceeded */
        if (loopbreaker == (maxloop-1)) {
-               printf("Error: binarysearch_bezt_index() was taking too long \n");
+               printf("Error: binarysearch_bezt_index() was taking too long\n");
                
                // include debug info 
-               printf("\tround = %d: start = %d, end = %d, arraylen = %d \n", loopbreaker, start, end, arraylen);
+               printf("\tround = %d: start = %d, end = %d, arraylen = %d\n", loopbreaker, start, end, arraylen);
        }
        
        /* not found, so return where to place it */
@@ -476,8 +476,8 @@ static void get_fcurve_end_keyframes (FCurve *fcu, BezTriple **first, BezTriple
 
 
 /* Calculate the extents of F-Curve's data */
-void calc_fcurve_bounds (FCurve *fcu, float *xmin, float *xmax, float *ymin, float *ymax,
-                         const short do_sel_only)
+void calc_fcurve_bounds(FCurve *fcu, float *xmin, float *xmax, float *ymin, float *ymax,
+                        const short do_sel_only)
 {
        float xminv=999999999.0f, xmaxv=-999999999.0f;
        float yminv=999999999.0f, ymaxv=-999999999.0f;
@@ -546,7 +546,7 @@ void calc_fcurve_bounds (FCurve *fcu, float *xmin, float *xmax, float *ymin, flo
                if (ymax) *ymax= ymaxv;
        }
        else {
-               if (G.f & G_DEBUG)
+               if (G.debug & G_DEBUG)
                        printf("F-Curve calc bounds didn't find anything, so assuming minimum bounds of 1.0\n");
                        
                if (xmin) *xmin= 0.0f;
@@ -558,8 +558,8 @@ void calc_fcurve_bounds (FCurve *fcu, float *xmin, float *xmax, float *ymin, flo
 }
 
 /* Calculate the extents of F-Curve's keyframes */
-void calc_fcurve_range (FCurve *fcu, float *start, float *end,
-                        const short do_sel_only, const short do_min_length)
+void calc_fcurve_range(FCurve *fcu, float *start, float *end,
+                       const short do_sel_only, const short do_min_length)
 {
        float min=999999999.0f, max=-999999999.0f;
        short foundvert= FALSE;
@@ -610,7 +610,7 @@ void calc_fcurve_range (FCurve *fcu, float *start, float *end,
  * Usability of keyframes refers to whether they should be displayed,
  * and also whether they will have any influence on the final result.
  */
-short fcurve_are_keyframes_usable (FCurve *fcu)
+short fcurve_are_keyframes_usable(FCurve *fcu)
 {
        /* F-Curve must exist */
        if (fcu == NULL)
@@ -671,7 +671,7 @@ short fcurve_are_keyframes_usable (FCurve *fcu)
 /* Can keyframes be added to F-Curve? 
  * Keyframes can only be added if they are already visible
  */
-short fcurve_is_keyframable (FCurve *fcu)
+short fcurve_is_keyframable(FCurve *fcu)
 {
        /* F-Curve's keyframes must be "usable" (i.e. visible + have an effect on final result) */
        if (fcurve_are_keyframes_usable(fcu) == 0)
@@ -688,7 +688,7 @@ short fcurve_is_keyframable (FCurve *fcu)
 /* ***************************** Keyframe Column Tools ********************************* */
 
 /* add a BezTriple to a column */
-void bezt_add_to_cfra_elem (ListBase *lb, BezTriple *bezt)
+void bezt_add_to_cfra_elem(ListBase *lb, BezTriple *bezt)
 {
        CfraElem *ce, *cen;
        
@@ -721,7 +721,7 @@ void bezt_add_to_cfra_elem (ListBase *lb, BezTriple *bezt)
 /* Basic sampling callback which acts as a wrapper for evaluate_fcurve() 
  *     'data' arg here is unneeded here...
  */
-float fcurve_samplingcb_evalcurve (FCurve *fcu, void *UNUSED(data), float evaltime)
+float fcurve_samplingcb_evalcurve(FCurve *fcu, void *UNUSED(data), float evaltime)
 {
        /* assume any interference from drivers on the curve is intended... */
        return evaluate_fcurve(fcu, evaltime);
@@ -731,19 +731,19 @@ float fcurve_samplingcb_evalcurve (FCurve *fcu, void *UNUSED(data), float evalti
 /* Main API function for creating a set of sampled curve data, given some callback function 
  * used to retrieve the values to store.
  */
-void fcurve_store_samples (FCurve *fcu, void *data, int start, int end, FcuSampleFunc sample_cb)
+void fcurve_store_samples(FCurve *fcu, void *data, int start, int end, FcuSampleFunc sample_cb)
 {
        FPoint *fpt, *new_fpt;
        int cfra;
        
        /* sanity checks */
        // TODO: make these tests report errors using reports not printf's
-       if ELEM(NULL, fcu, sample_cb) {
+       if (ELEM(NULL, fcu, sample_cb)) {
                printf("Error: No F-Curve with F-Curve Modifiers to Bake\n");
                return;
        }
        if (start >= end) {
-               printf("Error: Frame range for Sampled F-Curve creation is inappropriate \n");
+               printf("Error: Frame range for Sampled F-Curve creation is inappropriate\n");
                return;
        }
        
@@ -775,7 +775,7 @@ void fcurve_store_samples (FCurve *fcu, void *data, int start, int end, FcuSampl
 /* This function recalculates the handles of an F-Curve 
  * If the BezTriples have been rearranged, sort them first before using this.
  */
-void calchandles_fcurve (FCurve *fcu)
+void calchandles_fcurve(FCurve *fcu)
 {
        BezTriple *bezt, *prev, *next;
        int a= fcu->totvert;
@@ -800,10 +800,10 @@ void calchandles_fcurve (FCurve *fcu)
                if (bezt->vec[2][0] < bezt->vec[1][0]) bezt->vec[2][0]= bezt->vec[1][0];
                
                /* calculate auto-handles */
-               calchandleNurb(bezt, prev, next, 1);    /* 1==special autohandle */
+               BKE_nurb_handle_calc(bezt, prev, next, 1);      /* 1==special autohandle */
                
                /* for automatic ease in and out */
-               if (ELEM(bezt->h1,HD_AUTO,HD_AUTO_ANIM) && ELEM(bezt->h2,HD_AUTO,HD_AUTO_ANIM)) {
+               if (ELEM(bezt->h1, HD_AUTO, HD_AUTO_ANIM) && ELEM(bezt->h2, HD_AUTO, HD_AUTO_ANIM)) {
                        /* only do this on first or last beztriple */
                        if ((a == 0) || (a == fcu->totvert-1)) {
                                /* set both handles to have same horizontal value as keyframe */
@@ -827,26 +827,26 @@ void calchandles_fcurve (FCurve *fcu)
  *             -> Auto handles: become aligned when selection status is NOT(000 || 111)
  *             -> Vector handles: become 'nothing' when (one half selected AND other not)
  *  - PHASE 2: recalculate handles
-*/
-void testhandles_fcurve (FCurve *fcu, const short use_handle)
+ */
+void testhandles_fcurve(FCurve *fcu, const short use_handle)
 {
        BezTriple *bezt;
        unsigned int a;
 
        /* only beztriples have handles (bpoints don't though) */
-       if ELEM(NULL, fcu, fcu->bezt)
+       if (ELEM(NULL, fcu, fcu->bezt))
                return;
        
        /* loop over beztriples */
        for (a=0, bezt=fcu->bezt; a < fcu->totvert; a++, bezt++) {
                short flag= 0;
                
-               /* flag is initialised as selection status
+               /* flag is initialized as selection status
                 * of beztriple control-points (labelled 0,1,2)
                 */
                if (bezt->f2 & SELECT) flag |= (1<<1); // == 2
-               if(use_handle == FALSE) {
-                       if(flag & 2) {
+               if (use_handle == FALSE) {
+                       if (flag & 2) {
                                flag |= (1<<0) | (1<<2);
                        }
                }
@@ -884,7 +884,7 @@ void testhandles_fcurve (FCurve *fcu, const short use_handle)
 /* This function sorts BezTriples so that they are arranged in chronological order,
  * as tools working on F-Curves expect that the BezTriples are in order.
  */
-void sort_time_fcurve (FCurve *fcu)
+void sort_time_fcurve(FCurve *fcu)
 {
        short ok= 1;
        
@@ -927,7 +927,7 @@ void sort_time_fcurve (FCurve *fcu)
 }
 
 /* This function tests if any BezTriples are out of order, thus requiring a sort */
-short test_time_fcurve (FCurve *fcu)
+short test_time_fcurve(FCurve *fcu)
 {
        unsigned int a;
        
@@ -1001,7 +1001,7 @@ static float dtar_get_prop_val (ChannelDriver *driver, DriverTarget *dtar)
        float value= 0.0f;
        
        /* sanity check */
-       if ELEM(NULL, driver, dtar)
+       if (ELEM(NULL, driver, dtar))
                return 0.0f;
        
        id= dtar_id_ensure_proxy_from(dtar->id);
@@ -1009,8 +1009,8 @@ static float dtar_get_prop_val (ChannelDriver *driver, DriverTarget *dtar)
        /* error check for missing pointer... */
        // TODO: tag the specific target too as having issues
        if (id == NULL) {
-               printf("Error: driver has an invalid target to use \n");
-               if (G.f & G_DEBUG) printf("\tpath = %s\n", dtar->rna_path);
+               printf("Error: driver has an invalid target to use\n");
+               if (G.debug & G_DEBUG) printf("\tpath = %s\n", dtar->rna_path);
                driver->flag |= DRIVER_FLAG_INVALID;
                return 0.0f;
        }
@@ -1020,7 +1020,7 @@ static float dtar_get_prop_val (ChannelDriver *driver, DriverTarget *dtar)
        
        /* get property to read from, and get value as appropriate */
        if (RNA_path_resolve_full(&id_ptr, dtar->rna_path, &ptr, &prop, &index)) {
-               if(RNA_property_array_check(prop)) {
+               if (RNA_property_array_check(prop)) {
                        /* array */
                        if (index < RNA_property_array_length(&ptr, prop)) {    
                                switch (RNA_property_type(prop)) {
@@ -1060,8 +1060,8 @@ static float dtar_get_prop_val (ChannelDriver *driver, DriverTarget *dtar)
 
        }
        else {
-               if (G.f & G_DEBUG)
-                       printf("Driver Evaluation Error: cannot resolve target for %s -> %s \n", id->name, dtar->rna_path);
+               if (G.debug & G_DEBUG)
+                       printf("Driver Evaluation Error: cannot resolve target for %s -> %s\n", id->name, dtar->rna_path);
                
                driver->flag |= DRIVER_FLAG_INVALID;
                return 0.0f;
@@ -1075,7 +1075,7 @@ static bPoseChannel *dtar_get_pchan_ptr (ChannelDriver *driver, DriverTarget *dt
 {
        ID *id;
        /* sanity check */
-       if ELEM(NULL, driver, dtar)
+       if (ELEM(NULL, driver, dtar))
                return NULL;
 
        id= dtar_id_ensure_proxy_from(dtar->id);
@@ -1118,11 +1118,11 @@ static float dvar_eval_rotDiff (ChannelDriver *driver, DriverVar *dvar)
                
                /* check what the error was */
                if ((pchan == NULL) && (pchan2 == NULL))
-                       printf("Driver Evaluation Error: Rotational difference failed - first 2 targets invalid \n");
+                       printf("Driver Evaluation Error: Rotational difference failed - first 2 targets invalid\n");
                else if (pchan == NULL)
-                       printf("Driver Evaluation Error: Rotational difference failed - first target not valid PoseChannel \n");
+                       printf("Driver Evaluation Error: Rotational difference failed - first target not valid PoseChannel\n");
                else if (pchan2 == NULL)
-                       printf("Driver Evaluation Error: Rotational difference failed - second target not valid PoseChannel \n");
+                       printf("Driver Evaluation Error: Rotational difference failed - second target not valid PoseChannel\n");
                        
                /* stop here... */
                return 0.0f;
@@ -1144,8 +1144,8 @@ static float dvar_eval_rotDiff (ChannelDriver *driver, DriverVar *dvar)
 // TODO: this needs to take into account space conversions...
 static float dvar_eval_locDiff (ChannelDriver *driver, DriverVar *dvar)
 {
-       float loc1[3] = {0.0f,0.0f,0.0f};
-       float loc2[3] = {0.0f,0.0f,0.0f};
+       float loc1[3] = {0.0f, 0.0f, 0.0f};
+       float loc2[3] = {0.0f, 0.0f, 0.0f};
        
        /* get two location values */
        // NOTE: for now, these are all just worldspace
@@ -1240,7 +1240,7 @@ static float dvar_eval_transChan (ChannelDriver *driver, DriverVar *dvar)
        Object *ob= (Object *)dtar_id_ensure_proxy_from(dtar->id);
        bPoseChannel *pchan;
        float mat[4][4];
-       float oldEul[3] = {0.0f,0.0f,0.0f};
+       float oldEul[3] = {0.0f, 0.0f, 0.0f};
        short useEulers=0, rotOrder=ROT_MODE_EUL;
        
        /* check if this target has valid data */
@@ -1283,7 +1283,7 @@ static float dvar_eval_transChan (ChannelDriver *driver, DriverVar *dvar)
                }
                else {
                        /* worldspace matrix */
-                       mul_m4_m4m4(mat, pchan->pose_mat, ob->obmat);
+                       mult_m4_m4m4(mat, ob->obmat, pchan->pose_mat);
                }
        }
        else {
@@ -1302,7 +1302,7 @@ static float dvar_eval_transChan (ChannelDriver *driver, DriverVar *dvar)
                        }
                        else {
                                /* transforms to matrix */
-                               object_to_mat4(ob, mat);
+                               BKE_object_to_mat4(ob, mat);
                        }
                }
                else {
@@ -1394,7 +1394,7 @@ static DriverVarTypeInfo *get_dvar_typeinfo (int type)
 /* Driver API --------------------------------- */
 
 /* This frees the driver variable itself */
-void driver_free_variable (ChannelDriver *driver, DriverVar *dvar)
+void driver_free_variable(ChannelDriver *driver, DriverVar *dvar)
 {
        /* sanity checks */
        if (dvar == NULL)
@@ -1414,20 +1414,17 @@ void driver_free_variable (ChannelDriver *driver, DriverVar *dvar)
        DRIVER_TARGETS_LOOPER_END
        
        /* remove the variable from the driver */
-       if (driver)
-               BLI_freelinkN(&driver->variables, dvar);
-       else
-               MEM_freeN(dvar);
+       BLI_freelinkN(&driver->variables, dvar);
 
 #ifdef WITH_PYTHON
        /* since driver variables are cached, the expression needs re-compiling too */
-       if(driver->type==DRIVER_TYPE_PYTHON)
+       if (driver->type==DRIVER_TYPE_PYTHON)
                driver->flag |= DRIVER_FLAG_RENAMEVAR;
 #endif
 }
 
 /* Change the type of driver variable */
-void driver_change_variable_type (DriverVar *dvar, int type)
+void driver_change_variable_type(DriverVar *dvar, int type)
 {
        DriverVarTypeInfo *dvti= get_dvar_typeinfo(type);
        
@@ -1449,7 +1446,7 @@ void driver_change_variable_type (DriverVar *dvar, int type)
                /* store the flags */
                dtar->flag = flags;
                
-               /* object ID types only, or idtype not yet initialised*/
+               /* object ID types only, or idtype not yet initialized*/
                if ((flags & DTAR_FLAG_ID_OB_ONLY) || (dtar->idtype == 0))
                        dtar->idtype= ID_OB;
        }
@@ -1493,7 +1490,7 @@ void fcurve_free_driver(FCurve *fcu)
        DriverVar *dvar, *dvarn;
        
        /* sanity checks */
-       if ELEM(NULL, fcu, fcu->driver)
+       if (ELEM(NULL, fcu, fcu->driver))
                return;
        driver= fcu->driver;
        
@@ -1550,7 +1547,7 @@ ChannelDriver *fcurve_copy_driver (ChannelDriver *driver)
 /* Driver Evaluation -------------------------- */
 
 /* Evaluate a Driver Variable to get a value that contributes to the final */
-float driver_get_variable_value (ChannelDriver *driver, DriverVar *dvar)
+float driver_get_variable_value(ChannelDriver *driver, DriverVar *dvar)
 {
        DriverVarTypeInfo *dvti;
 
@@ -1658,9 +1655,8 @@ static float evaluate_driver (ChannelDriver *driver, const float evaltime)
                        {
                                driver->curval= 0.0f;
                        }
-                       else
-                       {
-                               /* this evaluates the expression using Python,and returns its result:
+                       else {
+                               /* this evaluates the expression using Python, and returns its result:
                                 *      - on errors it reports, then returns 0.0f
                                 */
                                driver->curval= BPY_driver_exec(driver, evaltime);
@@ -1689,8 +1685,8 @@ static float evaluate_driver (ChannelDriver *driver, const float evaltime)
 /* The total length of the handles is not allowed to be more
  * than the horizontal distance between (v1-v4).
  * This is to prevent curve loops.
-*/
-void correct_bezpart (float *v1, float *v2, float *v3, float *v4)
+ */
+void correct_bezpart(float v1[2], float v2[2], float v3[2], float v4[2])
 {
        float h1[2], h2[2], len1, len2, len, fac;
        
@@ -1707,8 +1703,8 @@ void correct_bezpart (float *v1, float *v2, float *v3, float *v4)
         *      - len2  = length of handle of end key
         */
        len= v4[0]- v1[0];
-       len1= (float)fabs(h1[0]);
-       len2= (float)fabs(h2[0]);
+       len1= fabsf(h1[0]);
+       len2= fabsf(h2[0]);
        
        /* if the handles have no length, no need to do any corrections */
        if ((len1+len2) == 0.0f) 
@@ -1876,22 +1872,20 @@ static float fcurve_eval_keyframes (FCurve *fcu, BezTriple *bezts, float evaltim
        lastbezt= prevbezt + a;
        
        /* evaluation time at or past endpoints? */
-       if (prevbezt->vec[1][0] >= evaltime) 
-       {
+       if (prevbezt->vec[1][0] >= evaltime) {
                /* before or on first keyframe */
                if ( (fcu->extend == FCURVE_EXTRAPOLATE_LINEAR) && (prevbezt->ipo != BEZT_IPO_CONST) &&
-                       !(fcu->flag & FCURVE_DISCRETE_VALUES) ) 
+                       !(fcu->flag & FCURVE_DISCRETE_VALUES) )
                {
                        /* linear or bezier interpolation */
-                       if (prevbezt->ipo==BEZT_IPO_LIN) 
-                       {
+                       if (prevbezt->ipo==BEZT_IPO_LIN) {
                                /* Use the next center point instead of our own handle for
                                 * linear interpolated extrapolate 
                                 */
-                               if (fcu->totvert == 1) 
+                               if (fcu->totvert == 1) {
                                        cvalue= prevbezt->vec[1][1];
-                               else 
-                               {
+                               }
+                               else {
                                        bezt = prevbezt+1;
                                        dx= prevbezt->vec[1][0] - evaltime;
                                        fac= bezt->vec[1][0] - prevbezt->vec[1][0];
@@ -1901,12 +1895,12 @@ static float fcurve_eval_keyframes (FCurve *fcu, BezTriple *bezts, float evaltim
                                                fac= (bezt->vec[1][1] - prevbezt->vec[1][1]) / fac;
                                                cvalue= prevbezt->vec[1][1] - (fac * dx);
                                        }
-                                       else 
+                                       else {
                                                cvalue= prevbezt->vec[1][1];
+                                       }
                                }
                        } 
-                       else 
-                       {
+                       else {
                                /* Use the first handle (earlier) of first BezTriple to calculate the
                                 * gradient and thus the value of the curve at evaltime
                                 */
@@ -1918,34 +1912,32 @@ static float fcurve_eval_keyframes (FCurve *fcu, BezTriple *bezts, float evaltim
                                        fac= (prevbezt->vec[1][1] - prevbezt->vec[0][1]) / fac;
                                        cvalue= prevbezt->vec[1][1] - (fac * dx);
                                }
-                               else 
+                               else {
                                        cvalue= prevbezt->vec[1][1];
+                               }
                        }
                }
-               else 
-               {
+               else {
                        /* constant (BEZT_IPO_HORIZ) extrapolation or constant interpolation, 
                         * so just extend first keyframe's value 
                         */
                        cvalue= prevbezt->vec[1][1];
                }
        }
-       else if (lastbezt->vec[1][0] <= evaltime) 
-       {
+       else if (lastbezt->vec[1][0] <= evaltime) {
                /* after or on last keyframe */
                if ( (fcu->extend == FCURVE_EXTRAPOLATE_LINEAR) && (lastbezt->ipo != BEZT_IPO_CONST) &&
                        !(fcu->flag & FCURVE_DISCRETE_VALUES) ) 
                {
                        /* linear or bezier interpolation */
-                       if (lastbezt->ipo==BEZT_IPO_LIN) 
-                       {
+                       if (lastbezt->ipo==BEZT_IPO_LIN) {
                                /* Use the next center point instead of our own handle for
                                 * linear interpolated extrapolate 
                                 */
-                               if (fcu->totvert == 1) 
+                               if (fcu->totvert == 1) {
                                        cvalue= lastbezt->vec[1][1];
-                               else 
-                               {
+                               }
+                               else {
                                        prevbezt = lastbezt - 1;
                                        dx= evaltime - lastbezt->vec[1][0];
                                        fac= lastbezt->vec[1][0] - prevbezt->vec[1][0];
@@ -1955,12 +1947,12 @@ static float fcurve_eval_keyframes (FCurve *fcu, BezTriple *bezts, float evaltim
                                                fac= (lastbezt->vec[1][1] - prevbezt->vec[1][1]) / fac;
                                                cvalue= lastbezt->vec[1][1] + (fac * dx);
                                        }
-                                       else 
+                                       else {
                                                cvalue= lastbezt->vec[1][1];
+                                       }
                                }
                        } 
-                       else 
-                       {
+                       else {
                                /* Use the gradient of the second handle (later) of last BezTriple to calculate the
                                 * gradient and thus the value of the curve at evaltime
                                 */
@@ -1972,38 +1964,33 @@ static float fcurve_eval_keyframes (FCurve *fcu, BezTriple *bezts, float evaltim
                                        fac= (lastbezt->vec[2][1] - lastbezt->vec[1][1]) / fac;
                                        cvalue= lastbezt->vec[1][1] + (fac * dx);
                                }
-                               else 
+                               else {
                                        cvalue= lastbezt->vec[1][1];
+                               }
                        }
                }
-               else 
-               {
+               else {
                        /* constant (BEZT_IPO_HORIZ) extrapolation or constant interpolation, 
                         * so just extend last keyframe's value 
                         */
                        cvalue= lastbezt->vec[1][1];
                }
        }
-       else 
-       {
+       else {
                /* evaltime occurs somewhere in the middle of the curve */
-               for (a=0; prevbezt && bezt && (a < fcu->totvert-1); a++, prevbezt=bezt, bezt++) 
-               {
+               for (a=0; prevbezt && bezt && (a < fcu->totvert-1); a++, prevbezt=bezt, bezt++) {
                        /* use if the key is directly on the frame, rare cases this is needed else we get 0.0 instead. */
-                       if(fabs(bezt->vec[1][0] - evaltime) < SMALL_NUMBER) {
+                       if (fabsf(bezt->vec[1][0] - evaltime) < SMALL_NUMBER) {
                                cvalue= bezt->vec[1][1];
                        }
                        /* evaltime occurs within the interval defined by these two keyframes */
-                       else if ((prevbezt->vec[1][0] <= evaltime) && (bezt->vec[1][0] >= evaltime))
-                       {
+                       else if ((prevbezt->vec[1][0] <= evaltime) && (bezt->vec[1][0] >= evaltime)) {
                                /* value depends on interpolation mode */
-                               if ((prevbezt->ipo == BEZT_IPO_CONST) || (fcu->flag & FCURVE_DISCRETE_VALUES))
-                               {
+                               if ((prevbezt->ipo == BEZT_IPO_CONST) || (fcu->flag & FCURVE_DISCRETE_VALUES)) {
                                        /* constant (evaltime not relevant, so no interpolation needed) */
                                        cvalue= prevbezt->vec[1][1];
                                }
-                               else if (prevbezt->ipo == BEZT_IPO_LIN) 
-                               {
+                               else if (prevbezt->ipo == BEZT_IPO_LIN) {
                                        /* linear - interpolate between values of the two keyframes */
                                        fac= bezt->vec[1][0] - prevbezt->vec[1][0];
                                        
@@ -2012,11 +1999,11 @@ static float fcurve_eval_keyframes (FCurve *fcu, BezTriple *bezts, float evaltim
                                                fac= (evaltime - prevbezt->vec[1][0]) / fac;
                                                cvalue= prevbezt->vec[1][1] + (fac * (bezt->vec[1][1] - prevbezt->vec[1][1]));
                                        }
-                                       else
+                                       else {
                                                cvalue= prevbezt->vec[1][1];
+                                       }
                                }
-                               else 
-                               {
+                               else {
                                        /* bezier interpolation */
                                                /* v1,v2 are the first keyframe and its 2nd handle */
                                        v1[0]= prevbezt->vec[1][0];
@@ -2089,7 +2076,7 @@ static float fcurve_eval_samples (FCurve *fcu, FPoint *fpts, float evaltime)
 /* Evaluate and return the value of the given F-Curve at the specified frame ("evaltime") 
  * Note: this is also used for drivers
  */
-float evaluate_fcurve (FCurve *fcu, float evaltime)
+float evaluate_fcurve(FCurve *fcu, float evaltime)
 {
        float cvalue= 0.0f;
        float devaltime;
@@ -2129,13 +2116,13 @@ float evaluate_fcurve (FCurve *fcu, float evaltime)
 }
 
 /* Calculate the value of the given F-Curve at the given frame, and set its curval */
-void calculate_fcurve (FCurve *fcu, float ctime)
+void calculate_fcurve(FCurve *fcu, float ctime)
 {
        /* only calculate + set curval (overriding the existing value) if curve has 
         * any data which warrants this...
         */
-       if ( (fcu->totvert) || (fcu->driver && !(fcu->driver->flag & DRIVER_FLAG_INVALID)) ||
-                list_has_suitable_fmodifier(&fcu->modifiers, 0, FMI_TYPE_GENERATE_CURVE) )
+       if ((fcu->totvert) || (fcu->driver && !(fcu->driver->flag & DRIVER_FLAG_INVALID)) ||
+           list_has_suitable_fmodifier(&fcu->modifiers, 0, FMI_TYPE_GENERATE_CURVE))
        {
                /* calculate and set curval (evaluates driver too if necessary) */
                fcu->curval= evaluate_fcurve(fcu, ctime);