rename api functions...
[blender.git] / source / blender / blenkernel / intern / key.c
index 670ffd2b7c6888d828b6de5699c825d4cef614c6..7df5449b1b155ec3d4b7e7f6a4c283e90dff1e26 100644 (file)
 #include "MEM_guardedalloc.h"
 
 #include "BLI_blenlib.h"
 #include "MEM_guardedalloc.h"
 
 #include "BLI_blenlib.h"
-#include "BLI_editVert.h"
 #include "BLI_math_vector.h"
 #include "BLI_utildefines.h"
 
 #include "DNA_anim_types.h"
 #include "DNA_key_types.h"
 #include "DNA_lattice_types.h"
 #include "BLI_math_vector.h"
 #include "BLI_utildefines.h"
 
 #include "DNA_anim_types.h"
 #include "DNA_key_types.h"
 #include "DNA_lattice_types.h"
+#include "DNA_mesh_types.h"
 #include "DNA_meshdata_types.h"
 #include "DNA_object_types.h"
 #include "DNA_scene_types.h"
 #include "DNA_meshdata_types.h"
 #include "DNA_object_types.h"
 #include "DNA_scene_types.h"
 
 #include "RNA_access.h"
 
 
 #include "RNA_access.h"
 
-#define KEY_MODE_DUMMY         0 /* use where mode isn't checked for */
-#define KEY_MODE_BPOINT                1
-#define KEY_MODE_BEZTRIPLE     2
+#define KEY_MODE_DUMMY      0 /* use where mode isn't checked for */
+#define KEY_MODE_BPOINT     1
+#define KEY_MODE_BEZTRIPLE  2
 
 
-       // old defines from DNA_ipo_types.h for data-type
-#define IPO_FLOAT              4
-#define IPO_BEZTRIPLE  100
-#define IPO_BPOINT             101
+/* old defines from DNA_ipo_types.h for data-type, stored in DNA - don't modify! */
+#define IPO_FLOAT       4
+#define IPO_BEZTRIPLE   100
+#define IPO_BPOINT      101
 
 
-int slurph_opt= 1;
+/* extern, not threadsafe */
+int slurph_opt = 1;
 
 
 
 
-void free_key(Key *key)
+void BKE_key_free(Key *key)
 {
        KeyBlock *kb;
        
        BKE_free_animdata((ID *)key);
        
 {
        KeyBlock *kb;
        
        BKE_free_animdata((ID *)key);
        
-       while( (kb= key->block.first) ) {
+       while ( (kb = key->block.first) ) {
                
                
-               if(kb->data) MEM_freeN(kb->data);
+               if (kb->data) MEM_freeN(kb->data);
                
                BLI_remlink(&key->block, kb);
                MEM_freeN(kb);
                
                BLI_remlink(&key->block, kb);
                MEM_freeN(kb);
@@ -93,13 +94,13 @@ void free_key(Key *key)
        
 }
 
        
 }
 
-void free_key_nolib(Key *key)
+void BKE_key_free_nolib(Key *key)
 {
        KeyBlock *kb;
        
 {
        KeyBlock *kb;
        
-       while( (kb= key->block.first) ) {
+       while ( (kb = key->block.first) ) {
                
                
-               if(kb->data) MEM_freeN(kb->data);
+               if (kb->data) MEM_freeN(kb->data);
                
                BLI_remlink(&key->block, kb);
                MEM_freeN(kb);
                
                BLI_remlink(&key->block, kb);
                MEM_freeN(kb);
@@ -115,116 +116,123 @@ void free_key_nolib(Key *key)
  * well. I expect we'll sort it out soon... */
 
 /* from blendef: */
  * well. I expect we'll sort it out soon... */
 
 /* from blendef: */
-#define GS(a)  (*((short *)(a)))
+#define GS(a)   (*((short *)(a)))
 
 /* from misc_util: flip the bytes from x  */
 /*  #define GS(x) (((unsigned char *)(x))[0] << 8 | ((unsigned char *)(x))[1]) */
 
 
 /* from misc_util: flip the bytes from x  */
 /*  #define GS(x) (((unsigned char *)(x))[0] << 8 | ((unsigned char *)(x))[1]) */
 
-Key *add_key(ID *id)   /* common function */
+Key *BKE_key_add(ID *id)    /* common function */
 {
        Key *key;
        char *el;
        
 {
        Key *key;
        char *el;
        
-       key= alloc_libblock(&G.main->key, ID_KE, "Key");
+       key = BKE_libblock_alloc(&G.main->key, ID_KE, "Key");
        
        
-       key->type= KEY_NORMAL;
-       key->from= id;
+       key->type = KEY_NORMAL;
+       key->from = id;
 
        key->uidgen = 1;
        
 
        key->uidgen = 1;
        
-       // XXX the code here uses some defines which will soon be depreceated...
-       if( GS(id->name)==ID_ME) {
-               el= key->elemstr;
-               
-               el[0]= 3;
-               el[1]= IPO_FLOAT;
-               el[2]= 0;
-               
-               key->elemsize= 12;
-       }
-       else if( GS(id->name)==ID_LT) {
-               el= key->elemstr;
-               
-               el[0]= 3;
-               el[1]= IPO_FLOAT;
-               el[2]= 0;
-               
-               key->elemsize= 12;
-       }
-       else if( GS(id->name)==ID_CU) {
-               el= key->elemstr;
-               
-               el[0]= 4;
-               el[1]= IPO_BPOINT;
-               el[2]= 0;
-               
-               key->elemsize= 16;
+       /* XXX the code here uses some defines which will soon be deprecated... */
+       switch (GS(id->name)) {
+               case ID_ME:
+                       el = key->elemstr;
+
+                       el[0] = 3;
+                       el[1] = IPO_FLOAT;
+                       el[2] = 0;
+
+                       key->elemsize = 12;
+
+                       break;
+               case ID_LT:
+                       el = key->elemstr;
+
+                       el[0] = 3;
+                       el[1] = IPO_FLOAT;
+                       el[2] = 0;
+
+                       key->elemsize = 12;
+
+                       break;
+               case ID_CU:
+                       el = key->elemstr;
+
+                       el[0] = 4;
+                       el[1] = IPO_BPOINT;
+                       el[2] = 0;
+
+                       key->elemsize = 16;
+
+                       break;
        }
        
        return key;
 }
 
        }
        
        return key;
 }
 
-Key *copy_key(Key *key)
+Key *BKE_key_copy(Key *key)
 {
        Key *keyn;
        KeyBlock *kbn, *kb;
        
 {
        Key *keyn;
        KeyBlock *kbn, *kb;
        
-       if(key==NULL) return NULL;
+       if (key == NULL) return NULL;
        
        
-       keyn= copy_libblock(&key->id);
+       keyn = BKE_libblock_copy(&key->id);
        
        BLI_duplicatelist(&keyn->block, &key->block);
        
        
        BLI_duplicatelist(&keyn->block, &key->block);
        
-       kb= key->block.first;
-       kbn= keyn->block.first;
-       while(kbn) {
+       kb = key->block.first;
+       kbn = keyn->block.first;
+       while (kbn) {
                
                
-               if(kbn->data) kbn->data= MEM_dupallocN(kbn->data);
-               if(kb==key->refkey) keyn->refkey= kbn;
+               if (kbn->data) kbn->data = MEM_dupallocN(kbn->data);
+               if (kb == key->refkey) keyn->refkey = kbn;
                
                
-               kbn= kbn->next;
-               kb= kb->next;
+               kbn = kbn->next;
+               kb = kb->next;
        }
        
        return keyn;
 }
 
 
        }
        
        return keyn;
 }
 
 
-Key *copy_key_nolib(Key *key)
+Key *BKE_key_copy_nolib(Key *key)
 {
        Key *keyn;
        KeyBlock *kbn, *kb;
        
 {
        Key *keyn;
        KeyBlock *kbn, *kb;
        
-       if(key==0) return 0;
-       
-       keyn= MEM_dupallocN(key);
+       if (key == 0) return 0;
        
        
+       keyn = MEM_dupallocN(key);
+
+       keyn->adt = NULL;
+
        BLI_duplicatelist(&keyn->block, &key->block);
        
        BLI_duplicatelist(&keyn->block, &key->block);
        
-       kb= key->block.first;
-       kbn= keyn->block.first;
-       while(kbn) {
+       kb = key->block.first;
+       kbn = keyn->block.first;
+       while (kbn) {
                
                
-               if(kbn->data) kbn->data= MEM_dupallocN(kbn->data);
-               if(kb==key->refkey) keyn->refkey= kbn;
+               if (kbn->data) kbn->data = MEM_dupallocN(kbn->data);
+               if (kb == key->refkey) keyn->refkey = kbn;
                
                
-               kbn= kbn->next;
-               kb= kb->next;
+               kbn = kbn->next;
+               kb = kb->next;
        }
        
        return keyn;
 }
 
        }
        
        return keyn;
 }
 
-void make_local_key(Key *key)
+void BKE_key_make_local(Key *key)
 {
 
        /* - only lib users: do nothing
 {
 
        /* - only lib users: do nothing
-       * - only local users: set flag
-       * - mixed: make copy
-       */
-       if(key==NULL) return;
+        * - only local users: set flag
+        * - mixed: make copy
+        */
+       if (key == NULL) return;
        
        
-       key->id.lib= NULL;
+       key->id.lib = NULL;
        new_id(NULL, &key->id, NULL);
 }
 
        new_id(NULL, &key->id, NULL);
 }
 
@@ -233,15 +241,13 @@ void make_local_key(Key *key)
  * currently being called.
  */
 
  * currently being called.
  */
 
-void sort_keys(Key *key)
+void BKE_key_sort(Key *key)
 {
        KeyBlock *kb;
 {
        KeyBlock *kb;
-       //short i, adrcode;
-       //IpoCurve *icu = NULL;
        KeyBlock *kb2;
 
        /* locate the key which is out of position */ 
        KeyBlock *kb2;
 
        /* locate the key which is out of position */ 
-       for (kb= key->block.first; kb; kb= kb->next)
+       for (kb = key->block.first; kb; kb = kb->next)
                if ((kb->next) && (kb->pos > kb->next->pos))
                        break;
 
                if ((kb->next) && (kb->pos > kb->next->pos))
                        break;
 
@@ -251,262 +257,222 @@ void sort_keys(Key *key)
                BLI_remlink(&key->block, kb);
                
                /* find the right location and insert before */
                BLI_remlink(&key->block, kb);
                
                /* find the right location and insert before */
-               for (kb2=key->block.first; kb2; kb2= kb2->next) {
+               for (kb2 = key->block.first; kb2; kb2 = kb2->next) {
                        if (kb2->pos > kb->pos) {
                                BLI_insertlink(&key->block, kb2->prev, kb);
                                break;
                        }
                }
                        if (kb2->pos > kb->pos) {
                                BLI_insertlink(&key->block, kb2->prev, kb);
                                break;
                        }
                }
-               
-               /* if more than one Ipo curve, see if this key had a curve */
-#if 0 // XXX old animation system
-               if(key->ipo && key->ipo->curve.first != key->ipo->curve.last ) {
-                       for(icu= key->ipo->curve.first; icu; icu= icu->next) {
-                               /* if we find the curve, remove it and reinsert in the 
-                                right place */
-                               if(icu->adrcode==kb->adrcode) {
-                                       IpoCurve *icu2;
-                                       BLI_remlink(&key->ipo->curve, icu);
-                                       for(icu2= key->ipo->curve.first; icu2; icu2= icu2->next) {
-                                               if(icu2->adrcode >= kb2->adrcode) {
-                                                       BLI_insertlink(&key->ipo->curve, icu2->prev, icu);
-                                                       break;
-                                               }
-                                       }
-                                       break;
-                               }
-                       }
-               }
-               
-               /* kb points at the moved key, icu at the moved ipo (if it exists).
-                * go back now and renumber adrcodes */
-
-               /* first new code */
-               adrcode = kb2->adrcode;
-               for (i = kb->adrcode - adrcode; i >= 0; i--, adrcode++) {
-                       /* if the next ipo curve matches the current key, renumber it */
-                       if(icu && icu->adrcode == kb->adrcode ) {
-                               icu->adrcode = adrcode;
-                               icu = icu->next;
-                       }
-                       /* renumber the shape key */
-                       kb->adrcode = adrcode;
-                       kb = kb->next;
-               }
-#endif // XXX old animation system
        }
 
        /* new rule; first key is refkey, this to match drawing channels... */
        }
 
        /* new rule; first key is refkey, this to match drawing channels... */
-       key->refkey= key->block.first;
+       key->refkey = key->block.first;
 }
 
 /**************** do the key ****************/
 
 }
 
 /**************** do the key ****************/
 
-void key_curve_position_weights(float t, float *data, int type)
+void key_curve_position_weights(float t, float data[4], int type)
 {
        float t2, t3, fc;
        
 {
        float t2, t3, fc;
        
-       if(type==KEY_LINEAR) {
-               data[0]=                  0.0f;
-               data[1]= -t             + 1.0f;
-               data[2]= t;
-               data[3]=                  0.0f;
-       }
-       else if(type==KEY_CARDINAL) {
-               t2= t*t;
-               t3= t2*t;
-               fc= 0.71f;
-               
-               data[0]= -fc*t3                 + 2.0f*fc*t2            - fc*t;
-               data[1]= (2.0f-fc)*t3   + (fc-3.0f)*t2                                  + 1.0f;
-               data[2]= (fc-2.0f)*t3   + (3.0f-2.0f*fc)*t2     + fc*t;
-               data[3]= fc*t3                  - fc*t2;
-       }
-       else if(type==KEY_BSPLINE) {
-               t2= t*t;
-               t3= t2*t;
-
-               data[0]= -0.16666666f*t3        + 0.5f*t2       - 0.5f*t        + 0.16666666f;
-               data[1]= 0.5f*t3                        - t2                                    + 0.6666666f;
-               data[2]= -0.5f*t3                       + 0.5f*t2       + 0.5f*t        + 0.16666666f;
-               data[3]= 0.16666666f*t3;
+       if (type == KEY_LINEAR) {
+               data[0] =          0.0f;
+               data[1] = -t     + 1.0f;
+               data[2] =  t;
+               data[3] =          0.0f;
+       }
+       else if (type == KEY_CARDINAL) {
+               t2 = t * t;
+               t3 = t2 * t;
+               fc = 0.71f;
+
+               data[0] = -fc          * t3  + 2.0f * fc          * t2 - fc * t;
+               data[1] =  (2.0f - fc) * t3  + (fc - 3.0f)        * t2 + 1.0f;
+               data[2] =  (fc - 2.0f) * t3  + (3.0f - 2.0f * fc) * t2 + fc * t;
+               data[3] =  fc          * t3  - fc * t2;
+       }
+       else if (type == KEY_BSPLINE) {
+               t2 = t * t;
+               t3 = t2 * t;
+
+               data[0] = -0.16666666f * t3  + 0.5f * t2   - 0.5f * t    + 0.16666666f;
+               data[1] =  0.5f        * t3  - t2                        + 0.66666666f;
+               data[2] = -0.5f        * t3  + 0.5f * t2   + 0.5f * t    + 0.16666666f;
+               data[3] =  0.16666666f * t3;
        }
 }
 
 /* first derivative */
        }
 }
 
 /* first derivative */
-void key_curve_tangent_weights(float t, float *data, int type)
+void key_curve_tangent_weights(float t, float data[4], int type)
 {
        float t2, fc;
        
 {
        float t2, fc;
        
-       if(type==KEY_LINEAR) {
-               data[0]= 0.0f;
-               data[1]= -1.0f;
-               data[2]= 1.0f;
-               data[3]= 0.0f;
-       }
-       else if(type==KEY_CARDINAL) {
-               t2= t*t;
-               fc= 0.71f;
-               
-               data[0]= -3.0f*fc*t2            +4.0f*fc*t                              - fc;
-               data[1]= 3.0f*(2.0f-fc)*t2      +2.0f*(fc-3.0f)*t;
-               data[2]= 3.0f*(fc-2.0f)*t2      +2.0f*(3.0f-2.0f*fc)*t  + fc;
-               data[3]= 3.0f*fc*t2                     -2.0f*fc*t;
+       if (type == KEY_LINEAR) {
+               data[0] = 0.0f;
+               data[1] = -1.0f;
+               data[2] = 1.0f;
+               data[3] = 0.0f;
        }
        }
-       else if(type==KEY_BSPLINE) {
-               t2= t*t;
+       else if (type == KEY_CARDINAL) {
+               t2 = t * t;
+               fc = 0.71f;
 
 
-               data[0]= -0.5f*t2       + t                     - 0.5f;
-               data[1]= 1.5f*t2        - 2.0f*t;
-               data[2]= -1.5f*t2       + t                     + 0.5f;
-               data[3]= 0.5f*t2;
+               data[0] = -3.0f * fc          * t2  + 4.0f * fc * t                  - fc;
+               data[1] =  3.0f * (2.0f - fc) * t2  + 2.0f * (fc - 3.0f) * t;
+               data[2] =  3.0f * (fc - 2.0f) * t2  + 2.0f * (3.0f - 2.0f * fc) * t  + fc;
+               data[3] =  3.0f * fc          * t2  - 2.0f * fc * t;
+       }
+       else if (type == KEY_BSPLINE) {
+               t2 = t * t;
+
+               data[0] = -0.5f * t2  + t         - 0.5f;
+               data[1] =  1.5f * t2  - t * 2.0f;
+               data[2] = -1.5f * t2  + t         + 0.5f;
+               data[3] =  0.5f * t2;
        }
 }
 
 /* second derivative */
        }
 }
 
 /* second derivative */
-void key_curve_normal_weights(float t, float *data, int type)
+void key_curve_normal_weights(float t, float data[4], int type)
 {
        float fc;
        
 {
        float fc;
        
-       if(type==KEY_LINEAR) {
-               data[0]= 0.0f;
-               data[1]= 0.0f;
-               data[2]= 0.0f;
-               data[3]= 0.0f;
-       }
-       else if(type==KEY_CARDINAL) {
-               fc= 0.71f;
-               
-               data[0]= -6.0f*fc*t                     + 4.0f*fc;
-               data[1]= 6.0f*(2.0f-fc)*t       + 2.0f*(fc-3.0f);
-               data[2]= 6.0f*(fc-2.0f)*t       + 2.0f*(3.0f-2.0f*fc);
-               data[3]= 6.0f*fc*t                      - 2.0f*fc;
-       }
-       else if(type==KEY_BSPLINE) {
-               data[0]= -1.0f*t        + 1.0f;
-               data[1]= 3.0f*t         - 2.0f;
-               data[2]= -3.0f*t        + 1.0f;
-               data[3]= 1.0f*t;
+       if (type == KEY_LINEAR) {
+               data[0] = 0.0f;
+               data[1] = 0.0f;
+               data[2] = 0.0f;
+               data[3] = 0.0f;
+       }
+       else if (type == KEY_CARDINAL) {
+               fc = 0.71f;
+
+               data[0] = -6.0f * fc          * t  + 4.0f * fc;
+               data[1] =  6.0f * (2.0f - fc) * t  + 2.0f * (fc - 3.0f);
+               data[2] =  6.0f * (fc - 2.0f) * t  + 2.0f * (3.0f - 2.0f * fc);
+               data[3] =  6.0f * fc          * t  - 2.0f * fc;
+       }
+       else if (type == KEY_BSPLINE) {
+               data[0] = -1.0f * t  + 1.0f;
+               data[1] =  3.0f * t  - 2.0f;
+               data[2] = -3.0f * t  + 1.0f;
+               data[3] =  1.0f * t;
        }
 }
 
        }
 }
 
-static int setkeys(float fac, ListBase *lb, KeyBlock *k[], float *t, int cycl)
+static int setkeys(float fac, ListBase *lb, KeyBlock *k[], float t[4], int cycl)
 {
        /* return 1 means k[2] is the position, return 0 means interpolate */
        KeyBlock *k1, *firstkey;
 {
        /* return 1 means k[2] is the position, return 0 means interpolate */
        KeyBlock *k1, *firstkey;
-       float d, dpos, ofs=0, lastpos, temp, fval[4];
+       float d, dpos, ofs = 0, lastpos;
        short bsplinetype;
 
        short bsplinetype;
 
-       firstkey= lb->first;
-       k1= lb->last;
-       lastpos= k1->pos;
-       dpos= lastpos - firstkey->pos;
+       firstkey = lb->first;
+       k1 = lb->last;
+       lastpos = k1->pos;
+       dpos = lastpos - firstkey->pos;
 
 
-       if(fac < firstkey->pos) fac= firstkey->pos;
-       else if(fac > k1->pos) fac= k1->pos;
+       if (fac < firstkey->pos) fac = firstkey->pos;
+       else if (fac > k1->pos) fac = k1->pos;
 
 
-       k1=k[0]=k[1]=k[2]=k[3]= firstkey;
-       t[0]=t[1]=t[2]=t[3]= k1->pos;
+       k1 = k[0] = k[1] = k[2] = k[3] = firstkey;
+       t[0] = t[1] = t[2] = t[3] = k1->pos;
 
 
-       /* if(fac<0.0 || fac>1.0) return 1; */
+       /* if (fac < 0.0 || fac > 1.0) return 1; */
 
 
-       if(k1->next==NULL) return 1;
+       if (k1->next == NULL) return 1;
 
 
-       if(cycl) {      /* pre-sort */
-               k[2]= k1->next;
-               k[3]= k[2]->next;
-               if(k[3]==NULL) k[3]=k1;
-               while(k1) {
-                       if(k1->next==NULL) k[0]=k1;
-                       k1=k1->next;
+       if (cycl) { /* pre-sort */
+               k[2] = k1->next;
+               k[3] = k[2]->next;
+               if (k[3] == NULL) k[3] = k1;
+               while (k1) {
+                       if (k1->next == NULL) k[0] = k1;
+                       k1 = k1->next;
                }
                /* k1= k[1]; */ /* UNUSED */
                }
                /* k1= k[1]; */ /* UNUSED */
-               t[0]= k[0]->pos;
-               t[1]+= dpos;
-               t[2]= k[2]->pos + dpos;
-               t[3]= k[3]->pos + dpos;
-               fac+= dpos;
-               ofs= dpos;
-               if(k[3]==k[1]) { 
-                       t[3]+= dpos; 
-                       ofs= 2.0f*dpos;
-               }
-               if(fac<t[1]) fac+= dpos;
-               k1= k[3];
-       }
-       else {          /* pre-sort */
-               k[2]= k1->next;
-               t[2]= k[2]->pos;
-               k[3]= k[2]->next;
-               if(k[3]==NULL) k[3]= k[2];
-               t[3]= k[3]->pos;
-               k1= k[3];
+               t[0] = k[0]->pos;
+               t[1] += dpos;
+               t[2] = k[2]->pos + dpos;
+               t[3] = k[3]->pos + dpos;
+               fac += dpos;
+               ofs = dpos;
+               if (k[3] == k[1]) {
+                       t[3] += dpos;
+                       ofs = 2.0f * dpos;
+               }
+               if (fac < t[1]) fac += dpos;
+               k1 = k[3];
+       }
+       else {  /* pre-sort */
+               k[2] = k1->next;
+               t[2] = k[2]->pos;
+               k[3] = k[2]->next;
+               if (k[3] == NULL) k[3] = k[2];
+               t[3] = k[3]->pos;
+               k1 = k[3];
        }
        
        }
        
-       while( t[2]<fac ) {     /* find correct location */
-               if(k1->next==NULL) {
-                       if(cycl) {
-                               k1= firstkey;
-                               ofs+= dpos;
+       while (t[2] < fac) {    /* find correct location */
+               if (k1->next == NULL) {
+                       if (cycl) {
+                               k1 = firstkey;
+                               ofs += dpos;
                        }
                        }
-                       else if(t[2]==t[3]) break;
+                       else if (t[2] == t[3]) break;
                }
                }
-               else k1= k1->next;
+               else k1 = k1->next;
 
 
-               t[0]= t[1]; 
-               k[0]= k[1];
-               t[1]= t[2]; 
-               k[1]= k[2];
-               t[2]= t[3]; 
-               k[2]= k[3];
-               t[3]= k1->pos+ofs; 
-               k[3]= k1;
+               t[0] = t[1];
+               k[0] = k[1];
+               t[1] = t[2];
+               k[1] = k[2];
+               t[2] = t[3];
+               k[2] = k[3];
+               t[3] = k1->pos + ofs;
+               k[3] = k1;
 
 
-               if(ofs > 2.1f + lastpos) break;
+               if (ofs > 2.1f + lastpos) break;
        }
        
        }
        
-       bsplinetype= 0;
-       if(k[1]->type==KEY_BSPLINE || k[2]->type==KEY_BSPLINE) bsplinetype= 1;
+       bsplinetype = 0;
+       if (k[1]->type == KEY_BSPLINE || k[2]->type == KEY_BSPLINE) bsplinetype = 1;
 
 
 
 
-       if(cycl==0) {
-               if(bsplinetype==0) {    /* B spline doesn't go through the control points */
-                       if(fac<=t[1]) {         /* fac for 1st key */
-                               t[2]= t[1];
-                               k[2]= k[1];
+       if (cycl == 0) {
+               if (bsplinetype == 0) {   /* B spline doesn't go through the control points */
+                       if (fac <= t[1]) {  /* fac for 1st key */
+                               t[2] = t[1];
+                               k[2] = k[1];
                                return 1;
                        }
                                return 1;
                        }
-                       if(fac>=t[2] ) {        /* fac after 2nd key */
+                       if (fac >= t[2]) {  /* fac after 2nd key */
                                return 1;
                        }
                }
                                return 1;
                        }
                }
-               else if(fac>t[2]) {     /* last key */
-                       fac= t[2];
-                       k[3]= k[2];
-                       t[3]= t[2];
+               else if (fac > t[2]) {  /* last key */
+                       fac = t[2];
+                       k[3] = k[2];
+                       t[3] = t[2];
                }
        }
 
                }
        }
 
-       d= t[2]-t[1];
-       if(d == 0.0f) {
-               if(bsplinetype==0) {
-                       return 1;       /* both keys equal */
+       d = t[2] - t[1];
+       if (d == 0.0f) {
+               if (bsplinetype == 0) {
+                       return 1;  /* both keys equal */
                }
        }
                }
        }
-       else d= (fac-t[1])/d;
+       else {
+               d = (fac - t[1]) / d;
+       }
 
        /* interpolation */
 
        /* interpolation */
-       
        key_curve_position_weights(d, t, k[1]->type);
 
        key_curve_position_weights(d, t, k[1]->type);
 
-       if(k[1]->type != k[2]->type) {
-               key_curve_position_weights(d, fval, k[2]->type);
-               
-               temp= 1.0f-d;
-               t[0]= temp*t[0]+ d*fval[0];
-               t[1]= temp*t[1]+ d*fval[1];
-               t[2]= temp*t[2]+ d*fval[2];
-               t[3]= temp*t[3]+ d*fval[3];
+       if (k[1]->type != k[2]->type) {
+               float t_other[4];
+               key_curve_position_weights(d, t_other, k[2]->type);
+               interp_v4_v4v4(t, t, t_other, d);
        }
 
        return 0;
        }
 
        return 0;
@@ -517,8 +483,8 @@ static void flerp(int tot, float *in, float *f0, float *f1, float *f2, float *f3
 {
        int a;
 
 {
        int a;
 
-       for(a=0; a<tot; a++) {
-               in[a]= t[0]*f0[a]+t[1]*f1[a]+t[2]*f2[a]+t[3]*f3[a];
+       for (a = 0; a < tot; a++) {
+               in[a] = t[0] * f0[a] + t[1] * f1[a] + t[2] * f2[a] + t[3] * f3[a];
        }
 }
 
        }
 }
 
@@ -526,41 +492,41 @@ static void rel_flerp(int tot, float *in, float *ref, float *out, float fac)
 {
        int a;
        
 {
        int a;
        
-       for(a=0; a<tot; a++) {
-               in[a]-= fac*(ref[a]-out[a]);
+       for (a = 0; a < tot; a++) {
+               in[a] -= fac * (ref[a] - out[a]);
        }
 }
 
 static char *key_block_get_data(Key *key, KeyBlock *actkb, KeyBlock *kb, char **freedata)
 {
        }
 }
 
 static char *key_block_get_data(Key *key, KeyBlock *actkb, KeyBlock *kb, char **freedata)
 {
-       if(kb == actkb) {
+       if (kb == actkb) {
                /* this hack makes it possible to edit shape keys in
                /* this hack makes it possible to edit shape keys in
-                  edit mode with shape keys blending applied */
-               if(GS(key->from->name) == ID_ME) {
+                * edit mode with shape keys blending applied */
+               if (GS(key->from->name) == ID_ME) {
                        Mesh *me;
                        BMVert *eve;
                        BMIter iter;
                        float (*co)[3];
                        int a;
 
                        Mesh *me;
                        BMVert *eve;
                        BMIter iter;
                        float (*co)[3];
                        int a;
 
-                       me= (Mesh*)key->from;
+                       me = (Mesh *)key->from;
 
 
-                       if(me->edit_btmesh && me->edit_btmesh->bm->totvert == kb->totelem) {
-                               a= 0;
-                               co= MEM_callocN(sizeof(float)*3*me->edit_btmesh->bm->totvert, "key_block_get_data");
+                       if (me->edit_btmesh && me->edit_btmesh->bm->totvert == kb->totelem) {
+                               a = 0;
+                               co = MEM_callocN(sizeof(float) * 3 * me->edit_btmesh->bm->totvert, "key_block_get_data");
 
 
-                               BM_ITER(eve, &iter, me->edit_btmesh->bm, BM_VERTS_OF_MESH, NULL) {
+                               BM_ITER_MESH (eve, &iter, me->edit_btmesh->bm, BM_VERTS_OF_MESH) {
                                        copy_v3_v3(co[a], eve->co);
                                        a++;
                                }
 
                                        copy_v3_v3(co[a], eve->co);
                                        a++;
                                }
 
-                               *freedata= (char*)co;
-                               return (char*)co;
+                               *freedata = (char *)co;
+                               return (char *)co;
                        }
                }
        }
 
                        }
                }
        }
 
-       *freedata= NULL;
+       *freedata = NULL;
        return kb->data;
 }
 
        return kb->data;
 }
 
@@ -568,32 +534,33 @@ static char *key_block_get_data(Key *key, KeyBlock *actkb, KeyBlock *kb, char **
 /* currently only the first value of 'ofs' may be set. */
 static short key_pointer_size(const Key *key, const int mode, int *poinsize, int *ofs)
 {
 /* currently only the first value of 'ofs' may be set. */
 static short key_pointer_size(const Key *key, const int mode, int *poinsize, int *ofs)
 {
-       if(key->from==NULL) {
+       if (key->from == NULL) {
                return FALSE;
        }
 
                return FALSE;
        }
 
-       switch(GS(key->from->name)) {
-       case ID_ME:
-               *ofs= sizeof(float)*3;
-               *poinsize= *ofs;
-               break;
-       case ID_LT:
-               *ofs= sizeof(float)*3;
-               *poinsize= *ofs;
-               break;
-       case ID_CU:
-               if(mode == KEY_MODE_BPOINT) {
-                       *ofs= sizeof(float)*4;
-                       *poinsize= *ofs;
-               } else {
-                       ofs[0]= sizeof(float)*12;
-                       *poinsize= (*ofs) / 3;
-               }
-
-               break;
-       default:
-               BLI_assert(!"invalid 'key->from' ID type");
-               return FALSE;
+       switch (GS(key->from->name)) {
+               case ID_ME:
+                       *ofs = sizeof(float) * 3;
+                       *poinsize = *ofs;
+                       break;
+               case ID_LT:
+                       *ofs = sizeof(float) * 3;
+                       *poinsize = *ofs;
+                       break;
+               case ID_CU:
+                       if (mode == KEY_MODE_BPOINT) {
+                               *ofs = sizeof(float) * 4;
+                               *poinsize = *ofs;
+                       }
+                       else {
+                               ofs[0] = sizeof(float) * 12;
+                               *poinsize = (*ofs) / 3;
+                       }
+
+                       break;
+               default:
+                       BLI_assert(!"invalid 'key->from' ID type");
+                       return FALSE;
        }
 
        return TRUE;
        }
 
        return TRUE;
@@ -602,112 +569,117 @@ static short key_pointer_size(const Key *key, const int mode, int *poinsize, int
 static void cp_key(const int start, int end, const int tot, char *poin, Key *key, KeyBlock *actkb, KeyBlock *kb, float *weights, const int mode)
 {
        float ktot = 0.0, kd = 0.0;
 static void cp_key(const int start, int end, const int tot, char *poin, Key *key, KeyBlock *actkb, KeyBlock *kb, float *weights, const int mode)
 {
        float ktot = 0.0, kd = 0.0;
-       int elemsize, poinsize = 0, a, *ofsp, ofs[32], flagflo=0;
+       int elemsize, poinsize = 0, a, *ofsp, ofs[32], flagflo = 0;
        char *k1, *kref, *freek1, *freekref;
        char *cp, elemstr[8];
 
        /* currently always 0, in future key_pointer_size may assign */
        char *k1, *kref, *freek1, *freekref;
        char *cp, elemstr[8];
 
        /* currently always 0, in future key_pointer_size may assign */
-       ofs[1]= 0;
+       ofs[1] = 0;
 
 
-       if(!key_pointer_size(key, mode, &poinsize, &ofs[0]))
+       if (!key_pointer_size(key, mode, &poinsize, &ofs[0]))
                return;
 
                return;
 
-       if(end>tot) end= tot;
+       if (end > tot) end = tot;
        
        
-       if(tot != kb->totelem) {
-               ktot= 0.0;
-               flagflo= 1;
-               if(kb->totelem) {
-                       kd= kb->totelem/(float)tot;
+       if (tot != kb->totelem) {
+               ktot = 0.0;
+               flagflo = 1;
+               if (kb->totelem) {
+                       kd = kb->totelem / (float)tot;
+               }
+               else {
+                       return;
                }
                }
-               else return;
        }
 
        }
 
-       k1= key_block_get_data(key, actkb, kb, &freek1);
-       kref= key_block_get_data(key, actkb, key->refkey, &freekref);
+       k1 = key_block_get_data(key, actkb, kb, &freek1);
+       kref = key_block_get_data(key, actkb, key->refkey, &freekref);
 
        /* this exception is needed for slurphing */
 
        /* this exception is needed for slurphing */
-       if(start!=0) {
+       if (start != 0) {
                
                
-               poin+= poinsize*start;
+               poin += poinsize * start;
                
                
-               if(flagflo) {
-                       ktot+= start*kd;
-                       a= (int)floor(ktot);
-                       if(a) {
-                               ktot-= a;
-                               k1+= a*key->elemsize;
+               if (flagflo) {
+                       ktot += start * kd;
+                       a = (int)floor(ktot);
+                       if (a) {
+                               ktot -= a;
+                               k1 += a * key->elemsize;
                        }
                }
                        }
                }
-               else k1+= start*key->elemsize;
-       }       
+               else k1 += start * key->elemsize;
+       }
        
        
-       if(mode == KEY_MODE_BEZTRIPLE) {
-               elemstr[0]= 1;
-               elemstr[1]= IPO_BEZTRIPLE;
-               elemstr[2]= 0;
+       if (mode == KEY_MODE_BEZTRIPLE) {
+               elemstr[0] = 1;
+               elemstr[1] = IPO_BEZTRIPLE;
+               elemstr[2] = 0;
        }
        
        /* just do it here, not above! */
        }
        
        /* just do it here, not above! */
-       elemsize= key->elemsize;
-       if(mode == KEY_MODE_BEZTRIPLE) elemsize*= 3;
+       elemsize = key->elemsize;
+       if (mode == KEY_MODE_BEZTRIPLE) elemsize *= 3;
 
 
-       for(a=start; a<end; a++) {
-               cp= key->elemstr;
-               if(mode == KEY_MODE_BEZTRIPLE) cp= elemstr;
+       for (a = start; a < end; a++) {
+               cp = key->elemstr;
+               if (mode == KEY_MODE_BEZTRIPLE) cp = elemstr;
 
 
-               ofsp= ofs;
-               
-               while( cp[0] ) {
-                       
-                       switch(cp[1]) {
-                       case IPO_FLOAT:
-                               if(weights) {
-                                       memcpy(poin, kref, sizeof(float)*3);
-                                       if(*weights!=0.0f)
-                                               rel_flerp(cp[0], (float *)poin, (float *)kref, (float *)k1, *weights);
-                                       weights++;
-                               }
-                               else 
-                                       memcpy(poin, k1, sizeof(float)*3);
-                               break;
-                       case IPO_BPOINT:
-                               memcpy(poin, k1, sizeof(float)*4);
-                               break;
-                       case IPO_BEZTRIPLE:
-                               memcpy(poin, k1, sizeof(float)*12);
-                               break;
-                       default:
-                               /* should never happen */
-                               if(freek1) MEM_freeN(freek1);
-                               if(freekref) MEM_freeN(freekref);
-                               BLI_assert(!"invalid 'cp[1]'");
-                               return;
+               ofsp = ofs;
+
+               while (cp[0]) {
+
+                       switch (cp[1]) {
+                               case IPO_FLOAT:
+                                       if (weights) {
+                                               memcpy(poin, kref, sizeof(float) * 3);
+                                               if (*weights != 0.0f)
+                                                       rel_flerp(cp[0], (float *)poin, (float *)kref, (float *)k1, *weights);
+                                               weights++;
+                                       }
+                                       else {
+                                               memcpy(poin, k1, sizeof(float) * 3);
+                                       }
+                                       break;
+                               case IPO_BPOINT:
+                                       memcpy(poin, k1, sizeof(float) * 4);
+                                       break;
+                               case IPO_BEZTRIPLE:
+                                       memcpy(poin, k1, sizeof(float) * 12);
+                                       break;
+                               default:
+                                       /* should never happen */
+                                       if (freek1) MEM_freeN(freek1);
+                                       if (freekref) MEM_freeN(freekref);
+                                       BLI_assert(!"invalid 'cp[1]'");
+                                       return;
                        }
 
                        }
 
-                       poin+= ofsp[0]; 
-                       cp+= 2; ofsp++;
+                       poin += *ofsp;
+                       cp += 2; ofsp++;
                }
                
                /* are we going to be nasty? */
                }
                
                /* are we going to be nasty? */
-               if(flagflo) {
-                       ktot+= kd;
-                       while(ktot >= 1.0f) {
+               if (flagflo) {
+                       ktot += kd;
+                       while (ktot >= 1.0f) {
                                ktot -= 1.0f;
                                ktot -= 1.0f;
-                               k1+= elemsize;
-                               kref+= elemsize;
+                               k1 += elemsize;
+                               kref += elemsize;
                        }
                }
                else {
                        }
                }
                else {
-                       k1+= elemsize;
-                       kref+= elemsize;
+                       k1 += elemsize;
+                       kref += elemsize;
                }
                
                }
                
-               if(mode == KEY_MODE_BEZTRIPLE) a+=2;
+               if (mode == KEY_MODE_BEZTRIPLE) {
+                       a += 2;
+               }
        }
 
        }
 
-       if(freek1) MEM_freeN(freek1);
-       if(freekref) MEM_freeN(freekref);
+       if (freek1) MEM_freeN(freek1);
+       if (freekref) MEM_freeN(freekref);
 }
 
 static void cp_cu_key(Curve *cu, Key *key, KeyBlock *actkb, KeyBlock *kb, const int start, int end, char *out, const int tot)
 }
 
 static void cp_cu_key(Curve *cu, Key *key, KeyBlock *actkb, KeyBlock *kb, const int start, int end, char *out, const int tot)
@@ -715,127 +687,125 @@ static void cp_cu_key(Curve *cu, Key *key, KeyBlock *actkb, KeyBlock *kb, const
        Nurb *nu;
        int a, step, a1, a2;
 
        Nurb *nu;
        int a, step, a1, a2;
 
-       for(a=0, nu=cu->nurb.first; nu; nu=nu->next, a+=step) {
-               if(nu->bp) {
-                       step= nu->pntsu*nu->pntsv;
+       for (a = 0, nu = cu->nurb.first; nu; nu = nu->next, a += step) {
+               if (nu->bp) {
+                       step = nu->pntsu * nu->pntsv;
 
 
-                       a1= MAX2(a, start);
-                       a2= MIN2(a+step, end);
+                       a1 = max_ii(a, start);
+                       a2 = min_ii(a + step, end);
 
 
-                       if(a1<a2) cp_key(a1, a2, tot, out, key, actkb, kb, NULL, KEY_MODE_BPOINT);
+                       if (a1 < a2) cp_key(a1, a2, tot, out, key, actkb, kb, NULL, KEY_MODE_BPOINT);
                }
                }
-               else if(nu->bezt) {
-                       step= 3*nu->pntsu;
+               else if (nu->bezt) {
+                       step = 3 * nu->pntsu;
 
                        /* exception because keys prefer to work with complete blocks */
 
                        /* exception because keys prefer to work with complete blocks */
-                       a1= MAX2(a, start);
-                       a2= MIN2(a+step, end);
+                       a1 = max_ii(a, start);
+                       a2 = min_ii(a + step, end);
 
 
-                       if(a1<a2) cp_key(a1, a2, tot, out, key, actkb, kb, NULL, KEY_MODE_BEZTRIPLE);
+                       if (a1 < a2) cp_key(a1, a2, tot, out, key, actkb, kb, NULL, KEY_MODE_BEZTRIPLE);
+               }
+               else {
+                       step = 0;
                }
                }
-               else
-                       step= 0;
        }
 }
 
        }
 }
 
-void do_rel_key(const int start, int end, const int tot, char *basispoin, Key *key, KeyBlock *actkb, const int mode)
+void BKE_key_evaluate_relative(const int start, int end, const int tot, char *basispoin, Key *key, KeyBlock *actkb, const int mode)
 {
        KeyBlock *kb;
        int *ofsp, ofs[3], elemsize, b;
        char *cp, *poin, *reffrom, *from, elemstr[8];
 {
        KeyBlock *kb;
        int *ofsp, ofs[3], elemsize, b;
        char *cp, *poin, *reffrom, *from, elemstr[8];
-       char *freefrom, *freereffrom;
        int poinsize;
 
        /* currently always 0, in future key_pointer_size may assign */
        int poinsize;
 
        /* currently always 0, in future key_pointer_size may assign */
-       ofs[1]= 0;
+       ofs[1] = 0;
 
 
-       if(!key_pointer_size(key, mode, &poinsize, &ofs[0]))
+       if (!key_pointer_size(key, mode, &poinsize, &ofs[0]))
                return;
 
                return;
 
-       if(end>tot) end= tot;
+       if (end > tot) end = tot;
 
        /* in case of beztriple */
 
        /* in case of beztriple */
-       elemstr[0]= 1;                          /* nr of ipofloats */
-       elemstr[1]= IPO_BEZTRIPLE;
-       elemstr[2]= 0;
+       elemstr[0] = 1;              /* nr of ipofloats */
+       elemstr[1] = IPO_BEZTRIPLE;
+       elemstr[2] = 0;
 
        /* just here, not above! */
 
        /* just here, not above! */
-       elemsize= key->elemsize;
-       if(mode == KEY_MODE_BEZTRIPLE) elemsize*= 3;
+       elemsize = key->elemsize;
+       if (mode == KEY_MODE_BEZTRIPLE) elemsize *= 3;
 
        /* step 1 init */
        cp_key(start, end, tot, basispoin, key, actkb, key->refkey, NULL, mode);
        
        /* step 2: do it */
        
 
        /* step 1 init */
        cp_key(start, end, tot, basispoin, key, actkb, key->refkey, NULL, mode);
        
        /* step 2: do it */
        
-       for(kb=key->block.first; kb; kb=kb->next) {
-               if(kb!=key->refkey) {
-                       float icuval= kb->curval;
+       for (kb = key->block.first; kb; kb = kb->next) {
+               if (kb != key->refkey) {
+                       float icuval = kb->curval;
                        
                        /* only with value, and no difference allowed */
                        
                        /* only with value, and no difference allowed */
-                       if(!(kb->flag & KEYBLOCK_MUTE) && icuval!=0.0f && kb->totelem==tot) {
+                       if (!(kb->flag & KEYBLOCK_MUTE) && icuval != 0.0f && kb->totelem == tot) {
                                KeyBlock *refb;
                                KeyBlock *refb;
-                               float weight, *weights= kb->weights;
+                               float weight, *weights = kb->weights;
+                               char *freefrom = NULL, *freereffrom = NULL;
 
                                /* reference now can be any block */
 
                                /* reference now can be any block */
-                               refb= BLI_findlink(&key->block, kb->relative);
-                               if(refb==NULL) continue;
+                               refb = BLI_findlink(&key->block, kb->relative);
+                               if (refb == NULL) continue;
                                
                                
-                               poin= basispoin;
-                               from= key_block_get_data(key, actkb, kb, &freefrom);
-                               reffrom= key_block_get_data(key, actkb, refb, &freereffrom);
-                               
-                               poin+= start*poinsize;
-                               reffrom+= key->elemsize*start;  // key elemsize yes!
-                               from+= key->elemsize*start;
+                               poin = basispoin;
+                               from = key_block_get_data(key, actkb, kb, &freefrom);
+                               reffrom = key_block_get_data(key, actkb, refb, &freereffrom);
+
+                               poin += start * poinsize;
+                               reffrom += key->elemsize * start;  // key elemsize yes!
+                               from += key->elemsize * start;
                                
                                
-                               for(b=start; b<end; b++) {
+                               for (b = start; b < end; b++) {
                                
                                
-                                       if(weights) 
-                                               weight= *weights * icuval;
-                                       else
-                                               weight= icuval;
+                                       weight = weights ? (*weights * icuval) : icuval;
                                        
                                        
-                                       cp= key->elemstr;       
-                                       if(mode == KEY_MODE_BEZTRIPLE) cp= elemstr;
+                                       cp = key->elemstr;
+                                       if (mode == KEY_MODE_BEZTRIPLE) cp = elemstr;
                                        
                                        
-                                       ofsp= ofs;
+                                       ofsp = ofs;
                                        
                                        
-                                       while( cp[0] ) {        /* cp[0]==amount */
+                                       while (cp[0]) {  /* (cp[0] == amount) */
                                                
                                                
-                                               switch(cp[1]) {
-                                               case IPO_FLOAT:
-                                                       rel_flerp(3, (float *)poin, (float *)reffrom, (float *)from, weight);
-                                                       break;
-                                               case IPO_BPOINT:
-                                                       rel_flerp(4, (float *)poin, (float *)reffrom, (float *)from, weight);
-                                                       break;
-                                               case IPO_BEZTRIPLE:
-                                                       rel_flerp(12, (float *)poin, (float *)reffrom, (float *)from, weight);
-                                                       break;
-                                               default:
-                                                       /* should never happen */
-                                                       if(freefrom) MEM_freeN(freefrom);
-                                                       if(freereffrom) MEM_freeN(freereffrom);
-                                                       BLI_assert(!"invalid 'cp[1]'");
-                                                       return;
+                                               switch (cp[1]) {
+                                                       case IPO_FLOAT:
+                                                               rel_flerp(3, (float *)poin, (float *)reffrom, (float *)from, weight);
+                                                               break;
+                                                       case IPO_BPOINT:
+                                                               rel_flerp(4, (float *)poin, (float *)reffrom, (float *)from, weight);
+                                                               break;
+                                                       case IPO_BEZTRIPLE:
+                                                               rel_flerp(12, (float *)poin, (float *)reffrom, (float *)from, weight);
+                                                               break;
+                                                       default:
+                                                               /* should never happen */
+                                                               if (freefrom) MEM_freeN(freefrom);
+                                                               if (freereffrom) MEM_freeN(freereffrom);
+                                                               BLI_assert(!"invalid 'cp[1]'");
+                                                               return;
                                                }
 
                                                }
 
-                                               poin+= ofsp[0];                         
+                                               poin += *ofsp;
                                                
                                                
-                                               cp+= 2;
+                                               cp += 2;
                                                ofsp++;
                                        }
                                        
                                                ofsp++;
                                        }
                                        
-                                       reffrom+= elemsize;
-                                       from+= elemsize;
+                                       reffrom += elemsize;
+                                       from += elemsize;
                                        
                                        
-                                       if(mode == KEY_MODE_BEZTRIPLE) b+= 2;
-                                       if(weights) weights++;
+                                       if (mode == KEY_MODE_BEZTRIPLE) b += 2;
+                                       if (weights) weights++;
                                }
 
                                }
 
-                               if(freefrom) MEM_freeN(freefrom);
-                               if(freereffrom) MEM_freeN(freereffrom);
+                               if (freefrom) MEM_freeN(freefrom);
+                               if (freereffrom) MEM_freeN(freereffrom);
                        }
                }
        }
                        }
                }
        }
@@ -847,251 +817,250 @@ static void do_key(const int start, int end, const int tot, char *poin, Key *key
        float k1tot = 0.0, k2tot = 0.0, k3tot = 0.0, k4tot = 0.0;
        float k1d = 0.0, k2d = 0.0, k3d = 0.0, k4d = 0.0;
        int a, ofs[32], *ofsp;
        float k1tot = 0.0, k2tot = 0.0, k3tot = 0.0, k4tot = 0.0;
        float k1d = 0.0, k2d = 0.0, k3d = 0.0, k4d = 0.0;
        int a, ofs[32], *ofsp;
-       int flagdo= 15, flagflo=0, elemsize, poinsize=0;
+       int flagdo = 15, flagflo = 0, elemsize, poinsize = 0;
        char *k1, *k2, *k3, *k4, *freek1, *freek2, *freek3, *freek4;
        char *cp, elemstr[8];
 
        /* currently always 0, in future key_pointer_size may assign */
        char *k1, *k2, *k3, *k4, *freek1, *freek2, *freek3, *freek4;
        char *cp, elemstr[8];
 
        /* currently always 0, in future key_pointer_size may assign */
-       ofs[1]= 0;
+       ofs[1] = 0;
 
 
-       if(!key_pointer_size(key, mode, &poinsize, &ofs[0]))
+       if (!key_pointer_size(key, mode, &poinsize, &ofs[0]))
                return;
        
                return;
        
-       if(end>tot) end= tot;
+       if (end > tot) end = tot;
 
 
-       k1= key_block_get_data(key, actkb, k[0], &freek1);
-       k2= key_block_get_data(key, actkb, k[1], &freek2);
-       k3= key_block_get_data(key, actkb, k[2], &freek3);
-       k4= key_block_get_data(key, actkb, k[3], &freek4);
+       k1 = key_block_get_data(key, actkb, k[0], &freek1);
+       k2 = key_block_get_data(key, actkb, k[1], &freek2);
+       k3 = key_block_get_data(key, actkb, k[2], &freek3);
+       k4 = key_block_get_data(key, actkb, k[3], &freek4);
 
        /*  test for more or less points (per key!) */
 
        /*  test for more or less points (per key!) */
-       if(tot != k[0]->totelem) {
-               k1tot= 0.0;
+       if (tot != k[0]->totelem) {
+               k1tot = 0.0;
                flagflo |= 1;
                flagflo |= 1;
-               if(k[0]->totelem) {
-                       k1d= k[0]->totelem/(float)tot;
+               if (k[0]->totelem) {
+                       k1d = k[0]->totelem / (float)tot;
                }
                else flagdo -= 1;
        }
                }
                else flagdo -= 1;
        }
-       if(tot != k[1]->totelem) {
-               k2tot= 0.0;
+       if (tot != k[1]->totelem) {
+               k2tot = 0.0;
                flagflo |= 2;
                flagflo |= 2;
-               if(k[0]->totelem) {
-                       k2d= k[1]->totelem/(float)tot;
+               if (k[0]->totelem) {
+                       k2d = k[1]->totelem / (float)tot;
                }
                else flagdo -= 2;
        }
                }
                else flagdo -= 2;
        }
-       if(tot != k[2]->totelem) {
-               k3tot= 0.0;
+       if (tot != k[2]->totelem) {
+               k3tot = 0.0;
                flagflo |= 4;
                flagflo |= 4;
-               if(k[0]->totelem) {
-                       k3d= k[2]->totelem/(float)tot;
+               if (k[0]->totelem) {
+                       k3d = k[2]->totelem / (float)tot;
                }
                else flagdo -= 4;
        }
                }
                else flagdo -= 4;
        }
-       if(tot != k[3]->totelem) {
-               k4tot= 0.0;
+       if (tot != k[3]->totelem) {
+               k4tot = 0.0;
                flagflo |= 8;
                flagflo |= 8;
-               if(k[0]->totelem) {
-                       k4d= k[3]->totelem/(float)tot;
+               if (k[0]->totelem) {
+                       k4d = k[3]->totelem / (float)tot;
                }
                else flagdo -= 8;
        }
 
                }
                else flagdo -= 8;
        }
 
-               /* this exception needed for slurphing */
-       if(start!=0) {
+       /* this exception needed for slurphing */
+       if (start != 0) {
 
 
-               poin+= poinsize*start;
+               poin += poinsize * start;
                
                
-               if(flagdo & 1) {
-                       if(flagflo & 1) {
-                               k1tot+= start*k1d;
-                               a= (int)floor(k1tot);
-                               if(a) {
-                                       k1tot-= a;
-                                       k1+= a*key->elemsize;
+               if (flagdo & 1) {
+                       if (flagflo & 1) {
+                               k1tot += start * k1d;
+                               a = (int)floor(k1tot);
+                               if (a) {
+                                       k1tot -= a;
+                                       k1 += a * key->elemsize;
                                }
                        }
                                }
                        }
-                       else k1+= start*key->elemsize;
-               }
-               if(flagdo & 2) {
-                       if(flagflo & 2) {
-                               k2tot+= start*k2d;
-                               a= (int)floor(k2tot);
-                               if(a) {
-                                       k2tot-= a;
-                                       k2+= a*key->elemsize;
+                       else k1 += start * key->elemsize;
+               }
+               if (flagdo & 2) {
+                       if (flagflo & 2) {
+                               k2tot += start * k2d;
+                               a = (int)floor(k2tot);
+                               if (a) {
+                                       k2tot -= a;
+                                       k2 += a * key->elemsize;
                                }
                        }
                                }
                        }
-                       else k2+= start*key->elemsize;
-               }
-               if(flagdo & 4) {
-                       if(flagflo & 4) {
-                               k3tot+= start*k3d;
-                               a= (int)floor(k3tot);
-                               if(a) {
-                                       k3tot-= a;
-                                       k3+= a*key->elemsize;
+                       else k2 += start * key->elemsize;
+               }
+               if (flagdo & 4) {
+                       if (flagflo & 4) {
+                               k3tot += start * k3d;
+                               a = (int)floor(k3tot);
+                               if (a) {
+                                       k3tot -= a;
+                                       k3 += a * key->elemsize;
                                }
                        }
                                }
                        }
-                       else k3+= start*key->elemsize;
-               }
-               if(flagdo & 8) {
-                       if(flagflo & 8) {
-                               k4tot+= start*k4d;
-                               a= (int)floor(k4tot);
-                               if(a) {
-                                       k4tot-= a;
-                                       k4+= a*key->elemsize;
+                       else k3 += start * key->elemsize;
+               }
+               if (flagdo & 8) {
+                       if (flagflo & 8) {
+                               k4tot += start * k4d;
+                               a = (int)floor(k4tot);
+                               if (a) {
+                                       k4tot -= a;
+                                       k4 += a * key->elemsize;
                                }
                        }
                                }
                        }
-                       else k4+= start*key->elemsize;
+                       else k4 += start * key->elemsize;
                }
 
        }
 
        /* in case of beztriple */
                }
 
        }
 
        /* in case of beztriple */
-       elemstr[0]= 1;                          /* nr of ipofloats */
-       elemstr[1]= IPO_BEZTRIPLE;
-       elemstr[2]= 0;
+       elemstr[0] = 1;              /* nr of ipofloats */
+       elemstr[1] = IPO_BEZTRIPLE;
+       elemstr[2] = 0;
 
        /* only here, not above! */
 
        /* only here, not above! */
-       elemsize= key->elemsize;
-       if(mode == KEY_MODE_BEZTRIPLE) elemsize*= 3;
+       elemsize = key->elemsize;
+       if (mode == KEY_MODE_BEZTRIPLE) elemsize *= 3;
 
 
-       for(a=start; a<end; a++) {
+       for (a = start; a < end; a++) {
        
        
-               cp= key->elemstr;       
-               if(mode == KEY_MODE_BEZTRIPLE) cp= elemstr;
+               cp = key->elemstr;
+               if (mode == KEY_MODE_BEZTRIPLE) cp = elemstr;
                
                
-               ofsp= ofs;
-               
-               while( cp[0] ) {        /* cp[0]==amount */
-                       
-                       switch(cp[1]) {
-                       case IPO_FLOAT:
-                               flerp(3, (float *)poin, (float *)k1, (float *)k2, (float *)k3, (float *)k4, t);
-                               break;
-                       case IPO_BPOINT:
-                               flerp(4, (float *)poin, (float *)k1, (float *)k2, (float *)k3, (float *)k4, t);
-                               break;
-                       case IPO_BEZTRIPLE:
-                               flerp(12, (void *)poin, (void *)k1, (void *)k2, (void *)k3, (void *)k4, t);
-                               break;
-                       default:
-                               /* should never happen */
-                               if(freek1) MEM_freeN(freek1);
-                               if(freek2) MEM_freeN(freek2);
-                               if(freek3) MEM_freeN(freek3);
-                               if(freek4) MEM_freeN(freek4);
-                               BLI_assert(!"invalid 'cp[1]'");
-                               return;
+               ofsp = ofs;
+
+               while (cp[0]) {  /* (cp[0] == amount) */
+
+                       switch (cp[1]) {
+                               case IPO_FLOAT:
+                                       flerp(3, (float *)poin, (float *)k1, (float *)k2, (float *)k3, (float *)k4, t);
+                                       break;
+                               case IPO_BPOINT:
+                                       flerp(4, (float *)poin, (float *)k1, (float *)k2, (float *)k3, (float *)k4, t);
+                                       break;
+                               case IPO_BEZTRIPLE:
+                                       flerp(12, (void *)poin, (void *)k1, (void *)k2, (void *)k3, (void *)k4, t);
+                                       break;
+                               default:
+                                       /* should never happen */
+                                       if (freek1) MEM_freeN(freek1);
+                                       if (freek2) MEM_freeN(freek2);
+                                       if (freek3) MEM_freeN(freek3);
+                                       if (freek4) MEM_freeN(freek4);
+                                       BLI_assert(!"invalid 'cp[1]'");
+                                       return;
                        }
                        
                        }
                        
-                       poin+= ofsp[0];                         
-                       cp+= 2;
+                       poin += *ofsp;
+                       cp += 2;
                        ofsp++;
                }
                /* lets do it the difficult way: when keys have a different size */
                        ofsp++;
                }
                /* lets do it the difficult way: when keys have a different size */
-               if(flagdo & 1) {
-                       if(flagflo & 1) {
-                               k1tot+= k1d;
-                               while(k1tot >= 1.0f) {
+               if (flagdo & 1) {
+                       if (flagflo & 1) {
+                               k1tot += k1d;
+                               while (k1tot >= 1.0f) {
                                        k1tot -= 1.0f;
                                        k1tot -= 1.0f;
-                                       k1+= elemsize;
+                                       k1 += elemsize;
                                }
                        }
                                }
                        }
-                       else k1+= elemsize;
+                       else k1 += elemsize;
                }
                }
-               if(flagdo & 2) {
-                       if(flagflo & 2) {
-                               k2tot+= k2d;
-                               while(k2tot >= 1.0f) {
+               if (flagdo & 2) {
+                       if (flagflo & 2) {
+                               k2tot += k2d;
+                               while (k2tot >= 1.0f) {
                                        k2tot -= 1.0f;
                                        k2tot -= 1.0f;
-                                       k2+= elemsize;
+                                       k2 += elemsize;
                                }
                        }
                                }
                        }
-                       else k2+= elemsize;
+                       else k2 += elemsize;
                }
                }
-               if(flagdo & 4) {
-                       if(flagflo & 4) {
-                               k3tot+= k3d;
-                               while(k3tot >= 1.0f) {
+               if (flagdo & 4) {
+                       if (flagflo & 4) {
+                               k3tot += k3d;
+                               while (k3tot >= 1.0f) {
                                        k3tot -= 1.0f;
                                        k3tot -= 1.0f;
-                                       k3+= elemsize;
+                                       k3 += elemsize;
                                }
                        }
                                }
                        }
-                       else k3+= elemsize;
+                       else k3 += elemsize;
                }
                }
-               if(flagdo & 8) {
-                       if(flagflo & 8) {
-                               k4tot+= k4d;
-                               while(k4tot >= 1.0f) {
+               if (flagdo & 8) {
+                       if (flagflo & 8) {
+                               k4tot += k4d;
+                               while (k4tot >= 1.0f) {
                                        k4tot -= 1.0f;
                                        k4tot -= 1.0f;
-                                       k4+= elemsize;
+                                       k4 += elemsize;
                                }
                        }
                                }
                        }
-                       else k4+= elemsize;
+                       else k4 += elemsize;
                }
                
                }
                
-               if(mode == KEY_MODE_BEZTRIPLE) a+= 2;
+               if (mode == KEY_MODE_BEZTRIPLE) a += 2;
        }
 
        }
 
-       if(freek1) MEM_freeN(freek1);
-       if(freek2) MEM_freeN(freek2);
-       if(freek3) MEM_freeN(freek3);
-       if(freek4) MEM_freeN(freek4);
+       if (freek1) MEM_freeN(freek1);
+       if (freek2) MEM_freeN(freek2);
+       if (freek3) MEM_freeN(freek3);
+       if (freek4) MEM_freeN(freek4);
 }
 
 static float *get_weights_array(Object *ob, char *vgroup)
 {
 }
 
 static float *get_weights_array(Object *ob, char *vgroup)
 {
-       MDeformVert *dvert= NULL;
-       BMEditMesh *em= NULL;
+       MDeformVert *dvert = NULL;
+       BMEditMesh *em = NULL;
        BMIter iter;
        BMVert *eve;
        BMIter iter;
        BMVert *eve;
-       int totvert= 0, defgrp_index= 0;
+       int totvert = 0, defgrp_index = 0;
        
        /* no vgroup string set? */
        
        /* no vgroup string set? */
-       if(vgroup[0]==0) return NULL;
+       if (vgroup[0] == 0) return NULL;
        
        /* gather dvert and totvert */
        
        /* gather dvert and totvert */
-       if(ob->type==OB_MESH) {
-               Mesh *me= ob->data;
-               dvert= me->dvert;
-               totvert= me->totvert;
+       if (ob->type == OB_MESH) {
+               Mesh *me = ob->data;
+               dvert = me->dvert;
+               totvert = me->totvert;
 
 
-               if(me->edit_btmesh && me->edit_btmesh->bm->totvert == totvert)
-                       em= me->edit_btmesh;
+               if (me->edit_btmesh && me->edit_btmesh->bm->totvert == totvert)
+                       em = me->edit_btmesh;
        }
        }
-       else if(ob->type==OB_LATTICE) {
-               Lattice *lt= ob->data;
-               dvert= lt->dvert;
-               totvert= lt->pntsu*lt->pntsv*lt->pntsw;
+       else if (ob->type == OB_LATTICE) {
+               Lattice *lt = ob->data;
+               dvert = lt->dvert;
+               totvert = lt->pntsu * lt->pntsv * lt->pntsw;
        }
        
        }
        
-       if(dvert==NULL) return NULL;
+       if (dvert == NULL) return NULL;
        
        /* find the group (weak loop-in-loop) */
        
        /* find the group (weak loop-in-loop) */
-       defgrp_index= defgroup_name_index(ob, vgroup);
-       if(defgrp_index >= 0) {
+       defgrp_index = defgroup_name_index(ob, vgroup);
+       if (defgrp_index != -1) {
                float *weights;
                int i;
                
                float *weights;
                int i;
                
-               weights= MEM_callocN(totvert*sizeof(float), "weights");
+               weights = MEM_callocN(totvert * sizeof(float), "weights");
 
 
-               if(em) {
-                       eve = BMIter_New(&iter, em->bm, BM_VERTS_OF_MESH, NULL);
-                       for (i=0; eve; eve=BMIter_Step(&iter), i++) {
-                               dvert= CustomData_bmesh_get(&em->bm->vdata, eve->head.data, CD_MDEFORMVERT);
+               if (em) {
+                       BM_ITER_MESH_INDEX (eve, &iter, em->bm, BM_VERTS_OF_MESH, i) {
+                               dvert = CustomData_bmesh_get(&em->bm->vdata, eve->head.data, CD_MDEFORMVERT);
 
 
-                               if(dvert) {
-                                       weights[i]= defvert_find_weight(dvert, defgrp_index);
+                               if (dvert) {
+                                       weights[i] = defvert_find_weight(dvert, defgrp_index);
                                }
                        }
                }
                else {
                                }
                        }
                }
                else {
-                       for(i=0; i < totvert; i++, dvert++) {
-                               weights[i]= defvert_find_weight(dvert, defgrp_index);
+                       for (i = 0; i < totvert; i++, dvert++) {
+                               weights[i] = defvert_find_weight(dvert, defgrp_index);
                        }
                }
 
                        }
                }
 
@@ -1102,74 +1071,54 @@ static float *get_weights_array(Object *ob, char *vgroup)
 
 static void do_mesh_key(Scene *scene, Object *ob, Key *key, char *out, const int tot)
 {
 
 static void do_mesh_key(Scene *scene, Object *ob, Key *key, char *out, const int tot)
 {
-       KeyBlock *k[4], *actkb= ob_get_keyblock(ob);
-       float cfra, ctime, t[4], delta;
-       int a, flag = 0, step;
-       
-       if(key->slurph && key->type!=KEY_RELATIVE ) {
-               delta= key->slurph;
-               delta/= tot;
-               
-               step= 1;
-               if(tot>100 && slurph_opt) {
-                       step= tot/50;
-                       delta*= step;
+       KeyBlock *k[4], *actkb = BKE_keyblock_from_object(ob);
+       float t[4];
+       int flag = 0;
+
+       if (key->slurph && key->type != KEY_RELATIVE) {
+               const float ctime_scaled = key->ctime / 100.0f;
+               float delta = (float)key->slurph / tot;
+               float cfra = (float)scene->r.cfra;
+               int step, a;
+
+               if (tot > 100 && slurph_opt) {
+                       step = tot / 50;
+                       delta *= step;
                        /* in do_key and cp_key the case a>tot is handled */
                }
                        /* in do_key and cp_key the case a>tot is handled */
                }
-               
-               cfra= (float)scene->r.cfra;
-               
-               for(a=0; a<tot; a+=step, cfra+= delta) {
-                       
-                       ctime= BKE_curframe(scene);
-#if 0 // XXX old animation system
-                       if(calc_ipo_spec(key->ipo, KEY_SPEED, &ctime)==0) {
-                               ctime /= 100.0;
-                               CLAMP(ctime, 0.0, 1.0);
-                       }
-#endif // XXX old animation system
-                       // XXX for now... since speed curve cannot be directly ported yet
-                       ctime /= 100.0f;
-                       CLAMP(ctime, 0.0f, 1.0f); // XXX for compat, we use this, but this clamping was confusing
-               
-                       flag= setkeys(ctime, &key->block, k, t, 0);
+               else {
+                       step = 1;
+               }
 
 
-                       if(flag==0)
-                               do_key(a, a+step, tot, (char *)out, key, actkb, k, t, KEY_MODE_DUMMY);
+               for (a = 0; a < tot; a += step, cfra += delta) {
+                       flag = setkeys(ctime_scaled, &key->block, k, t, 0);
+
+                       if (flag == 0)
+                               do_key(a, a + step, tot, (char *)out, key, actkb, k, t, KEY_MODE_DUMMY);
                        else
                        else
-                               cp_key(a, a+step, tot, (char *)out, key, actkb, k[2], NULL, KEY_MODE_DUMMY);
+                               cp_key(a, a + step, tot, (char *)out, key, actkb, k[2], NULL, KEY_MODE_DUMMY);
                }
        }
        else {
                }
        }
        else {
-               if(key->type==KEY_RELATIVE) {
+               if (key->type == KEY_RELATIVE) {
                        KeyBlock *kb;
                        KeyBlock *kb;
-                       
-                       for(kb= key->block.first; kb; kb= kb->next)
-                               kb->weights= get_weights_array(ob, kb->vgroup);
+                       for (kb = key->block.first; kb; kb = kb->next) {
+                               kb->weights = get_weights_array(ob, kb->vgroup);
+                       }
 
 
-                       do_rel_key(0, tot, tot, (char *)out, key, actkb, KEY_MODE_DUMMY);
+                       BKE_key_evaluate_relative(0, tot, tot, (char *)out, key, actkb, KEY_MODE_DUMMY);
                        
                        
-                       for(kb= key->block.first; kb; kb= kb->next) {
-                               if(kb->weights) MEM_freeN(kb->weights);
-                               kb->weights= NULL;
+                       for (kb = key->block.first; kb; kb = kb->next) {
+                               if (kb->weights) MEM_freeN(kb->weights);
+                               kb->weights = NULL;
                        }
                }
                else {
                        }
                }
                else {
-                       ctime= BKE_curframe(scene);
-                       
-#if 0 // XXX old animation system
-                       if(calc_ipo_spec(key->ipo, KEY_SPEED, &ctime)==0) {
-                               ctime /= 100.0;
-                               CLAMP(ctime, 0.0, 1.0);
-                       }
-#endif // XXX old animation system
-                       // XXX for now... since speed curve cannot be directly ported yet
-                       ctime /= 100.0f;
-                       CLAMP(ctime, 0.0f, 1.0f); // XXX for compat, we use this, but this clamping was confusing
-                       
-                       flag= setkeys(ctime, &key->block, k, t, 0);
+                       const float ctime_scaled = key->ctime / 100.0f;
 
 
-                       if(flag==0)
+                       flag = setkeys(ctime_scaled, &key->block, k, t, 0);
+
+                       if (flag == 0)
                                do_key(0, tot, tot, (char *)out, key, actkb, k, t, KEY_MODE_DUMMY);
                        else
                                cp_key(0, tot, tot, (char *)out, key, actkb, k[2], NULL, KEY_MODE_DUMMY);
                                do_key(0, tot, tot, (char *)out, key, actkb, k, t, KEY_MODE_DUMMY);
                        else
                                cp_key(0, tot, tot, (char *)out, key, actkb, k[2], NULL, KEY_MODE_DUMMY);
@@ -1182,95 +1131,101 @@ static void do_cu_key(Curve *cu, Key *key, KeyBlock *actkb, KeyBlock **k, float
        Nurb *nu;
        int a, step;
        
        Nurb *nu;
        int a, step;
        
-       for(a=0, nu=cu->nurb.first; nu; nu=nu->next, a+=step) {
-               if(nu->bp) {
-                       step= nu->pntsu*nu->pntsv;
-                       do_key(a, a+step, tot, out, key, actkb, k, t, KEY_MODE_BPOINT);
+       for (a = 0, nu = cu->nurb.first; nu; nu = nu->next, a += step) {
+               if (nu->bp) {
+                       step = nu->pntsu * nu->pntsv;
+                       do_key(a, a + step, tot, out, key, actkb, k, t, KEY_MODE_BPOINT);
                }
                }
-               else if(nu->bezt) {
-                       step= 3*nu->pntsu;
-                       do_key(a, a+step, tot, out, key, actkb, k, t, KEY_MODE_BEZTRIPLE);
+               else if (nu->bezt) {
+                       step = 3 * nu->pntsu;
+                       do_key(a, a + step, tot, out, key, actkb, k, t, KEY_MODE_BEZTRIPLE);
+               }
+               else {
+                       step = 0;
                }
                }
-               else
-                       step= 0;
        }
 }
 
        }
 }
 
-static void do_rel_cu_key(Curve *cu, Key *key, KeyBlock *actkb, float UNUSED(ctime), char *out, const int tot)
+static void do_rel_cu_key(Curve *cu, Key *key, KeyBlock *actkb, char *out, const int tot)
 {
        Nurb *nu;
        int a, step;
        
 {
        Nurb *nu;
        int a, step;
        
-       for(a=0, nu=cu->nurb.first; nu; nu=nu->next, a+=step) {
-               if(nu->bp) {
-                       step= nu->pntsu*nu->pntsv;
-                       do_rel_key(a, a+step, tot, out, key, actkb, KEY_MODE_BPOINT);
+       for (a = 0, nu = cu->nurb.first; nu; nu = nu->next, a += step) {
+               if (nu->bp) {
+                       step = nu->pntsu * nu->pntsv;
+                       BKE_key_evaluate_relative(a, a + step, tot, out, key, actkb, KEY_MODE_BPOINT);
+               }
+               else if (nu->bezt) {
+                       step = 3 * nu->pntsu;
+                       BKE_key_evaluate_relative(a, a + step, tot, out, key, actkb, KEY_MODE_BEZTRIPLE);
                }
                }
-               else if(nu->bezt) {
-                       step= 3*nu->pntsu;
-                       do_rel_key(a, a+step, tot, out, key, actkb, KEY_MODE_BEZTRIPLE);
+               else {
+                       step = 0;
                }
                }
-               else
-                       step= 0;
        }
 }
 
 static void do_curve_key(Scene *scene, Object *ob, Key *key, char *out, const int tot)
 {
        }
 }
 
 static void do_curve_key(Scene *scene, Object *ob, Key *key, char *out, const int tot)
 {
-       Curve *cu= ob->data;
-       KeyBlock *k[4], *actkb= ob_get_keyblock(ob);
-       float cfra, ctime, t[4], delta;
-       int a, flag = 0, step = 0;
-
-       if(key->slurph  && key->type!=KEY_RELATIVE) {
+       Curve *cu = ob->data;
+       KeyBlock *k[4], *actkb = BKE_keyblock_from_object(ob);
+       float t[4];
+       int flag = 0;
+
+       if (key->slurph && key->type != KEY_RELATIVE) {
+               const float ctime_scaled = key->ctime / 100.0f;
+               float delta = (float)key->slurph / tot;
+               float cfra = (float)scene->r.cfra;
                Nurb *nu;
                Nurb *nu;
-               int mode=0, i= 0, remain= 0, estep=0, count=0;
-
-               delta= (float)key->slurph / tot;
+               int i = 0, remain = 0;
+               int step, a;
 
 
-               step= 1;
-               if(tot>100 && slurph_opt) {
-                       step= tot/50;
-                       delta*= step;
+               if (tot > 100 && slurph_opt) {
+                       step = tot / 50;
+                       delta *= step;
                        /* in do_key and cp_key the case a>tot has been handled */
                }
                        /* in do_key and cp_key the case a>tot has been handled */
                }
+               else {
+                       step = 1;
+               }
 
 
-               cfra= (float)scene->r.cfra;
+               for (nu = cu->nurb.first; nu; nu = nu->next) {
+                       int estep, mode;
 
 
-               for(nu=cu->nurb.first; nu; nu=nu->next) {
-                       if(nu->bp) {
-                               mode= KEY_MODE_BPOINT;
-                               estep= nu->pntsu*nu->pntsv;
+                       if (nu->bp) {
+                               mode = KEY_MODE_BPOINT;
+                               estep = nu->pntsu * nu->pntsv;
                        }
                        }
-                       else if(nu->bezt) {
-                               mode= KEY_MODE_BEZTRIPLE;
-                               estep= 3*nu->pntsu;
+                       else if (nu->bezt) {
+                               mode = KEY_MODE_BEZTRIPLE;
+                               estep = 3 * nu->pntsu;
+                       }
+                       else {
+                               mode = 0;
+                               estep = 0;
                        }
                        }
-                       else
-                               step= 0;
 
 
-                       a= 0;
+                       a = 0;
                        while (a < estep) {
                        while (a < estep) {
-                               if (remain <= 0) {
-                                       cfra+= delta;
-                                       ctime= BKE_curframe(scene);
+                               int count;
 
 
-                                       ctime /= 100.0f;
-                                       CLAMP(ctime, 0.0f, 1.0f); // XXX for compat, we use this, but this clamping was confusing
-                                       flag= setkeys(ctime, &key->block, k, t, 0);
+                               if (remain <= 0) {
+                                       cfra += delta;
+                                       flag = setkeys(ctime_scaled, &key->block, k, t, 0);
 
 
-                                       remain= step;
+                                       remain = step;
                                }
 
                                }
 
-                               count= MIN2(remain, estep);
+                               count = min_ii(remain, estep);
                                if (mode == KEY_MODE_BEZTRIPLE) {
                                        count += 3 - count % 3;
                                }
 
                                if (mode == KEY_MODE_BEZTRIPLE) {
                                        count += 3 - count % 3;
                                }
 
-                               if(flag==0)
-                                       do_key(i, i+count, tot, (char *)out, key, actkb, k, t, mode);
+                               if (flag == 0)
+                                       do_key(i, i + count, tot, (char *)out, key, actkb, k, t, mode);
                                else
                                else
-                                       cp_key(i, i+count, tot, (char *)out, key, actkb, k[2], NULL, mode);
+                                       cp_key(i, i + count, tot, (char *)out, key, actkb, k[2], NULL, mode);
 
                                a += count;
                                i += count;
 
                                a += count;
                                i += count;
@@ -1279,23 +1234,15 @@ static void do_curve_key(Scene *scene, Object *ob, Key *key, char *out, const in
                }
        }
        else {
                }
        }
        else {
-               
-               ctime= BKE_curframe(scene);
-               
-               if(key->type==KEY_RELATIVE) {
-                       do_rel_cu_key(cu, cu->key, actkb, ctime, out, tot);
+               if (key->type == KEY_RELATIVE) {
+                       do_rel_cu_key(cu, cu->key, actkb, out, tot);
                }
                else {
                }
                else {
-#if 0 // XXX old animation system
-                       if(calc_ipo_spec(key->ipo, KEY_SPEED, &ctime)==0) {
-                               ctime /= 100.0;
-                               CLAMP(ctime, 0.0, 1.0);
-                       }
-#endif // XXX old animation system
-                       
-                       flag= setkeys(ctime, &key->block, k, t, 0);
-                       
-                       if(flag==0) do_cu_key(cu, key, actkb, k, t, out, tot);
+                       const float ctime_scaled = key->ctime / 100.0f;
+
+                       flag = setkeys(ctime_scaled, &key->block, k, t, 0);
+
+                       if (flag == 0) do_cu_key(cu, key, actkb, k, t, out, tot);
                        else cp_cu_key(cu, key, actkb, k[2], 0, tot, out, tot);
                }
        }
                        else cp_cu_key(cu, key, actkb, k[2], 0, tot, out, tot);
                }
        }
@@ -1303,243 +1250,237 @@ static void do_curve_key(Scene *scene, Object *ob, Key *key, char *out, const in
 
 static void do_latt_key(Scene *scene, Object *ob, Key *key, char *out, const int tot)
 {
 
 static void do_latt_key(Scene *scene, Object *ob, Key *key, char *out, const int tot)
 {
-       Lattice *lt= ob->data;
-       KeyBlock *k[4], *actkb= ob_get_keyblock(ob);
-       float delta, cfra, ctime, t[4];
-       int a, flag;
+       Lattice *lt = ob->data;
+       KeyBlock *k[4], *actkb = BKE_keyblock_from_object(ob);
+       float t[4];
+       int flag;
        
        
-       if(key->slurph) {
-               delta= key->slurph;
-               delta/= (float)tot;
-               
-               cfra= (float)scene->r.cfra;
-               
-               for(a=0; a<tot; a++, cfra+= delta) {
-                       
-                       ctime= BKE_curframe(scene);
-#if 0 // XXX old animation system
-                       if(calc_ipo_spec(key->ipo, KEY_SPEED, &ctime)==0) {
-                               ctime /= 100.0;
-                               CLAMP(ctime, 0.0, 1.0);
-                       }
-#endif // XXX old animation system
-               
-                       flag= setkeys(ctime, &key->block, k, t, 0);
+       if (key->slurph && key->type != KEY_RELATIVE) {
+               const float ctime_scaled = key->ctime / 100.0f;
+               float delta = (float)key->slurph / tot;
+               float cfra = (float)scene->r.cfra;
+               int a;
 
 
-                       if(flag==0)
-                               do_key(a, a+1, tot, out, key, actkb, k, t, KEY_MODE_DUMMY);
+               for (a = 0; a < tot; a++, cfra += delta) {
+                       flag = setkeys(ctime_scaled, &key->block, k, t, 0);
+
+                       if (flag == 0)
+                               do_key(a, a + 1, tot, out, key, actkb, k, t, KEY_MODE_DUMMY);
                        else
                        else
-                               cp_key(a, a+1, tot, out, key, actkb, k[2], NULL, KEY_MODE_DUMMY);
-               }               
+                               cp_key(a, a + 1, tot, out, key, actkb, k[2], NULL, KEY_MODE_DUMMY);
+               }
        }
        else {
        }
        else {
-               if(key->type==KEY_RELATIVE) {
+               if (key->type == KEY_RELATIVE) {
                        KeyBlock *kb;
                        
                        KeyBlock *kb;
                        
-                       for(kb= key->block.first; kb; kb= kb->next)
-                               kb->weights= get_weights_array(ob, kb->vgroup);
+                       for (kb = key->block.first; kb; kb = kb->next)
+                               kb->weights = get_weights_array(ob, kb->vgroup);
                        
                        
-                       do_rel_key(0, tot, tot, out, key, actkb, KEY_MODE_DUMMY);
+                       BKE_key_evaluate_relative(0, tot, tot, out, key, actkb, KEY_MODE_DUMMY);
                        
                        
-                       for(kb= key->block.first; kb; kb= kb->next) {
-                               if(kb->weights) MEM_freeN(kb->weights);
-                               kb->weights= NULL;
+                       for (kb = key->block.first; kb; kb = kb->next) {
+                               if (kb->weights) MEM_freeN(kb->weights);
+                               kb->weights = NULL;
                        }
                }
                else {
                        }
                }
                else {
-                       ctime= BKE_curframe(scene);
-
-#if 0 // XXX old animation system
-                       if(calc_ipo_spec(key->ipo, KEY_SPEED, &ctime)==0) {
-                               ctime /= 100.0;
-                               CLAMP(ctime, 0.0, 1.0);
-                       }
-#endif // XXX old animation system
+                       const float ctime_scaled = key->ctime / 100.0f;
                        
                        
-                       flag= setkeys(ctime, &key->block, k, t, 0);
+                       flag = setkeys(ctime_scaled, &key->block, k, t, 0);
 
 
-                       if(flag==0)
+                       if (flag == 0)
                                do_key(0, tot, tot, (char *)out, key, actkb, k, t, KEY_MODE_DUMMY);
                        else
                                cp_key(0, tot, tot, (char *)out, key, actkb, k[2], NULL, KEY_MODE_DUMMY);
                }
        }
        
                                do_key(0, tot, tot, (char *)out, key, actkb, k, t, KEY_MODE_DUMMY);
                        else
                                cp_key(0, tot, tot, (char *)out, key, actkb, k[2], NULL, KEY_MODE_DUMMY);
                }
        }
        
-       if(lt->flag & LT_OUTSIDE) outside_lattice(lt);
+       if (lt->flag & LT_OUTSIDE) outside_lattice(lt);
 }
 
 /* returns key coordinates (+ tilt) when key applied, NULL otherwise */
 float *do_ob_key(Scene *scene, Object *ob)
 {
 }
 
 /* returns key coordinates (+ tilt) when key applied, NULL otherwise */
 float *do_ob_key(Scene *scene, Object *ob)
 {
-       Key *key= ob_get_key(ob);
-       KeyBlock *actkb= ob_get_keyblock(ob);
+       Key *key = BKE_key_from_object(ob);
+       KeyBlock *actkb = BKE_keyblock_from_object(ob);
        char *out;
        char *out;
-       int tot= 0, size= 0;
+       int tot = 0, size = 0;
        
        
-       if(key==NULL || key->block.first==NULL)
+       if (key == NULL || key->block.first == NULL)
                return NULL;
 
        /* compute size of output array */
                return NULL;
 
        /* compute size of output array */
-       if(ob->type == OB_MESH) {
-               Mesh *me= ob->data;
+       if (ob->type == OB_MESH) {
+               Mesh *me = ob->data;
 
 
-               tot= me->totvert;
-               size= tot*3*sizeof(float);
+               tot = me->totvert;
+               size = tot * 3 * sizeof(float);
        }
        }
-       else if(ob->type == OB_LATTICE) {
-               Lattice *lt= ob->data;
+       else if (ob->type == OB_LATTICE) {
+               Lattice *lt = ob->data;
 
 
-               tot= lt->pntsu*lt->pntsv*lt->pntsw;
-               size= tot*3*sizeof(float);
+               tot = lt->pntsu * lt->pntsv * lt->pntsw;
+               size = tot * 3 * sizeof(float);
        }
        }
-       else if(ELEM(ob->type, OB_CURVE, OB_SURF)) {
-               Curve *cu= ob->data;
+       else if (ELEM(ob->type, OB_CURVE, OB_SURF)) {
+               Curve *cu = ob->data;
                Nurb *nu;
 
                Nurb *nu;
 
-               for(nu=cu->nurb.first; nu; nu=nu->next) {
-                       if(nu->bezt) {
-                               tot += 3*nu->pntsu;
-                               size += nu->pntsu*12*sizeof(float);
+               for (nu = cu->nurb.first; nu; nu = nu->next) {
+                       if (nu->bezt) {
+                               tot += 3 * nu->pntsu;
+                               size += nu->pntsu * 12 * sizeof(float);
                        }
                        }
-                       else if(nu->bp) {
-                               tot += nu->pntsu*nu->pntsv;
-                               size += nu->pntsu*nu->pntsv*12*sizeof(float);
+                       else if (nu->bp) {
+                               tot += nu->pntsu * nu->pntsv;
+                               size += nu->pntsu * nu->pntsv * 12 * sizeof(float);
                        }
                }
        }
 
        /* if nothing to interpolate, cancel */
                        }
                }
        }
 
        /* if nothing to interpolate, cancel */
-       if(tot == 0 || size == 0)
+       if (tot == 0 || size == 0)
                return NULL;
        
        /* allocate array */
                return NULL;
        
        /* allocate array */
-       out= MEM_callocN(size, "do_ob_key out");
+       out = MEM_callocN(size, "do_ob_key out");
 
        /* prevent python from screwing this up? anyhoo, the from pointer could be dropped */
 
        /* prevent python from screwing this up? anyhoo, the from pointer could be dropped */
-       key->from= (ID *)ob->data;
+       key->from = (ID *)ob->data;
                
                
-       if(ob->shapeflag & OB_SHAPE_LOCK) {
+       if (ob->shapeflag & OB_SHAPE_LOCK) {
                /* shape locked, copy the locked shape instead of blending */
                /* shape locked, copy the locked shape instead of blending */
-               KeyBlock *kb= BLI_findlink(&key->block, ob->shapenr-1);
+               KeyBlock *kb = BLI_findlink(&key->block, ob->shapenr - 1);
                
                
-               if(kb && (kb->flag & KEYBLOCK_MUTE))
-                       kb= key->refkey;
+               if (kb && (kb->flag & KEYBLOCK_MUTE))
+                       kb = key->refkey;
 
 
-               if(kb==NULL) {
-                       kb= key->block.first;
-                       ob->shapenr= 1;
+               if (kb == NULL) {
+                       kb = key->block.first;
+                       ob->shapenr = 1;
                }
                
                if (OB_TYPE_SUPPORT_VGROUP(ob->type)) {
                }
                
                if (OB_TYPE_SUPPORT_VGROUP(ob->type)) {
-                       float *weights= get_weights_array(ob, kb->vgroup);
+                       float *weights = get_weights_array(ob, kb->vgroup);
 
                        cp_key(0, tot, tot, out, key, actkb, kb, weights, 0);
 
 
                        cp_key(0, tot, tot, out, key, actkb, kb, weights, 0);
 
-                       if(weights) MEM_freeN(weights);
+                       if (weights) MEM_freeN(weights);
                }
                }
-               else if(ELEM(ob->type, OB_CURVE, OB_SURF))
+               else if (ELEM(ob->type, OB_CURVE, OB_SURF))
                        cp_cu_key(ob->data, key, actkb, kb, 0, tot, out, tot);
        }
        else {
                /* do shapekey local drivers */
                        cp_cu_key(ob->data, key, actkb, kb, 0, tot, out, tot);
        }
        else {
                /* do shapekey local drivers */
-               float ctime= (float)scene->r.cfra; // XXX this needs to be checked
-               
+               float ctime = (float)scene->r.cfra; // XXX this needs to be checked
+
                BKE_animsys_evaluate_animdata(scene, &key->id, key->adt, ctime, ADT_RECALC_DRIVERS);
                
                BKE_animsys_evaluate_animdata(scene, &key->id, key->adt, ctime, ADT_RECALC_DRIVERS);
                
-               if(ob->type==OB_MESH) do_mesh_key(scene, ob, key, out, tot);
-               else if(ob->type==OB_LATTICE) do_latt_key(scene, ob, key, out, tot);
-               else if(ob->type==OB_CURVE) do_curve_key(scene, ob, key, out, tot);
-               else if(ob->type==OB_SURF) do_curve_key(scene, ob, key, out, tot);
+               if (ob->type == OB_MESH) do_mesh_key(scene, ob, key, out, tot);
+               else if (ob->type == OB_LATTICE) do_latt_key(scene, ob, key, out, tot);
+               else if (ob->type == OB_CURVE) do_curve_key(scene, ob, key, out, tot);
+               else if (ob->type == OB_SURF) do_curve_key(scene, ob, key, out, tot);
        }
        
        }
        
-       return (float*)out;
+       return (float *)out;
 }
 
 }
 
-Key *ob_get_key(Object *ob)
+Key *BKE_key_from_object(Object *ob)
 {
 {
-       if(ob==NULL) return NULL;
+       if (ob == NULL) return NULL;
        
        
-       if(ob->type==OB_MESH) {
-               Mesh *me= ob->data;
+       if (ob->type == OB_MESH) {
+               Mesh *me = ob->data;
                return me->key;
        }
                return me->key;
        }
-       else if ELEM(ob->type, OB_CURVE, OB_SURF) {
-               Curve *cu= ob->data;
+       else if (ELEM(ob->type, OB_CURVE, OB_SURF)) {
+               Curve *cu = ob->data;
                return cu->key;
        }
                return cu->key;
        }
-       else if(ob->type==OB_LATTICE) {
-               Lattice *lt= ob->data;
+       else if (ob->type == OB_LATTICE) {
+               Lattice *lt = ob->data;
                return lt->key;
        }
        return NULL;
 }
 
                return lt->key;
        }
        return NULL;
 }
 
-KeyBlock *add_keyblock(Key *key, const char *name)
+KeyBlock *BKE_keyblock_add(Key *key, const char *name)
 {
        KeyBlock *kb;
 {
        KeyBlock *kb;
-       float curpos= -0.1;
+       float curpos = -0.1;
        int tot;
        
        int tot;
        
-       kb= key->block.last;
-       if(kb) curpos= kb->pos;
+       kb = key->block.last;
+       if (kb) curpos = kb->pos;
        
        
-       kb= MEM_callocN(sizeof(KeyBlock), "Keyblock");
+       kb = MEM_callocN(sizeof(KeyBlock), "Keyblock");
        BLI_addtail(&key->block, kb);
        BLI_addtail(&key->block, kb);
-       kb->type= KEY_CARDINAL;
+       kb->type = KEY_CARDINAL;
        
        
-       tot= BLI_countlist(&key->block);
-       if(name) {
+       tot = BLI_countlist(&key->block);
+       if (name) {
                BLI_strncpy(kb->name, name, sizeof(kb->name));
                BLI_strncpy(kb->name, name, sizeof(kb->name));
-       } else {
-               if(tot==1) BLI_strncpy(kb->name, "Basis", sizeof(kb->name));
-               else BLI_snprintf(kb->name, sizeof(kb->name), "Key %d", tot-1);
+       }
+       else {
+               if (tot == 1) BLI_strncpy(kb->name, "Basis", sizeof(kb->name));
+               else BLI_snprintf(kb->name, sizeof(kb->name), "Key %d", tot - 1);
        }
 
        BLI_uniquename(&key->block, kb, "Key", '.', offsetof(KeyBlock, name), sizeof(kb->name));
 
        }
 
        BLI_uniquename(&key->block, kb, "Key", '.', offsetof(KeyBlock, name), sizeof(kb->name));
 
-       // XXX this is old anim system stuff? (i.e. the 'index' of the shapekey)
-       kb->adrcode= tot-1;
        kb->uid = key->uidgen++;
 
        key->totkey++;
        kb->uid = key->uidgen++;
 
        key->totkey++;
-       if(key->totkey==1) key->refkey= kb;
+       if (key->totkey == 1) key->refkey = kb;
        
        
-       kb->slidermin= 0.0f;
-       kb->slidermax= 1.0f;
-       
-       // XXX kb->pos is the confusing old horizontal-line RVK crap in old IPO Editor...
-       if(key->type == KEY_RELATIVE) 
-               kb->pos= curpos + 0.1f;
-       else {
-#if 0 // XXX old animation system
-               curpos= BKE_curframe(scene);
-               if(calc_ipo_spec(key->ipo, KEY_SPEED, &curpos)==0) {
-                       curpos /= 100.0;
-               }
-               kb->pos= curpos;
-               
-               sort_keys(key);
-#endif // XXX old animation system
+       kb->slidermin = 0.0f;
+       kb->slidermax = 1.0f;
+
+       /**
+        * \note caller may want to set this to current time, but don't do it here since we need to sort
+        * which could cause problems in some cases, see #BKE_keyblock_add_ctime */
+       kb->pos = curpos + 0.1f; /* only used for absolute shape keys */
+
+       return kb;
+}
+
+/**
+ * \note sorting is a problematic side effect in some cases,
+ * better only do this explicitly by having its own function,
+ *
+ * \param key The key datablock to add to.
+ * \param name Optional name for the new keyblock.
+ * \param do_force always use ctime even for relative keys.
+ */
+KeyBlock *BKE_keyblock_add_ctime(Key *key, const char *name, const short do_force)
+{
+       KeyBlock *kb = BKE_keyblock_add(key, name);
+
+       if (do_force || (key->type != KEY_RELATIVE)) {
+               kb->pos = key->ctime / 100.0f;
+               BKE_key_sort(key);
        }
        }
+
        return kb;
 }
 
 /* only the active keyblock */
        return kb;
 }
 
 /* only the active keyblock */
-KeyBlock *ob_get_keyblock(Object *ob) 
+KeyBlock *BKE_keyblock_from_object(Object *ob) 
 {
 {
-       Key *key= ob_get_key(ob);
+       Key *key = BKE_key_from_object(ob);
        
        if (key) {
        
        if (key) {
-               KeyBlock *kb= BLI_findlink(&key->block, ob->shapenr-1);
+               KeyBlock *kb = BLI_findlink(&key->block, ob->shapenr - 1);
                return kb;
        }
 
        return NULL;
 }
 
                return kb;
        }
 
        return NULL;
 }
 
-KeyBlock *ob_get_reference_keyblock(Object *ob)
+KeyBlock *BKE_keyblock_from_object_reference(Object *ob)
 {
 {
-       Key *key= ob_get_key(ob);
+       Key *key = BKE_key_from_object(ob);
        
        if (key)
                return key->refkey;
        
        if (key)
                return key->refkey;
@@ -1548,18 +1489,18 @@ KeyBlock *ob_get_reference_keyblock(Object *ob)
 }
 
 /* get the appropriate KeyBlock given an index */
 }
 
 /* get the appropriate KeyBlock given an index */
-KeyBlock *key_get_keyblock(Key *key, int index)
+KeyBlock *BKE_keyblock_from_key(Key *key, int index)
 {
        KeyBlock *kb;
        int i;
        
        if (key) {
 {
        KeyBlock *kb;
        int i;
        
        if (key) {
-               kb= key->block.first;
+               kb = key->block.first;
                
                
-               for (i= 1; i < key->totkey; i++) {
-                       kb= kb->next;
+               for (i = 1; i < key->totkey; i++) {
+                       kb = kb->next;
                        
                        
-                       if (index==i)
+                       if (index == i)
                                return kb;
                }
        }
                                return kb;
                }
        }
@@ -1568,30 +1509,41 @@ KeyBlock *key_get_keyblock(Key *key, int index)
 }
 
 /* get the appropriate KeyBlock given a name to search for */
 }
 
 /* get the appropriate KeyBlock given a name to search for */
-KeyBlock *key_get_named_keyblock(Key *key, const char name[])
+KeyBlock *BKE_keyblock_find_name(Key *key, const char name[])
 {
 {
-       if (key && name)
-               return BLI_findstring(&key->block, name, offsetof(KeyBlock, name));
-       
-       return NULL;
+       return BLI_findstring(&key->block, name, offsetof(KeyBlock, name));
+}
+
+/**
+ * \brief copy shape-key attributes, but not key data.or name/uid
+ */
+void BKE_keyblock_copy_settings(KeyBlock *kb_dst, const KeyBlock *kb_src)
+{
+       kb_dst->pos        = kb_src->pos;
+       kb_dst->curval     = kb_src->curval;
+       kb_dst->type       = kb_src->type;
+       kb_dst->relative   = kb_src->relative;
+       BLI_strncpy(kb_dst->vgroup, kb_src->vgroup, sizeof(kb_dst->vgroup));
+       kb_dst->slidermin  = kb_src->slidermin;
+       kb_dst->slidermax  = kb_src->slidermax;
 }
 
 /* Get RNA-Path for 'value' setting of the given ShapeKey 
 }
 
 /* Get RNA-Path for 'value' setting of the given ShapeKey 
- * NOTE: the user needs to free the returned string once they're finishe with it
+ * NOTE: the user needs to free the returned string once they're finish with it
  */
  */
-char *key_get_curValue_rnaPath(Key *key, KeyBlock *kb)
+char *BKE_keyblock_curval_rnapath_get(Key *key, KeyBlock *kb)
 {
        PointerRNA ptr;
        PropertyRNA *prop;
        
        /* sanity checks */
 {
        PointerRNA ptr;
        PropertyRNA *prop;
        
        /* sanity checks */
-       if ELEM(NULL, key, kb)
+       if (ELEM(NULL, key, kb))
                return NULL;
        
        /* create the RNA pointer */
        RNA_pointer_create(&key->id, &RNA_ShapeKey, kb, &ptr);
        /* get pointer to the property too */
                return NULL;
        
        /* create the RNA pointer */
        RNA_pointer_create(&key->id, &RNA_ShapeKey, kb, &ptr);
        /* get pointer to the property too */
-       prop= RNA_struct_find_property(&ptr, "value");
+       prop = RNA_struct_find_property(&ptr, "value");
        
        /* return the path */
        return RNA_path_from_ID_to_property(&ptr, prop);
        
        /* return the path */
        return RNA_path_from_ID_to_property(&ptr, prop);
@@ -1601,46 +1553,46 @@ char *key_get_curValue_rnaPath(Key *key, KeyBlock *kb)
 /* conversion functions */
 
 /************************* Lattice ************************/
 /* conversion functions */
 
 /************************* Lattice ************************/
-void latt_to_key(Lattice *lt, KeyBlock *kb)
+void BKE_key_convert_from_lattice(Lattice *lt, KeyBlock *kb)
 {
        BPoint *bp;
        float *fp;
        int a, tot;
 
 {
        BPoint *bp;
        float *fp;
        int a, tot;
 
-       tot= lt->pntsu*lt->pntsv*lt->pntsw;
-       if(tot==0) return;
+       tot = lt->pntsu * lt->pntsv * lt->pntsw;
+       if (tot == 0) return;
 
 
-       if(kb->data) MEM_freeN(kb->data);
+       if (kb->data) MEM_freeN(kb->data);
 
 
-       kb->data= MEM_callocN(lt->key->elemsize*tot, "kb->data");
-       kb->totelem= tot;
+       kb->data = MEM_callocN(lt->key->elemsize * tot, "kb->data");
+       kb->totelem = tot;
 
 
-       bp= lt->def;
-       fp= kb->data;
-       for(a=0; a<kb->totelem; a++, fp+=3, bp++) {
+       bp = lt->def;
+       fp = kb->data;
+       for (a = 0; a < kb->totelem; a++, fp += 3, bp++) {
                copy_v3_v3(fp, bp->vec);
        }
 }
 
                copy_v3_v3(fp, bp->vec);
        }
 }
 
-void key_to_latt(KeyBlock *kb, Lattice *lt)
+void BKE_key_convert_to_lattice(KeyBlock *kb, Lattice *lt)
 {
        BPoint *bp;
        float *fp;
        int a, tot;
 
 {
        BPoint *bp;
        float *fp;
        int a, tot;
 
-       bp= lt->def;
-       fp= kb->data;
+       bp = lt->def;
+       fp = kb->data;
 
 
-       tot= lt->pntsu*lt->pntsv*lt->pntsw;
-       tot= MIN2(kb->totelem, tot);
+       tot = lt->pntsu * lt->pntsv * lt->pntsw;
+       tot = min_ii(kb->totelem, tot);
 
 
-       for(a=0; a<tot; a++, fp+=3, bp++) {
+       for (a = 0; a < tot; a++, fp += 3, bp++) {
                copy_v3_v3(bp->vec, fp);
        }
 }
 
 /************************* Curve ************************/
                copy_v3_v3(bp->vec, fp);
        }
 }
 
 /************************* Curve ************************/
-void curve_to_key(Curve *cu, KeyBlock *kb, ListBase *nurb)
+void BKE_key_convert_from_curve(Curve *cu, KeyBlock *kb, ListBase *nurb)
 {
        Nurb *nu;
        BezTriple *bezt;
 {
        Nurb *nu;
        BezTriple *bezt;
@@ -1649,49 +1601,49 @@ void curve_to_key(Curve *cu, KeyBlock *kb, ListBase *nurb)
        int a, tot;
 
        /* count */
        int a, tot;
 
        /* count */
-       tot= count_curveverts(nurb);
-       if(tot==0) return;
+       tot = BKE_nurbList_verts_count(nurb);
+       if (tot == 0) return;
 
 
-       if(kb->data) MEM_freeN(kb->data);
+       if (kb->data) MEM_freeN(kb->data);
 
 
-       kb->data= MEM_callocN(cu->key->elemsize*tot, "kb->data");
-       kb->totelem= tot;
+       kb->data = MEM_callocN(cu->key->elemsize * tot, "kb->data");
+       kb->totelem = tot;
 
 
-       nu= nurb->first;
-       fp= kb->data;
-       while(nu) {
+       nu = nurb->first;
+       fp = kb->data;
+       while (nu) {
 
 
-               if(nu->bezt) {
-                       bezt= nu->bezt;
-                       a= nu->pntsu;
-                       while(a--) {
+               if (nu->bezt) {
+                       bezt = nu->bezt;
+                       a = nu->pntsu;
+                       while (a--) {
                                copy_v3_v3(fp, bezt->vec[0]);
                                copy_v3_v3(fp, bezt->vec[0]);
-                               fp+= 3;
+                               fp += 3;
                                copy_v3_v3(fp, bezt->vec[1]);
                                copy_v3_v3(fp, bezt->vec[1]);
-                               fp+= 3;
+                               fp += 3;
                                copy_v3_v3(fp, bezt->vec[2]);
                                copy_v3_v3(fp, bezt->vec[2]);
-                               fp+= 3;
-                               fp[0]= bezt->alfa;
-                               fp+= 3; /* alphas */
+                               fp += 3;
+                               fp[0] = bezt->alfa;
+                               fp += 3; /* alphas */
                                bezt++;
                        }
                }
                else {
                                bezt++;
                        }
                }
                else {
-                       bp= nu->bp;
-                       a= nu->pntsu*nu->pntsv;
-                       while(a--) {
+                       bp = nu->bp;
+                       a = nu->pntsu * nu->pntsv;
+                       while (a--) {
                                copy_v3_v3(fp, bp->vec);
                                copy_v3_v3(fp, bp->vec);
-                               fp[3]= bp->alfa;
+                               fp[3] = bp->alfa;
 
 
-                               fp+= 4;
+                               fp += 4;
                                bp++;
                        }
                }
                                bp++;
                        }
                }
-               nu= nu->next;
+               nu = nu->next;
        }
 }
 
        }
 }
 
-void key_to_curve(KeyBlock *kb, Curve *UNUSED(cu), ListBase *nurb)
+void BKE_key_convert_to_curve(KeyBlock *kb, Curve *UNUSED(cu), ListBase *nurb)
 {
        Nurb *nu;
        BezTriple *bezt;
 {
        Nurb *nu;
        BezTriple *bezt;
@@ -1699,284 +1651,291 @@ void key_to_curve(KeyBlock *kb, Curve *UNUSED(cu), ListBase *nurb)
        float *fp;
        int a, tot;
 
        float *fp;
        int a, tot;
 
-       nu= nurb->first;
-       fp= kb->data;
+       nu = nurb->first;
+       fp = kb->data;
 
 
-       tot= count_curveverts(nurb);
+       tot = BKE_nurbList_verts_count(nurb);
 
 
-       tot= MIN2(kb->totelem, tot);
+       tot = min_ii(kb->totelem, tot);
 
 
-       while(nu && tot>0) {
+       while (nu && tot > 0) {
 
 
-               if(nu->bezt) {
-                       bezt= nu->bezt;
-                       a= nu->pntsu;
-                       while(a-- && tot>0) {
+               if (nu->bezt) {
+                       bezt = nu->bezt;
+                       a = nu->pntsu;
+                       while (a-- && tot > 0) {
                                copy_v3_v3(bezt->vec[0], fp);
                                copy_v3_v3(bezt->vec[0], fp);
-                               fp+= 3;
+                               fp += 3;
                                copy_v3_v3(bezt->vec[1], fp);
                                copy_v3_v3(bezt->vec[1], fp);
-                               fp+= 3;
+                               fp += 3;
                                copy_v3_v3(bezt->vec[2], fp);
                                copy_v3_v3(bezt->vec[2], fp);
-                               fp+= 3;
-                               bezt->alfa= fp[0];
-                               fp+= 3; /* alphas */
+                               fp += 3;
+                               bezt->alfa = fp[0];
+                               fp += 3; /* alphas */
 
 
-                               tot-= 3;
+                               tot -= 3;
                                bezt++;
                        }
                }
                else {
                                bezt++;
                        }
                }
                else {
-                       bp= nu->bp;
-                       a= nu->pntsu*nu->pntsv;
-                       while(a-- && tot>0) {
+                       bp = nu->bp;
+                       a = nu->pntsu * nu->pntsv;
+                       while (a-- && tot > 0) {
                                copy_v3_v3(bp->vec, fp);
                                copy_v3_v3(bp->vec, fp);
-                               bp->alfa= fp[3];
+                               bp->alfa = fp[3];
 
 
-                               fp+= 4;
+                               fp += 4;
                                tot--;
                                bp++;
                        }
                }
                                tot--;
                                bp++;
                        }
                }
-               nu= nu->next;
+               nu = nu->next;
        }
 }
 
 /************************* Mesh ************************/
        }
 }
 
 /************************* Mesh ************************/
-void mesh_to_key(Mesh *me, KeyBlock *kb)
+void BKE_key_convert_from_mesh(Mesh *me, KeyBlock *kb)
 {
        MVert *mvert;
        float *fp;
        int a;
 
 {
        MVert *mvert;
        float *fp;
        int a;
 
-       if(me->totvert==0) return;
+       if (me->totvert == 0) return;
 
 
-       if(kb->data) MEM_freeN(kb->data);
+       if (kb->data) MEM_freeN(kb->data);
 
 
-       kb->data= MEM_callocN(me->key->elemsize*me->totvert, "kb->data");
-       kb->totelem= me->totvert;
+       kb->data = MEM_callocN(me->key->elemsize * me->totvert, "kb->data");
+       kb->totelem = me->totvert;
 
 
-       mvert= me->mvert;
-       fp= kb->data;
-       for(a=0; a<kb->totelem; a++, fp+=3, mvert++) {
+       mvert = me->mvert;
+       fp = kb->data;
+       for (a = 0; a < kb->totelem; a++, fp += 3, mvert++) {
                copy_v3_v3(fp, mvert->co);
 
        }
 }
 
                copy_v3_v3(fp, mvert->co);
 
        }
 }
 
-void key_to_mesh(KeyBlock *kb, Mesh *me)
+void BKE_key_convert_to_mesh(KeyBlock *kb, Mesh *me)
 {
        MVert *mvert;
        float *fp;
        int a, tot;
 
 {
        MVert *mvert;
        float *fp;
        int a, tot;
 
-       mvert= me->mvert;
-       fp= kb->data;
+       mvert = me->mvert;
+       fp = kb->data;
 
 
-       tot= MIN2(kb->totelem, me->totvert);
+       tot = min_ii(kb->totelem, me->totvert);
 
 
-       for(a=0; a<tot; a++, fp+=3, mvert++) {
+       for (a = 0; a < tot; a++, fp += 3, mvert++) {
                copy_v3_v3(mvert->co, fp);
        }
 }
 
 /************************* vert coords ************************/
                copy_v3_v3(mvert->co, fp);
        }
 }
 
 /************************* vert coords ************************/
-float (*key_to_vertcos(Object *ob, KeyBlock *kb))[3]
+float (*BKE_key_convert_to_vertcos(Object * ob, KeyBlock * kb))[3]
 {
        float (*vertCos)[3], *co;
 {
        float (*vertCos)[3], *co;
-       float *fp= kb->data;
-       int tot= 0, a;
+       float *fp = kb->data;
+       int tot = 0, a;
 
        /* Count of vertex coords in array */
 
        /* Count of vertex coords in array */
-       if(ob->type == OB_MESH) {
-               Mesh *me= (Mesh*)ob->data;
-               tot= me->totvert;
-       } else if(ob->type == OB_LATTICE) {
-               Lattice *lt= (Lattice*)ob->data;
-               tot= lt->pntsu*lt->pntsv*lt->pntsw;
-       } else if(ELEM(ob->type, OB_CURVE, OB_SURF)) {
-               Curve *cu= (Curve*)ob->data;
-               tot= count_curveverts(&cu->nurb);
+       if (ob->type == OB_MESH) {
+               Mesh *me = (Mesh *)ob->data;
+               tot = me->totvert;
+       }
+       else if (ob->type == OB_LATTICE) {
+               Lattice *lt = (Lattice *)ob->data;
+               tot = lt->pntsu * lt->pntsv * lt->pntsw;
+       }
+       else if (ELEM(ob->type, OB_CURVE, OB_SURF)) {
+               Curve *cu = (Curve *)ob->data;
+               tot = BKE_nurbList_verts_count(&cu->nurb);
        }
 
        if (tot == 0) return NULL;
 
        }
 
        if (tot == 0) return NULL;
 
-       vertCos= MEM_callocN(tot*sizeof(*vertCos), "key_to_vertcos vertCos");
+       vertCos = MEM_callocN(tot * sizeof(*vertCos), "BKE_key_convert_to_vertcos vertCos");
 
        /* Copy coords to array */
 
        /* Copy coords to array */
-       co= (float*)vertCos;
+       co = (float *)vertCos;
 
 
-       if(ELEM(ob->type, OB_MESH, OB_LATTICE)) {
-               for (a= 0; a<tot; a++, fp+=3, co+=3) {
+       if (ELEM(ob->type, OB_MESH, OB_LATTICE)) {
+               for (a = 0; a < tot; a++, fp += 3, co += 3) {
                        copy_v3_v3(co, fp);
                }
                        copy_v3_v3(co, fp);
                }
-       } else if(ELEM(ob->type, OB_CURVE, OB_SURF)) {
-               Curve *cu= (Curve*)ob->data;
-               Nurb *nu= cu->nurb.first;
+       }
+       else if (ELEM(ob->type, OB_CURVE, OB_SURF)) {
+               Curve *cu = (Curve *)ob->data;
+               Nurb *nu = cu->nurb.first;
                BezTriple *bezt;
                BPoint *bp;
 
                while (nu) {
                BezTriple *bezt;
                BPoint *bp;
 
                while (nu) {
-                       if(nu->bezt) {
+                       if (nu->bezt) {
                                int i;
                                int i;
-                               bezt= nu->bezt;
-                               a= nu->pntsu;
+                               bezt = nu->bezt;
+                               a = nu->pntsu;
 
                                while (a--) {
 
                                while (a--) {
-                                       for (i= 0; i<3; i++) {
+                                       for (i = 0; i < 3; i++) {
                                                copy_v3_v3(co, fp);
                                                copy_v3_v3(co, fp);
-                                               fp+= 3; co+= 3;
+                                               fp += 3; co += 3;
                                        }
 
                                        }
 
-                                       fp+= 3; /* skip alphas */
+                                       fp += 3; /* skip alphas */
 
                                        bezt++;
                                }
                        }
                        else {
 
                                        bezt++;
                                }
                        }
                        else {
-                               bp= nu->bp;
-                               a= nu->pntsu*nu->pntsv;
+                               bp = nu->bp;
+                               a = nu->pntsu * nu->pntsv;
 
                                while (a--) {
                                        copy_v3_v3(co, fp);
 
 
                                while (a--) {
                                        copy_v3_v3(co, fp);
 
-                                       fp+= 4;
-                                       co+= 3;
+                                       fp += 4;
+                                       co += 3;
 
                                        bp++;
                                }
                        }
 
 
                                        bp++;
                                }
                        }
 
-                       nu= nu->next;
+                       nu = nu->next;
                }
        }
 
        return vertCos;
 }
 
                }
        }
 
        return vertCos;
 }
 
-void vertcos_to_key(Object *ob, KeyBlock *kb, float (*vertCos)[3])
+void BKE_key_convert_from_vertcos(Object *ob, KeyBlock *kb, float (*vertCos)[3])
 {
 {
-       float *co= (float*)vertCos, *fp;
-       int tot= 0, a, elemsize;
+       float *co = (float *)vertCos, *fp;
+       int tot = 0, a, elemsize;
 
        if (kb->data) MEM_freeN(kb->data);
 
        /* Count of vertex coords in array */
 
        if (kb->data) MEM_freeN(kb->data);
 
        /* Count of vertex coords in array */
-       if(ob->type == OB_MESH) {
-               Mesh *me= (Mesh*)ob->data;
-               tot= me->totvert;
-               elemsize= me->key->elemsize;
-       } else if(ob->type == OB_LATTICE) {
-               Lattice *lt= (Lattice*)ob->data;
-               tot= lt->pntsu*lt->pntsv*lt->pntsw;
-               elemsize= lt->key->elemsize;
-       } else if(ELEM(ob->type, OB_CURVE, OB_SURF)) {
-               Curve *cu= (Curve*)ob->data;
-               elemsize= cu->key->elemsize;
-               tot= count_curveverts(&cu->nurb);
+       if (ob->type == OB_MESH) {
+               Mesh *me = (Mesh *)ob->data;
+               tot = me->totvert;
+               elemsize = me->key->elemsize;
+       }
+       else if (ob->type == OB_LATTICE) {
+               Lattice *lt = (Lattice *)ob->data;
+               tot = lt->pntsu * lt->pntsv * lt->pntsw;
+               elemsize = lt->key->elemsize;
+       }
+       else if (ELEM(ob->type, OB_CURVE, OB_SURF)) {
+               Curve *cu = (Curve *)ob->data;
+               elemsize = cu->key->elemsize;
+               tot = BKE_nurbList_verts_count(&cu->nurb);
        }
 
        if (tot == 0) {
        }
 
        if (tot == 0) {
-               kb->data= NULL;
+               kb->data = NULL;
                return;
        }
 
                return;
        }
 
-       fp= kb->data= MEM_callocN(tot*elemsize, "key_to_vertcos vertCos");
+       fp = kb->data = MEM_callocN(tot * elemsize, "BKE_key_convert_to_vertcos vertCos");
 
        /* Copy coords to keyblock */
 
 
        /* Copy coords to keyblock */
 
-       if(ELEM(ob->type, OB_MESH, OB_LATTICE)) {
-               for (a= 0; a<tot; a++, fp+=3, co+=3) {
+       if (ELEM(ob->type, OB_MESH, OB_LATTICE)) {
+               for (a = 0; a < tot; a++, fp += 3, co += 3) {
                        copy_v3_v3(fp, co);
                }
                        copy_v3_v3(fp, co);
                }
-       } else if(ELEM(ob->type, OB_CURVE, OB_SURF)) {
-               Curve *cu= (Curve*)ob->data;
-               Nurb *nu= cu->nurb.first;
+       }
+       else if (ELEM(ob->type, OB_CURVE, OB_SURF)) {
+               Curve *cu = (Curve *)ob->data;
+               Nurb *nu = cu->nurb.first;
                BezTriple *bezt;
                BPoint *bp;
 
                while (nu) {
                BezTriple *bezt;
                BPoint *bp;
 
                while (nu) {
-                       if(nu->bezt) {
+                       if (nu->bezt) {
                                int i;
                                int i;
-                               bezt= nu->bezt;
-                               a= nu->pntsu;
+                               bezt = nu->bezt;
+                               a = nu->pntsu;
 
                                while (a--) {
 
                                while (a--) {
-                                       for (i= 0; i<3; i++) {
+                                       for (i = 0; i < 3; i++) {
                                                copy_v3_v3(fp, co);
                                                copy_v3_v3(fp, co);
-                                               fp+= 3; co+= 3;
+                                               fp += 3; co += 3;
                                        }
 
                                        }
 
-                                       fp+= 3; /* skip alphas */
+                                       fp += 3; /* skip alphas */
 
                                        bezt++;
                                }
                        }
                        else {
 
                                        bezt++;
                                }
                        }
                        else {
-                               bp= nu->bp;
-                               a= nu->pntsu*nu->pntsv;
+                               bp = nu->bp;
+                               a = nu->pntsu * nu->pntsv;
 
                                while (a--) {
                                        copy_v3_v3(fp, co);
 
 
                                while (a--) {
                                        copy_v3_v3(fp, co);
 
-                                       fp+= 4;
-                                       co+= 3;
+                                       fp += 4;
+                                       co += 3;
 
                                        bp++;
                                }
                        }
 
 
                                        bp++;
                                }
                        }
 
-                       nu= nu->next;
+                       nu = nu->next;
                }
        }
 }
 
                }
        }
 }
 
-void offset_to_key(Object *ob, KeyBlock *kb, float (*ofs)[3])
+void BKE_key_convert_from_offset(Object *ob, KeyBlock *kb, float (*ofs)[3])
 {
        int a;
 {
        int a;
-       float *co= (float*)ofs, *fp= kb->data;
+       float *co = (float *)ofs, *fp = kb->data;
 
 
-       if(ELEM(ob->type, OB_MESH, OB_LATTICE)) {
-               for (a= 0; a<kb->totelem; a++, fp+=3, co+=3) {
+       if (ELEM(ob->type, OB_MESH, OB_LATTICE)) {
+               for (a = 0; a < kb->totelem; a++, fp += 3, co += 3) {
                        add_v3_v3(fp, co);
                }
                        add_v3_v3(fp, co);
                }
-       } else if(ELEM(ob->type, OB_CURVE, OB_SURF)) {
-               Curve *cu= (Curve*)ob->data;
-               Nurb *nu= cu->nurb.first;
+       }
+       else if (ELEM(ob->type, OB_CURVE, OB_SURF)) {
+               Curve *cu = (Curve *)ob->data;
+               Nurb *nu = cu->nurb.first;
                BezTriple *bezt;
                BPoint *bp;
 
                while (nu) {
                BezTriple *bezt;
                BPoint *bp;
 
                while (nu) {
-                       if(nu->bezt) {
+                       if (nu->bezt) {
                                int i;
                                int i;
-                               bezt= nu->bezt;
-                               a= nu->pntsu;
+                               bezt = nu->bezt;
+                               a = nu->pntsu;
 
                                while (a--) {
 
                                while (a--) {
-                                       for (i= 0; i<3; i++) {
+                                       for (i = 0; i < 3; i++) {
                                                add_v3_v3(fp, co);
                                                add_v3_v3(fp, co);
-                                               fp+= 3; co+= 3;
+                                               fp += 3; co += 3;
                                        }
 
                                        }
 
-                                       fp+= 3; /* skip alphas */
+                                       fp += 3; /* skip alphas */
 
                                        bezt++;
                                }
                        }
                        else {
 
                                        bezt++;
                                }
                        }
                        else {
-                               bp= nu->bp;
-                               a= nu->pntsu*nu->pntsv;
+                               bp = nu->bp;
+                               a = nu->pntsu * nu->pntsv;
 
                                while (a--) {
                                        add_v3_v3(fp, co);
 
 
                                while (a--) {
                                        add_v3_v3(fp, co);
 
-                                       fp+= 4;
-                                       co+= 3;
+                                       fp += 4;
+                                       co += 3;
 
                                        bp++;
                                }
                        }
 
 
                                        bp++;
                                }
                        }
 
-                       nu= nu->next;
+                       nu = nu->next;
                }
        }
 }
                }
        }
 }