rename api functions...
[blender.git] / source / blender / blenkernel / intern / key.c
index 54a2613991ae122d7108ca4af520bfb205c4ab14..7df5449b1b155ec3d4b7e7f6a4c283e90dff1e26 100644 (file)
@@ -78,7 +78,7 @@
 int slurph_opt = 1;
 
 
-void free_key(Key *key)
+void BKE_key_free(Key *key)
 {
        KeyBlock *kb;
        
@@ -94,7 +94,7 @@ void free_key(Key *key)
        
 }
 
-void free_key_nolib(Key *key)
+void BKE_key_free_nolib(Key *key)
 {
        KeyBlock *kb;
        
@@ -121,19 +121,19 @@ void free_key_nolib(Key *key)
 /* 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 = 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->uidgen = 1;
        
-       /* XXX the code here uses some defines which will soon be depreceated... */
+       /* XXX the code here uses some defines which will soon be deprecated... */
        switch (GS(id->name)) {
                case ID_ME:
                        el = key->elemstr;
@@ -170,14 +170,14 @@ Key *add_key(ID *id)    /* common function */
        return key;
 }
 
-Key *copy_key(Key *key)
+Key *BKE_key_copy(Key *key)
 {
        Key *keyn;
        KeyBlock *kbn, *kb;
        
        if (key == NULL) return NULL;
        
-       keyn = copy_libblock(&key->id);
+       keyn = BKE_libblock_copy(&key->id);
        
        BLI_duplicatelist(&keyn->block, &key->block);
        
@@ -196,7 +196,7 @@ Key *copy_key(Key *key)
 }
 
 
-Key *copy_key_nolib(Key *key)
+Key *BKE_key_copy_nolib(Key *key)
 {
        Key *keyn;
        KeyBlock *kbn, *kb;
@@ -223,7 +223,7 @@ Key *copy_key_nolib(Key *key)
        return keyn;
 }
 
-void make_local_key(Key *key)
+void BKE_key_make_local(Key *key)
 {
 
        /* - only lib users: do nothing
@@ -241,7 +241,7 @@ void make_local_key(Key *key)
  * currently being called.
  */
 
-void sort_keys(Key *key)
+void BKE_key_sort(Key *key)
 {
        KeyBlock *kb;
        KeyBlock *kb2;
@@ -271,7 +271,7 @@ void sort_keys(Key *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;
        
@@ -303,7 +303,7 @@ void key_curve_position_weights(float t, float *data, int type)
 }
 
 /* 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;
        
@@ -333,7 +333,7 @@ void key_curve_tangent_weights(float t, float *data, int type)
 }
 
 /* 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;
        
@@ -359,11 +359,11 @@ void key_curve_normal_weights(float t, float *data, int type)
        }
 }
 
-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;
-       float d, dpos, ofs = 0, lastpos, temp, fval[4];
+       float d, dpos, ofs = 0, lastpos;
        short bsplinetype;
 
        firstkey = lb->first;
@@ -377,7 +377,7 @@ static int setkeys(float fac, ListBase *lb, KeyBlock *k[], float *t, int cycl)
        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;
 
@@ -467,17 +467,12 @@ static int setkeys(float fac, ListBase *lb, KeyBlock *k[], float *t, int cycl)
        }
 
        /* interpolation */
-       
        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];
+               float t_other[4];
+               key_curve_position_weights(d, t_other, k[2]->type);
+               interp_v4_v4v4(t, t, t_other, d);
        }
 
        return 0;
@@ -614,7 +609,7 @@ static void cp_key(const int start, int end, const int tot, char *poin, Key *key
                        }
                }
                else k1 += start * key->elemsize;
-       }       
+       }
        
        if (mode == KEY_MODE_BEZTRIPLE) {
                elemstr[0] = 1;
@@ -696,8 +691,8 @@ static void cp_cu_key(Curve *cu, Key *key, KeyBlock *actkb, KeyBlock *kb, const
                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);
                }
@@ -705,8 +700,8 @@ static void cp_cu_key(Curve *cu, Key *key, KeyBlock *actkb, KeyBlock *kb, const
                        step = 3 * nu->pntsu;
 
                        /* 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);
                }
@@ -716,12 +711,11 @@ static void cp_cu_key(Curve *cu, Key *key, KeyBlock *actkb, KeyBlock *kb, const
        }
 }
 
-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];
-       char *freefrom, *freereffrom;
        int poinsize;
 
        /* currently always 0, in future key_pointer_size may assign */
@@ -754,6 +748,7 @@ void do_rel_key(const int start, int end, const int tot, char *basispoin, Key *k
                        if (!(kb->flag & KEYBLOCK_MUTE) && icuval != 0.0f && kb->totelem == tot) {
                                KeyBlock *refb;
                                float weight, *weights = kb->weights;
+                               char *freefrom = NULL, *freereffrom = NULL;
 
                                /* reference now can be any block */
                                refb = BLI_findlink(&key->block, kb->relative);
@@ -776,7 +771,7 @@ void do_rel_key(const int start, int end, const int tot, char *basispoin, Key *k
                                        
                                        ofsp = ofs;
                                        
-                                       while (cp[0]) {     /* cp[0]==amount */
+                                       while (cp[0]) {  /* (cp[0] == amount) */
                                                
                                                switch (cp[1]) {
                                                        case IPO_FLOAT:
@@ -941,7 +936,7 @@ static void do_key(const int start, int end, const int tot, char *poin, Key *key
                
                ofsp = ofs;
 
-               while (cp[0]) {     /* cp[0]==amount */
+               while (cp[0]) {  /* (cp[0] == amount) */
 
                        switch (cp[1]) {
                                case IPO_FLOAT:
@@ -1048,15 +1043,14 @@ static float *get_weights_array(Object *ob, char *vgroup)
        
        /* find the group (weak loop-in-loop) */
        defgrp_index = defgroup_name_index(ob, vgroup);
-       if (defgrp_index >= 0) {
+       if (defgrp_index != -1) {
                float *weights;
                int i;
                
                weights = MEM_callocN(totvert * sizeof(float), "weights");
 
                if (em) {
-                       eve = BM_iter_new(&iter, em->bm, BM_VERTS_OF_MESH, NULL);
-                       for (i = 0; eve; eve = BM_iter_step(&iter), i++) {
+                       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) {
@@ -1077,7 +1071,7 @@ 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)
 {
-       KeyBlock *k[4], *actkb = ob_get_keyblock(ob);
+       KeyBlock *k[4], *actkb = BKE_keyblock_from_object(ob);
        float t[4];
        int flag = 0;
 
@@ -1112,7 +1106,7 @@ static void do_mesh_key(Scene *scene, Object *ob, Key *key, char *out, const int
                                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);
@@ -1160,11 +1154,11 @@ static void do_rel_cu_key(Curve *cu, Key *key, KeyBlock *actkb, char *out, const
        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);
+                       BKE_key_evaluate_relative(a, a + step, tot, out, key, actkb, KEY_MODE_BPOINT);
                }
                else if (nu->bezt) {
                        step = 3 * nu->pntsu;
-                       do_rel_key(a, a + step, tot, out, key, actkb, KEY_MODE_BEZTRIPLE);
+                       BKE_key_evaluate_relative(a, a + step, tot, out, key, actkb, KEY_MODE_BEZTRIPLE);
                }
                else {
                        step = 0;
@@ -1175,7 +1169,7 @@ static void do_rel_cu_key(Curve *cu, Key *key, KeyBlock *actkb, char *out, const
 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);
+       KeyBlock *k[4], *actkb = BKE_keyblock_from_object(ob);
        float t[4];
        int flag = 0;
 
@@ -1223,7 +1217,7 @@ static void do_curve_key(Scene *scene, Object *ob, Key *key, char *out, const in
                                        remain = step;
                                }
 
-                               count = MIN2(remain, estep);
+                               count = min_ii(remain, estep);
                                if (mode == KEY_MODE_BEZTRIPLE) {
                                        count += 3 - count % 3;
                                }
@@ -1257,11 +1251,11 @@ 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)
 {
        Lattice *lt = ob->data;
-       KeyBlock *k[4], *actkb = ob_get_keyblock(ob);
+       KeyBlock *k[4], *actkb = BKE_keyblock_from_object(ob);
        float t[4];
        int flag;
        
-       if (key->slurph  && key->type != KEY_RELATIVE) {
+       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;
@@ -1274,7 +1268,7 @@ static void do_latt_key(Scene *scene, Object *ob, Key *key, char *out, const int
                                do_key(a, a + 1, tot, out, key, actkb, k, t, KEY_MODE_DUMMY);
                        else
                                cp_key(a, a + 1, tot, out, key, actkb, k[2], NULL, KEY_MODE_DUMMY);
-               }               
+               }
        }
        else {
                if (key->type == KEY_RELATIVE) {
@@ -1283,7 +1277,7 @@ static void do_latt_key(Scene *scene, Object *ob, Key *key, char *out, const int
                        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);
@@ -1308,8 +1302,8 @@ static void do_latt_key(Scene *scene, Object *ob, Key *key, char *out, const int
 /* 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;
        int tot = 0, size = 0;
        
@@ -1392,7 +1386,7 @@ float *do_ob_key(Scene *scene, Object *ob)
        return (float *)out;
 }
 
-Key *ob_get_key(Object *ob)
+Key *BKE_key_from_object(Object *ob)
 {
        if (ob == NULL) return NULL;
        
@@ -1411,7 +1405,7 @@ Key *ob_get_key(Object *ob)
        return NULL;
 }
 
-KeyBlock *add_keyblock(Key *key, const char *name)
+KeyBlock *BKE_keyblock_add(Key *key, const char *name)
 {
        KeyBlock *kb;
        float curpos = -0.1;
@@ -1445,7 +1439,7 @@ KeyBlock *add_keyblock(Key *key, const char *name)
 
        /**
         * \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 #add_keyblock_ctime */
+        * 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;
@@ -1455,24 +1449,26 @@ KeyBlock *add_keyblock(Key *key, const char *name)
  * \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 *add_keyblock_ctime(Key *key, const char *name, const short do_force)
+KeyBlock *BKE_keyblock_add_ctime(Key *key, const char *name, const short do_force)
 {
-       KeyBlock *kb = add_keyblock(key, name);
+       KeyBlock *kb = BKE_keyblock_add(key, name);
 
        if (do_force || (key->type != KEY_RELATIVE)) {
                kb->pos = key->ctime / 100.0f;
-               sort_keys(key);
+               BKE_key_sort(key);
        }
 
        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) {
                KeyBlock *kb = BLI_findlink(&key->block, ob->shapenr - 1);
@@ -1482,9 +1478,9 @@ KeyBlock *ob_get_keyblock(Object *ob)
        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;
@@ -1493,7 +1489,7 @@ KeyBlock *ob_get_reference_keyblock(Object *ob)
 }
 
 /* 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;
@@ -1513,18 +1509,29 @@ KeyBlock *key_get_keyblock(Key *key, int index)
 }
 
 /* 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 
  * 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;
@@ -1546,7 +1553,7 @@ char *key_get_curValue_rnaPath(Key *key, KeyBlock *kb)
 /* 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;
@@ -1567,7 +1574,7 @@ void latt_to_key(Lattice *lt, KeyBlock *kb)
        }
 }
 
-void key_to_latt(KeyBlock *kb, Lattice *lt)
+void BKE_key_convert_to_lattice(KeyBlock *kb, Lattice *lt)
 {
        BPoint *bp;
        float *fp;
@@ -1577,7 +1584,7 @@ void key_to_latt(KeyBlock *kb, Lattice *lt)
        fp = kb->data;
 
        tot = lt->pntsu * lt->pntsv * lt->pntsw;
-       tot = MIN2(kb->totelem, tot);
+       tot = min_ii(kb->totelem, tot);
 
        for (a = 0; a < tot; a++, fp += 3, bp++) {
                copy_v3_v3(bp->vec, fp);
@@ -1585,7 +1592,7 @@ void key_to_latt(KeyBlock *kb, Lattice *lt)
 }
 
 /************************* 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;
@@ -1636,7 +1643,7 @@ void curve_to_key(Curve *cu, KeyBlock *kb, ListBase *nurb)
        }
 }
 
-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;
@@ -1649,7 +1656,7 @@ void key_to_curve(KeyBlock *kb, Curve *UNUSED(cu), ListBase *nurb)
 
        tot = BKE_nurbList_verts_count(nurb);
 
-       tot = MIN2(kb->totelem, tot);
+       tot = min_ii(kb->totelem, tot);
 
        while (nu && tot > 0) {
 
@@ -1687,7 +1694,7 @@ void key_to_curve(KeyBlock *kb, Curve *UNUSED(cu), ListBase *nurb)
 }
 
 /************************* Mesh ************************/
-void mesh_to_key(Mesh *me, KeyBlock *kb)
+void BKE_key_convert_from_mesh(Mesh *me, KeyBlock *kb)
 {
        MVert *mvert;
        float *fp;
@@ -1708,7 +1715,7 @@ void mesh_to_key(Mesh *me, KeyBlock *kb)
        }
 }
 
-void key_to_mesh(KeyBlock *kb, Mesh *me)
+void BKE_key_convert_to_mesh(KeyBlock *kb, Mesh *me)
 {
        MVert *mvert;
        float *fp;
@@ -1717,7 +1724,7 @@ void key_to_mesh(KeyBlock *kb, Mesh *me)
        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++) {
                copy_v3_v3(mvert->co, fp);
@@ -1725,7 +1732,7 @@ void key_to_mesh(KeyBlock *kb, Mesh *me)
 }
 
 /************************* 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 *fp = kb->data;
@@ -1747,7 +1754,7 @@ float (*key_to_vertcos(Object * ob, KeyBlock * kb))[3]
 
        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 */
        co = (float *)vertCos;
@@ -1801,7 +1808,7 @@ float (*key_to_vertcos(Object * ob, KeyBlock * kb))[3]
        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;
@@ -1830,7 +1837,7 @@ void vertcos_to_key(Object *ob, KeyBlock *kb, float (*vertCos)[3])
                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 */
 
@@ -1881,7 +1888,7 @@ void vertcos_to_key(Object *ob, KeyBlock *kb, float (*vertCos)[3])
        }
 }
 
-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;
        float *co = (float *)ofs, *fp = kb->data;