svn merge ^/trunk/blender -r48749:48754
[blender.git] / source / blender / blenkernel / intern / customdata.c
index 5855cc67719ba03d8ac90b1dc117dd81f93b03fd..8dd3b3da705e5d108695876ba2623fe21716d7f8 100644 (file)
@@ -128,7 +128,7 @@ typedef struct LayerTypeInfo {
 } LayerTypeInfo;
 
 static void layerCopy_mdeformvert(const void *source, void *dest,
-                                                                 int count)
+                                  int count)
 {
        int i, size = sizeof(MDeformVert);
 
@@ -139,7 +139,7 @@ static void layerCopy_mdeformvert(const void *source, void *dest,
 
                if (dvert->totweight) {
                        MDeformWeight *dw = MEM_callocN(dvert->totweight * sizeof(*dw),
-                                                                                       "layerCopy_mdeformvert dw");
+                                                       "layerCopy_mdeformvert dw");
 
                        memcpy(dw, dvert->dw, dvert->totweight * sizeof(*dw));
                        dvert->dw = dw;
@@ -204,7 +204,7 @@ static void linklist_free_simple(void *link)
 }
 
 static void layerInterp_mdeformvert(void **sources, float *weights,
-                                                                       float *UNUSED(sub_weights), int count, void *dest)
+                                    float *UNUSED(sub_weights), int count, void *dest)
 {
        MDeformVert *dvert = dest;
        LinkNode *dest_dw = NULL; /* a list of lists of MDeformWeight pointers */
@@ -234,7 +234,7 @@ static void layerInterp_mdeformvert(void **sources, float *weights,
                        /* if this def_nr is not in the list, add it */
                        if (!node) {
                                MDeformWeight *tmp_dw = MEM_callocN(sizeof(*tmp_dw),
-                                                                                       "layerInterp_mdeformvert tmp_dw");
+                                                                   "layerInterp_mdeformvert tmp_dw");
                                tmp_dw->def_nr = dw->def_nr;
                                tmp_dw->weight = dw->weight * interp_weight;
                                BLI_linklist_prepend(&dest_dw, tmp_dw);
@@ -248,7 +248,7 @@ static void layerInterp_mdeformvert(void **sources, float *weights,
 
        if (totweight) {
                dvert->dw = MEM_callocN(sizeof(*dvert->dw) * totweight,
-                                                               "layerInterp_mdeformvert dvert->dw");
+                                       "layerInterp_mdeformvert dvert->dw");
                dvert->totweight = totweight;
 
                for (i = 0, node = dest_dw; node; node = node->next, ++i)
@@ -262,7 +262,7 @@ static void layerInterp_mdeformvert(void **sources, float *weights,
 
 
 static void layerInterp_msticky(void **sources, float *weights,
-                                                               float *UNUSED(sub_weights), int count, void *dest)
+                                float *UNUSED(sub_weights), int count, void *dest)
 {
        float co[2], w;
        MSticky *mst;
@@ -271,20 +271,20 @@ static void layerInterp_msticky(void **sources, float *weights,
        co[0] = co[1] = 0.0f;
        for (i = 0; i < count; i++) {
                w = weights ? weights[i] : 1.0f;
-               mst = (MSticky*)sources[i];
+               mst = (MSticky *)sources[i];
 
                madd_v2_v2fl(co, mst->co, w);
        }
 
-       mst = (MSticky*)dest;
+       mst = (MSticky *)dest;
        copy_v2_v2(mst->co, co);
 }
 
 
 static void layerCopy_tface(const void *source, void *dest, int count)
 {
-       const MTFace *source_tf = (const MTFace*)source;
-       MTFace *dest_tf = (MTFace*)dest;
+       const MTFace *source_tf = (const MTFace *)source;
+       MTFace *dest_tf = (MTFace *)dest;
        int i;
 
        for (i = 0; i < count; ++i)
@@ -292,7 +292,7 @@ static void layerCopy_tface(const void *source, void *dest, int count)
 }
 
 static void layerInterp_tface(void **sources, float *weights,
-                                                         float *sub_weights, int count, void *dest)
+                              float *sub_weights, int count, void *dest)
 {
        MTFace *tf = dest;
        int i, j, k;
@@ -326,10 +326,8 @@ static void layerSwap_tface(void *data, const int *corner_indices)
 {
        MTFace *tf = data;
        float uv[4][2];
-       static const short pin_flags[4] =
-               { TF_PIN1, TF_PIN2, TF_PIN3, TF_PIN4 };
-       static const char sel_flags[4] =
-               { TF_SEL1, TF_SEL2, TF_SEL3, TF_SEL4 };
+       static const short pin_flags[4] = { TF_PIN1, TF_PIN2, TF_PIN3, TF_PIN4 };
+       static const char sel_flags[4] = { TF_SEL1, TF_SEL2, TF_SEL3, TF_SEL4 };
        short unwrap = tf->unwrap & ~(TF_PIN1 | TF_PIN2 | TF_PIN3 | TF_PIN4);
        char flag = tf->flag & ~(TF_SEL1 | TF_SEL2 | TF_SEL3 | TF_SEL4);
        int j;
@@ -339,12 +337,12 @@ static void layerSwap_tface(void *data, const int *corner_indices)
 
                copy_v2_v2(uv[j], tf->uv[source_index]);
 
-               // swap pinning flags around
+               /* swap pinning flags around */
                if (tf->unwrap & pin_flags[source_index]) {
                        unwrap |= pin_flags[j];
                }
 
-               // swap selection flags around
+               /* swap selection flags around */
                if (tf->flag & sel_flags[source_index]) {
                        flag |= sel_flags[j];
                }
@@ -358,8 +356,8 @@ static void layerSwap_tface(void *data, const int *corner_indices)
 static void layerDefault_tface(void *data, int count)
 {
        static MTFace default_tf = {{{0, 0}, {1, 0}, {1, 1}, {0, 1}}, NULL,
-                                                          0, 0, TF_DYNAMIC|TF_CONVERTED, 0, 0};
-       MTFace *tf = (MTFace*)data;
+                                       0, 0, TF_DYNAMIC | TF_CONVERTED, 0, 0};
+       MTFace *tf = (MTFace *)data;
        int i;
 
        for (i = 0; i < count; i++)
@@ -367,27 +365,27 @@ static void layerDefault_tface(void *data, int count)
 }
 
 static void layerCopy_propFloat(const void *source, void *dest,
-                                                                 int count)
+                                int count)
 {
-       memcpy(dest, source, sizeof(MFloatProperty)*count);
+       memcpy(dest, source, sizeof(MFloatProperty) * count);
 }
 
 static void layerCopy_propInt(const void *source, void *dest,
-                                                                 int count)
+                              int count)
 {
-       memcpy(dest, source, sizeof(MIntProperty)*count);
+       memcpy(dest, source, sizeof(MIntProperty) * count);
 }
 
 static void layerCopy_propString(const void *source, void *dest,
-                                                                 int count)
+                                 int count)
 {
-       memcpy(dest, source, sizeof(MStringProperty)*count);
+       memcpy(dest, source, sizeof(MStringProperty) * count);
 }
 
 static void layerCopy_origspace_face(const void *source, void *dest, int count)
 {
-       const OrigSpaceFace *source_tf = (const OrigSpaceFace*)source;
-       OrigSpaceFace *dest_tf = (OrigSpaceFace*)dest;
+       const OrigSpaceFace *source_tf = (const OrigSpaceFace *)source;
+       OrigSpaceFace *dest_tf = (OrigSpaceFace *)dest;
        int i;
 
        for (i = 0; i < count; ++i)
@@ -395,7 +393,7 @@ static void layerCopy_origspace_face(const void *source, void *dest, int count)
 }
 
 static void layerInterp_origspace_face(void **sources, float *weights,
-                                                         float *sub_weights, int count, void *dest)
+                                       float *sub_weights, int count, void *dest)
 {
        OrigSpaceFace *osf = dest;
        int i, j, k;
@@ -442,7 +440,7 @@ static void layerSwap_origspace_face(void *data, const int *corner_indices)
 static void layerDefault_origspace_face(void *data, int count)
 {
        static OrigSpaceFace default_osf = {{{0, 0}, {1, 0}, {1, 1}, {0, 1}}};
-       OrigSpaceFace *osf = (OrigSpaceFace*)data;
+       OrigSpaceFace *osf = (OrigSpaceFace *)data;
        int i;
 
        for (i = 0; i < count; i++)
@@ -456,27 +454,27 @@ static void layerSwap_mdisps(void *data, const int *ci)
        int corners, cornersize, S;
 
        if (s->disps) {
-               int nverts= (ci[1] == 3) ? 4 : 3; /* silly way to know vertex count of face */
-               corners= multires_mdisp_corners(s);
-               cornersize= s->totdisp/corners;
+               int nverts = (ci[1] == 3) ? 4 : 3; /* silly way to know vertex count of face */
+               corners = multires_mdisp_corners(s);
+               cornersize = s->totdisp / corners;
 
-               if (corners!=nverts) {
+               if (corners != nverts) {
                        /* happens when face changed vertex count in edit mode
                         * if it happened, just forgot displacement */
 
                        MEM_freeN(s->disps);
-                       s->totdisp= (s->totdisp/corners)*nverts;
-                       s->disps= MEM_callocN(s->totdisp*sizeof(float)*3, "mdisp swap");
+                       s->totdisp = (s->totdisp / corners) * nverts;
+                       s->disps = MEM_callocN(s->totdisp * sizeof(float) * 3, "mdisp swap");
                        return;
                }
 
-               d= MEM_callocN(sizeof(float) * 3 * s->totdisp, "mdisps swap");
+               d = MEM_callocN(sizeof(float) * 3 * s->totdisp, "mdisps swap");
 
                for (S = 0; S < corners; S++)
-                       memcpy(d + cornersize*S, s->disps + cornersize*ci[S], cornersize*3*sizeof(float));
+                       memcpy(d + cornersize * S, s->disps + cornersize * ci[S], cornersize * 3 * sizeof(float));
                
                MEM_freeN(s->disps);
-               s->disps= d;
+               s->disps = d;
        }
 }
 
@@ -527,9 +525,9 @@ static int layerRead_mdisps(CDataFile *cdf, void *data, int count)
 
        for (i = 0; i < count; ++i) {
                if (!d[i].disps)
-                       d[i].disps = MEM_callocN(sizeof(float)*3*d[i].totdisp, "mdisps read");
+                       d[i].disps = MEM_callocN(sizeof(float) * 3 * d[i].totdisp, "mdisps read");
 
-               if (!cdf_read_data(cdf, d[i].totdisp*3*sizeof(float), d[i].disps)) {
+               if (!cdf_read_data(cdf, d[i].totdisp * 3 * sizeof(float), d[i].disps)) {
                        printf("failed to read multires displacement %d/%d %d\n", i, count, d[i].totdisp);
                        return 0;
                }
@@ -544,7 +542,7 @@ static int layerWrite_mdisps(CDataFile *cdf, void *data, int count)
        int i;
 
        for (i = 0; i < count; ++i) {
-               if (!cdf_write_data(cdf, d[i].totdisp*3*sizeof(float), d[i].disps)) {
+               if (!cdf_write_data(cdf, d[i].totdisp * 3 * sizeof(float), d[i].disps)) {
                        printf("failed to write multires displacement %d/%d %d\n", i, count, d[i].totdisp);
                        return 0;
                }
@@ -560,11 +558,43 @@ static size_t layerFilesize_mdisps(CDataFile *UNUSED(cdf), void *data, int count
        int i;
 
        for (i = 0; i < count; ++i)
-               size += d[i].totdisp*3*sizeof(float);
+               size += d[i].totdisp * 3 * sizeof(float);
 
        return size;
 }
 
+static void layerCopy_grid_paint_mask(const void *source, void *dest, int count)
+{
+       int i;
+       const GridPaintMask *s = source;
+       GridPaintMask *d = dest;
+
+       for (i = 0; i < count; ++i) {
+               if (s[i].data) {
+                       d[i].data = MEM_dupallocN(s[i].data);
+                       d[i].level = s[i].level;
+               }
+               else {
+                       d[i].data = NULL;
+                       d[i].level = 0;
+               }
+               
+       }
+}
+
+static void layerFree_grid_paint_mask(void *data, int count, int UNUSED(size))
+{
+       int i;
+       GridPaintMask *gpm = data;
+
+       for (i = 0; i < count; ++i) {
+               if (gpm[i].data)
+                       MEM_freeN(gpm[i].data);
+               gpm[i].data = NULL;
+               gpm[i].level = 0;
+       }
+}
+
 /* --------- */
 static void layerCopyValue_mloopcol(void *source, void *dest)
 {
@@ -586,7 +616,7 @@ static int layerEqual_mloopcol(void *data1, void *data2)
        b = m1->b - m2->b;
        a = m1->a - m2->a;
 
-       return r*r + g*g + b*b + a*a < 0.001;
+       return r * r + g * g + b * b + a * a < 0.001f;
 }
 
 static void layerMultiply_mloopcol(void *data, float fac)
@@ -643,7 +673,7 @@ static void layerInitMinMax_mloopcol(void *vmin, void *vmax)
 static void layerDefault_mloopcol(void *data, int count)
 {
        MLoopCol default_mloopcol = {255, 255, 255, 255};
-       MLoopCol *mlcol = (MLoopCol*)data;
+       MLoopCol *mlcol = (MLoopCol *)data;
        int i;
        for (i = 0; i < count; i++)
                mlcol[i] = default_mloopcol;
@@ -651,7 +681,7 @@ static void layerDefault_mloopcol(void *data, int count)
 }
 
 static void layerInterp_mloopcol(void **sources, float *weights,
-                               float *sub_weights, int count, void *dest)
+                                 float *sub_weights, int count, void *dest)
 {
        MLoopCol *mc = dest;
        int i;
@@ -742,7 +772,7 @@ static void layerInterp_mloopuv(void **sources, float *weights,
                                 float *sub_weights, int count, void *dest)
 {
        MLoopUV *mluv = dest;
-       float *uv= mluv->uv;
+       float *uv = mluv->uv;
        int i;
 
        zero_v2(uv);
@@ -809,10 +839,10 @@ static void layerAdd_mloop_origspace(void *data1, void *data2)
 }
 
 static void layerInterp_mloop_origspace(void **sources, float *weights,
-                                float *sub_weights, int count, void *dest)
+                                        float *sub_weights, int count, void *dest)
 {
        OrigSpaceLoop *mluv = dest;
-       float *uv= mluv->uv;
+       float *uv = mluv->uv;
        int i;
 
        zero_v2(uv);
@@ -837,7 +867,7 @@ static void layerInterp_mloop_origspace(void **sources, float *weights,
 /* --- end copy */
 
 static void layerInterp_mcol(void **sources, float *weights,
-                                                        float *sub_weights, int count, void *dest)
+                             float *sub_weights, int count, void *dest)
 {
        MCol *mc = dest;
        int i, j, k;
@@ -860,7 +890,7 @@ static void layerInterp_mcol(void **sources, float *weights,
                        if (sub_weights) {
                                MCol *src = sources[i];
                                for (k = 0; k < 4; ++k, ++sub_weight, ++src) {
-                                       const float w= (*sub_weight) * weight;
+                                       const float w = (*sub_weight) * weight;
                                        col[j].a += src->a * w;
                                        col[j].r += src->r * w;
                                        col[j].g += src->g * w;
@@ -908,10 +938,10 @@ static void layerSwap_mcol(void *data, const int *corner_indices)
 static void layerDefault_mcol(void *data, int count)
 {
        static MCol default_mcol = {255, 255, 255, 255};
-       MCol *mcol = (MCol*)data;
+       MCol *mcol = (MCol *)data;
        int i;
 
-       for (i = 0; i < 4*count; i++) {
+       for (i = 0; i < 4 * count; i++) {
                mcol[i] = default_mcol;
        }
 }
@@ -962,6 +992,38 @@ static void layerInterp_shapekey(void **sources, float *weights,
        }
 }
 
+static void layerDefault_mvert_skin(void *data, int count)
+{
+       MVertSkin *vs = data;
+       int i;
+       
+       for (i = 0; i < count; i++) {
+               copy_v3_fl(vs[i].radius, 0.25f);
+               vs[i].flag = 0;
+       }
+}
+
+static void layerInterp_mvert_skin(void **sources, float *weights,
+                                   float *UNUSED(sub_weights),
+                                   int count, void *dest)
+{
+       float radius[3], w;
+       MVertSkin *vs;
+       int i;
+
+       zero_v3(radius);
+       for (i = 0; i < count; i++) {
+               w = weights ? weights[i] : 1.0f;
+               vs = sources[i];
+
+               madd_v3_v3fl(radius, vs->radius, w);
+       }
+
+       vs = dest;
+       copy_v3_v3(vs->radius, radius);
+       vs->flag &= ~MVERT_SKIN_ROOT;
+}
+
 static const LayerTypeInfo LAYERTYPEINFO[CD_NUMTYPES] = {
        /* 0: CD_MVERT */
        {sizeof(MVert), "MVert", 1, NULL, NULL, NULL, NULL, NULL, NULL},
@@ -980,13 +1042,13 @@ static const LayerTypeInfo LAYERTYPEINFO[CD_NUMTYPES] = {
         layerInterp_tface, layerSwap_tface, layerDefault_tface},
        /* 6: CD_MCOL */
        /* 4 MCol structs per face */
-       {sizeof(MCol)*4, "MCol", 4, "Col", NULL, NULL, layerInterp_mcol,
+       {sizeof(MCol) * 4, "MCol", 4, "Col", NULL, NULL, layerInterp_mcol,
         layerSwap_mcol, layerDefault_mcol},
        /* 7: CD_ORIGINDEX */
        {sizeof(int), "", 0, NULL, NULL, NULL, NULL, NULL, NULL},
        /* 8: CD_NORMAL */
        /* 3 floats per normal vector */
-       {sizeof(float)*3, "vec3f", 1, NULL, NULL, NULL, NULL, NULL, NULL},
+       {sizeof(float) * 3, "vec3f", 1, NULL, NULL, NULL, NULL, NULL, NULL},
        /* 9: CD_POLYINDEX */
        {sizeof(int), "MIntProperty", 1, NULL, NULL, NULL, NULL, NULL, NULL},
        /* 10: CD_PROP_FLT */
@@ -999,10 +1061,10 @@ static const LayerTypeInfo LAYERTYPEINFO[CD_NUMTYPES] = {
        {sizeof(OrigSpaceFace), "OrigSpaceFace", 1, "UVMap", layerCopy_origspace_face, NULL,
         layerInterp_origspace_face, layerSwap_origspace_face, layerDefault_origspace_face},
        /* 14: CD_ORCO */
-       {sizeof(float)*3, "", 0, NULL, NULL, NULL, NULL, NULL, NULL},
+       {sizeof(float) * 3, "", 0, NULL, NULL, NULL, NULL, NULL, NULL},
        /* 15: CD_MTEXPOLY */
        /* note, when we expose the UV Map / TexFace split to the user, change this back to face Texture */
-       {sizeof(MTexPoly), "MTexPoly", 1, "UVMap"/* "Face Texture" */, NULL, NULL, NULL, NULL, NULL},
+       {sizeof(MTexPoly), "MTexPoly", 1, "UVMap" /* "Face Texture" */, NULL, NULL, NULL, NULL, NULL},
        /* 16: CD_MLOOPUV */
        {sizeof(MLoopUV), "MLoopUV", 1, "UV coord", NULL, NULL, layerInterp_mloopuv, NULL, NULL,
         layerEqual_mloopuv, layerMultiply_mloopuv, layerInitMinMax_mloopuv, 
@@ -1012,28 +1074,27 @@ static const LayerTypeInfo LAYERTYPEINFO[CD_NUMTYPES] = {
         layerDefault_mloopcol, layerEqual_mloopcol, layerMultiply_mloopcol, layerInitMinMax_mloopcol, 
         layerAdd_mloopcol, layerDoMinMax_mloopcol, layerCopyValue_mloopcol},
        /* 18: CD_TANGENT */
-       {sizeof(float)*4*4, "", 0, NULL, NULL, NULL, NULL, NULL, NULL},
+       {sizeof(float) * 4 * 4, "", 0, NULL, NULL, NULL, NULL, NULL, NULL},
        /* 19: CD_MDISPS */
        {sizeof(MDisps), "MDisps", 1, NULL, layerCopy_mdisps,
         layerFree_mdisps, NULL, layerSwap_mdisps, NULL,
         NULL, NULL, NULL, NULL, NULL, NULL, 
         layerRead_mdisps, layerWrite_mdisps, layerFilesize_mdisps},
        /* 20: CD_PREVIEW_MCOL */
-       {sizeof(MCol)*4, "MCol", 4, "PreviewCol", NULL, NULL, layerInterp_mcol,
+       {sizeof(MCol) * 4, "MCol", 4, "PreviewCol", NULL, NULL, layerInterp_mcol,
         layerSwap_mcol, layerDefault_mcol},
        /* 21: CD_ID_MCOL */
-       {sizeof(MCol)*4, "MCol", 4, "IDCol", NULL, NULL, layerInterp_mcol,
+       {sizeof(MCol) * 4, "MCol", 4, "IDCol", NULL, NULL, layerInterp_mcol,
         layerSwap_mcol, layerDefault_mcol},
        /* 22: CD_TEXTURE_MCOL */
-       {sizeof(MCol)*4, "MCol", 4, "TexturedCol", NULL, NULL, layerInterp_mcol,
+       {sizeof(MCol) * 4, "MCol", 4, "TexturedCol", NULL, NULL, layerInterp_mcol,
         layerSwap_mcol, layerDefault_mcol},
        /* 23: CD_CLOTH_ORCO */
-       {sizeof(float)*3, "", 0, NULL, NULL, NULL, NULL, NULL, NULL},
+       {sizeof(float) * 3, "", 0, NULL, NULL, NULL, NULL, NULL, NULL},
        /* 24: CD_RECAST */
-       {sizeof(MRecast), "MRecast", 1, "Recast", NULL, NULL, NULL, NULL}
+       {sizeof(MRecast), "MRecast", 1, "Recast", NULL, NULL, NULL, NULL},
 
 /* BMESH ONLY */
-       ,
        /* 25: CD_MPOLY */
        {sizeof(MPoly), "MPoly", 1, "NGon Face", NULL, NULL, NULL, NULL, NULL},
        /* 26: CD_MLOOP */
@@ -1041,7 +1102,7 @@ static const LayerTypeInfo LAYERTYPEINFO[CD_NUMTYPES] = {
        /* 27: CD_SHAPE_KEYINDEX */
        {sizeof(int), "", 0, NULL, NULL, NULL, NULL, NULL, NULL},
        /* 28: CD_SHAPEKEY */
-       {sizeof(float)*3, "", 0, "ShapeKey", NULL, NULL, layerInterp_shapekey},
+       {sizeof(float) * 3, "", 0, "ShapeKey", NULL, NULL, layerInterp_shapekey},
        /* 29: CD_BWEIGHT */
        {sizeof(float), "", 0, "BevelWeight", NULL, NULL, layerInterp_bweight},
        /* 30: CD_CREASE */
@@ -1060,7 +1121,14 @@ static const LayerTypeInfo LAYERTYPEINFO[CD_NUMTYPES] = {
 
 /* END BMESH ONLY */
 
-
+       /* 34: CD_PAINT_MASK */
+       {sizeof(float), "", 0, NULL, NULL, NULL, NULL, NULL, NULL},
+       /* 35: CD_GRID_PAINT_MASK */
+       {sizeof(GridPaintMask), "GridPaintMask", 1, NULL, layerCopy_grid_paint_mask,
+        layerFree_grid_paint_mask, NULL, NULL, NULL},
+       /* 36: CD_SKIN_NODE */
+       {sizeof(MVertSkin), "MVertSkin", 1, "Skin", NULL, NULL,
+        layerInterp_mvert_skin, NULL, layerDefault_mvert_skin}
 };
 
 /* note, numbers are from trunk and need updating for bmesh */
@@ -1070,43 +1138,46 @@ static const char *LAYERTYPENAMES[CD_NUMTYPES] = {
        /*   5-9 */ "CDMTFace", "CDMCol", "CDOrigIndex", "CDNormal", "CDFlags",
        /* 10-14 */ "CDMFloatProperty", "CDMIntProperty", "CDMStringProperty", "CDOrigSpace", "CDOrco",
        /* 15-19 */ "CDMTexPoly", "CDMLoopUV", "CDMloopCol", "CDTangent", "CDMDisps",
-       /* 20-24 */"CDPreviewMCol", "CDIDMCol", "CDTextureMCol", "CDClothOrco", "CDMRecast"
+       /* 20-24 */ "CDPreviewMCol", "CDIDMCol", "CDTextureMCol", "CDClothOrco", "CDMRecast",
 
 /* BMESH ONLY */
-       ,
        /* 25-29 */ "CDMPoly", "CDMLoop", "CDShapeKeyIndex", "CDShapeKey", "CDBevelWeight",
-       /* 30-32 */ "CDSubSurfCrease", "CDOrigSpaceLoop", "CDPreviewLoopCol"
-/* END BMESH ONLY */
-
+       /* 30-34 */ "CDSubSurfCrease", "CDOrigSpaceLoop", "CDPreviewLoopCol", "CDBMElemPyPtr", "CDPaintMask",
+       /* 35-36 */ "CDGridPaintMask", "CDMVertSkin"
 };
 
 
 const CustomDataMask CD_MASK_BAREMESH =
-       CD_MASK_MVERT | CD_MASK_MEDGE | CD_MASK_MFACE | CD_MASK_MLOOP | CD_MASK_MPOLY | CD_MASK_BWEIGHT;
+    CD_MASK_MVERT | CD_MASK_MEDGE | CD_MASK_MFACE | CD_MASK_MLOOP | CD_MASK_MPOLY | CD_MASK_BWEIGHT;
 const CustomDataMask CD_MASK_MESH =
-       CD_MASK_MVERT | CD_MASK_MEDGE | CD_MASK_MFACE |
-       CD_MASK_MSTICKY | CD_MASK_MDEFORMVERT | CD_MASK_MTFACE | CD_MASK_MCOL |
-       CD_MASK_PROP_FLT | CD_MASK_PROP_INT | CD_MASK_PROP_STR | CD_MASK_MDISPS |
-       CD_MASK_MLOOPUV | CD_MASK_MLOOPCOL | CD_MASK_MPOLY | CD_MASK_MLOOP |
-       CD_MASK_MTEXPOLY | CD_MASK_NORMAL | CD_MASK_RECAST;
+    CD_MASK_MVERT | CD_MASK_MEDGE | CD_MASK_MFACE |
+    CD_MASK_MSTICKY | CD_MASK_MDEFORMVERT | CD_MASK_MTFACE | CD_MASK_MCOL |
+    CD_MASK_PROP_FLT | CD_MASK_PROP_INT | CD_MASK_PROP_STR | CD_MASK_MDISPS |
+    CD_MASK_MLOOPUV | CD_MASK_MLOOPCOL | CD_MASK_MPOLY | CD_MASK_MLOOP |
+    CD_MASK_MTEXPOLY | CD_MASK_NORMAL | CD_MASK_RECAST | CD_MASK_PAINT_MASK |
+    CD_MASK_GRID_PAINT_MASK | CD_MASK_MVERT_SKIN;
 const CustomDataMask CD_MASK_EDITMESH =
-       CD_MASK_MSTICKY | CD_MASK_MDEFORMVERT | CD_MASK_MTFACE | CD_MASK_MLOOPUV |
-       CD_MASK_MLOOPCOL | CD_MASK_MTEXPOLY | CD_MASK_SHAPE_KEYINDEX |
-       CD_MASK_MCOL|CD_MASK_PROP_FLT | CD_MASK_PROP_INT | CD_MASK_PROP_STR |
-       CD_MASK_MDISPS | CD_MASK_SHAPEKEY | CD_MASK_RECAST;
+    CD_MASK_MSTICKY | CD_MASK_MDEFORMVERT | CD_MASK_MTFACE | CD_MASK_MLOOPUV |
+    CD_MASK_MLOOPCOL | CD_MASK_MTEXPOLY | CD_MASK_SHAPE_KEYINDEX |
+    CD_MASK_MCOL | CD_MASK_PROP_FLT | CD_MASK_PROP_INT | CD_MASK_PROP_STR |
+    CD_MASK_MDISPS | CD_MASK_SHAPEKEY | CD_MASK_RECAST | CD_MASK_PAINT_MASK |
+    CD_MASK_GRID_PAINT_MASK | CD_MASK_MVERT_SKIN;
 const CustomDataMask CD_MASK_DERIVEDMESH =
-       CD_MASK_MSTICKY | CD_MASK_MDEFORMVERT | CD_MASK_MTFACE |
-       CD_MASK_MCOL | CD_MASK_PROP_FLT | CD_MASK_PROP_INT | CD_MASK_CLOTH_ORCO |
-       CD_MASK_MLOOPUV | CD_MASK_MLOOPCOL | CD_MASK_MTEXPOLY | CD_MASK_PREVIEW_MLOOPCOL |
-       CD_MASK_PROP_STR | CD_MASK_ORIGSPACE | CD_MASK_ORIGSPACE_MLOOP | CD_MASK_ORCO | CD_MASK_TANGENT |
-       CD_MASK_PREVIEW_MCOL | CD_MASK_NORMAL | CD_MASK_SHAPEKEY | CD_MASK_RECAST |
-       CD_MASK_ORIGINDEX | CD_MASK_POLYINDEX;
-const CustomDataMask CD_MASK_BMESH = CD_MASK_MLOOPUV | CD_MASK_MLOOPCOL | CD_MASK_MTEXPOLY |
-       CD_MASK_MSTICKY | CD_MASK_MDEFORMVERT | CD_MASK_PROP_FLT | CD_MASK_PROP_INT | 
-       CD_MASK_PROP_STR | CD_MASK_SHAPEKEY | CD_MASK_SHAPE_KEYINDEX | CD_MASK_MDISPS | CD_MASK_CREASE | CD_MASK_BWEIGHT | CD_MASK_RECAST;
+    CD_MASK_MSTICKY | CD_MASK_MDEFORMVERT | CD_MASK_MTFACE |
+    CD_MASK_MCOL | CD_MASK_PROP_FLT | CD_MASK_PROP_INT | CD_MASK_CLOTH_ORCO |
+    CD_MASK_MLOOPUV | CD_MASK_MLOOPCOL | CD_MASK_MTEXPOLY | CD_MASK_PREVIEW_MLOOPCOL |
+    CD_MASK_PROP_STR | CD_MASK_ORIGSPACE | CD_MASK_ORIGSPACE_MLOOP | CD_MASK_ORCO | CD_MASK_TANGENT |
+    CD_MASK_PREVIEW_MCOL | CD_MASK_NORMAL | CD_MASK_SHAPEKEY | CD_MASK_RECAST |
+    CD_MASK_ORIGINDEX | CD_MASK_POLYINDEX | CD_MASK_MVERT_SKIN;
+const CustomDataMask CD_MASK_BMESH =
+    CD_MASK_MLOOPUV | CD_MASK_MLOOPCOL | CD_MASK_MTEXPOLY |
+    CD_MASK_MSTICKY | CD_MASK_MDEFORMVERT | CD_MASK_PROP_FLT | CD_MASK_PROP_INT |
+    CD_MASK_PROP_STR | CD_MASK_SHAPEKEY | CD_MASK_SHAPE_KEYINDEX | CD_MASK_MDISPS |
+    CD_MASK_CREASE | CD_MASK_BWEIGHT | CD_MASK_RECAST | CD_MASK_PAINT_MASK |
+    CD_MASK_GRID_PAINT_MASK | CD_MASK_MVERT_SKIN;
 const CustomDataMask CD_MASK_FACECORNERS =
-       CD_MASK_MTFACE | CD_MASK_MCOL | CD_MASK_MTEXPOLY | CD_MASK_MLOOPUV |
-       CD_MASK_MLOOPCOL;
+    CD_MASK_MTFACE | CD_MASK_MCOL | CD_MASK_MTEXPOLY | CD_MASK_MLOOPUV |
+    CD_MASK_MLOOPCOL;
 
 static const LayerTypeInfo *layerType_getInfo(int type)
 {
@@ -1122,11 +1193,23 @@ static const char *layerType_getName(int type)
        return LAYERTYPENAMES[type];
 }
 
+void customData_mask_layers__print(CustomDataMask mask)
+{
+       int i;
+
+       printf("mask=0x%lx:\n", (long unsigned int)mask);
+       for (i = 0; i < CD_NUMTYPES; i++) {
+               if (mask & CD_TYPE_AS_MASK(i)) {
+                       printf("  %s\n", layerType_getName(i));
+               }
+       }
+}
+
 /********************* CustomData functions *********************/
 static void customData_update_offsets(CustomData *data);
 
 static CustomDataLayer *customData_add_layer__internal(CustomData *data,
-       int type, int alloctype, void *layerdata, int totelem, const char *name);
+                                                       int type, int alloctype, void *layerdata, int totelem, const char *name);
 
 void CustomData_update_typemap(CustomData *data)
 {
@@ -1135,11 +1218,11 @@ void CustomData_update_typemap(CustomData *data)
        /* since we cant do in a pre-processor do here as an assert */
        BLI_assert(sizeof(data->typemap) / sizeof(int) >= CD_NUMTYPES);
 
-       for (i=0; i<CD_NUMTYPES; i++) {
+       for (i = 0; i < CD_NUMTYPES; i++) {
                data->typemap[i] = -1;
        }
 
-       for (i=0; i<data->totlayer; i++) {
+       for (i = 0; i < data->totlayer; i++) {
                if (data->layers[i].type != lasttype) {
                        data->typemap[data->layers[i].type] = i;
                }
@@ -1148,7 +1231,7 @@ void CustomData_update_typemap(CustomData *data)
 }
 
 void CustomData_merge(const struct CustomData *source, struct CustomData *dest,
-                                         CustomDataMask mask, int alloctype, int totelem)
+                      CustomDataMask mask, int alloctype, int totelem)
 {
        /*const LayerTypeInfo *typeInfo;*/
        CustomDataLayer *layer, *newlayer;
@@ -1190,10 +1273,10 @@ void CustomData_merge(const struct CustomData *source, struct CustomData *dest,
 
                if ((alloctype == CD_ASSIGN) && (lastflag & CD_FLAG_NOFREE))
                        newlayer = customData_add_layer__internal(dest, type, CD_REFERENCE,
-                               data, totelem, layer->name);
+                                                                 data, totelem, layer->name);
                else
                        newlayer = customData_add_layer__internal(dest, type, alloctype,
-                               data, totelem, layer->name);
+                                                                 data, totelem, layer->name);
                
                if (newlayer) {
                        newlayer->uid = layer->uid;
@@ -1202,7 +1285,7 @@ void CustomData_merge(const struct CustomData *source, struct CustomData *dest,
                        newlayer->active_rnd = lastrender;
                        newlayer->active_clone = lastclone;
                        newlayer->active_mask = lastmask;
-                       newlayer->flag |= lastflag & (CD_FLAG_EXTERNAL|CD_FLAG_IN_MEMORY);
+                       newlayer->flag |= lastflag & (CD_FLAG_EXTERNAL | CD_FLAG_IN_MEMORY);
                }
        }
 
@@ -1210,12 +1293,12 @@ void CustomData_merge(const struct CustomData *source, struct CustomData *dest,
 }
 
 void CustomData_copy(const struct CustomData *source, struct CustomData *dest,
-                                        CustomDataMask mask, int alloctype, int totelem)
+                     CustomDataMask mask, int alloctype, int totelem)
 {
        memset(dest, 0, sizeof(*dest));
 
        if (source->external)
-               dest->external= MEM_dupallocN(source->external);
+               dest->external = MEM_dupallocN(source->external);
 
        CustomData_merge(source, dest, mask, alloctype, totelem);
 }
@@ -1239,7 +1322,7 @@ static void CustomData_external_free(CustomData *data)
 {
        if (data->external) {
                MEM_freeN(data->external);
-               data->external= NULL;
+               data->external = NULL;
        }
 }
 
@@ -1278,7 +1361,7 @@ int CustomData_get_layer_index(const CustomData *data, int type)
 {
        int i; 
 
-       for (i=0; i < data->totlayer; ++i)
+       for (i = 0; i < data->totlayer; ++i)
                if (data->layers[i].type == type)
                        return i;
 
@@ -1300,8 +1383,8 @@ int CustomData_get_named_layer_index(const CustomData *data, int type, const cha
 {
        int i;
 
-       for (i=0; i < data->totlayer; ++i)
-               if (data->layers[i].type == type && strcmp(data->layers[i].name, name)==0)
+       for (i = 0; i < data->totlayer; ++i)
+               if (data->layers[i].type == type && strcmp(data->layers[i].name, name) == 0)
                        return i;
 
        return -1;
@@ -1323,7 +1406,7 @@ int CustomData_get_render_layer_index(const CustomData *data, int type)
 {
        int i;
 
-       for (i=0; i < data->totlayer; ++i)
+       for (i = 0; i < data->totlayer; ++i)
                if (data->layers[i].type == type)
                        return i + data->layers[i].active_rnd;
 
@@ -1334,7 +1417,7 @@ int CustomData_get_clone_layer_index(const CustomData *data, int type)
 {
        int i;
 
-       for (i=0; i < data->totlayer; ++i)
+       for (i = 0; i < data->totlayer; ++i)
                if (data->layers[i].type == type)
                        return i + data->layers[i].active_clone;
 
@@ -1345,7 +1428,7 @@ int CustomData_get_stencil_layer_index(const CustomData *data, int type)
 {
        int i;
 
-       for (i=0; i < data->totlayer; ++i)
+       for (i = 0; i < data->totlayer; ++i)
                if (data->layers[i].type == type)
                        return i + data->layers[i].active_mask;
 
@@ -1356,7 +1439,7 @@ int CustomData_get_active_layer(const CustomData *data, int type)
 {
        int i;
 
-       for (i=0; i < data->totlayer; ++i)
+       for (i = 0; i < data->totlayer; ++i)
                if (data->layers[i].type == type)
                        return data->layers[i].active;
 
@@ -1367,7 +1450,7 @@ int CustomData_get_render_layer(const CustomData *data, int type)
 {
        int i;
 
-       for (i=0; i < data->totlayer; ++i)
+       for (i = 0; i < data->totlayer; ++i)
                if (data->layers[i].type == type)
                        return data->layers[i].active_rnd;
 
@@ -1378,7 +1461,7 @@ int CustomData_get_clone_layer(const CustomData *data, int type)
 {
        int i;
 
-       for (i=0; i < data->totlayer; ++i)
+       for (i = 0; i < data->totlayer; ++i)
                if (data->layers[i].type == type)
                        return data->layers[i].active_clone;
 
@@ -1389,7 +1472,7 @@ int CustomData_get_stencil_layer(const CustomData *data, int type)
 {
        int i;
 
-       for (i=0; i < data->totlayer; ++i)
+       for (i = 0; i < data->totlayer; ++i)
                if (data->layers[i].type == type)
                        return data->layers[i].active_mask;
 
@@ -1400,7 +1483,7 @@ void CustomData_set_layer_active(CustomData *data, int type, int n)
 {
        int i;
 
-       for (i=0; i < data->totlayer; ++i)
+       for (i = 0; i < data->totlayer; ++i)
                if (data->layers[i].type == type)
                        data->layers[i].active = n;
 }
@@ -1409,7 +1492,7 @@ void CustomData_set_layer_render(CustomData *data, int type, int n)
 {
        int i;
 
-       for (i=0; i < data->totlayer; ++i)
+       for (i = 0; i < data->totlayer; ++i)
                if (data->layers[i].type == type)
                        data->layers[i].active_rnd = n;
 }
@@ -1418,7 +1501,7 @@ void CustomData_set_layer_clone(CustomData *data, int type, int n)
 {
        int i;
 
-       for (i=0; i < data->totlayer; ++i)
+       for (i = 0; i < data->totlayer; ++i)
                if (data->layers[i].type == type)
                        data->layers[i].active_clone = n;
 }
@@ -1427,7 +1510,7 @@ void CustomData_set_layer_stencil(CustomData *data, int type, int n)
 {
        int i;
 
-       for (i=0; i < data->totlayer; ++i)
+       for (i = 0; i < data->totlayer; ++i)
                if (data->layers[i].type == type)
                        data->layers[i].active_mask = n;
 }
@@ -1437,51 +1520,51 @@ void CustomData_set_layer_active_index(CustomData *data, int type, int n)
 {
        int i;
 
-       for (i=0; i < data->totlayer; ++i)
+       for (i = 0; i < data->totlayer; ++i)
                if (data->layers[i].type == type)
-                       data->layers[i].active = n-i;
+                       data->layers[i].active = n - i;
 }
 
 void CustomData_set_layer_render_index(CustomData *data, int type, int n)
 {
        int i;
 
-       for (i=0; i < data->totlayer; ++i)
+       for (i = 0; i < data->totlayer; ++i)
                if (data->layers[i].type == type)
-                       data->layers[i].active_rnd = n-i;
+                       data->layers[i].active_rnd = n - i;
 }
 
 void CustomData_set_layer_clone_index(CustomData *data, int type, int n)
 {
        int i;
 
-       for (i=0; i < data->totlayer; ++i)
+       for (i = 0; i < data->totlayer; ++i)
                if (data->layers[i].type == type)
-                       data->layers[i].active_clone = n-i;
+                       data->layers[i].active_clone = n - i;
 }
 
 void CustomData_set_layer_stencil_index(CustomData *data, int type, int n)
 {
        int i;
 
-       for (i=0; i < data->totlayer; ++i)
+       for (i = 0; i < data->totlayer; ++i)
                if (data->layers[i].type == type)
-                       data->layers[i].active_mask = n-i;
+                       data->layers[i].active_mask = n - i;
 }
 
 void CustomData_set_layer_flag(struct CustomData *data, int type, int flag)
 {
        int i;
 
-       for (i=0; i < data->totlayer; ++i)
+       for (i = 0; i < data->totlayer; ++i)
                if (data->layers[i].type == type)
                        data->layers[i].flag |= flag;
 }
 
 static int customData_resize(CustomData *data, int amount)
 {
-       CustomDataLayer *tmp = MEM_callocN(sizeof(*tmp)*(data->maxlayer + amount),
-                                                                          "CustomData->layers");
+       CustomDataLayer *tmp = MEM_callocN(sizeof(*tmp) * (data->maxlayer + amount),
+                                          "CustomData->layers");
        if (!tmp) return 0;
 
        data->maxlayer += amount;
@@ -1495,9 +1578,9 @@ static int customData_resize(CustomData *data, int amount)
 }
 
 static CustomDataLayer *customData_add_layer__internal(CustomData *data,
-       int type, int alloctype, void *layerdata, int totelem, const char *name)
+                                                       int type, int alloctype, void *layerdata, int totelem, const char *name)
 {
-       const LayerTypeInfo *typeInfo= layerType_getInfo(type);
+       const LayerTypeInfo *typeInfo = layerType_getInfo(type);
        int size = typeInfo->size * totelem, flag = 0, index = data->totlayer;
        void *newlayerdata = NULL;
 
@@ -1528,7 +1611,7 @@ static CustomDataLayer *customData_add_layer__internal(CustomData *data,
        }
        else if (alloctype == CD_DEFAULT) {
                if (typeInfo->set_default)
-                       typeInfo->set_default((char*)newlayerdata, totelem);
+                       typeInfo->set_default((char *)newlayerdata, totelem);
        }
        else if (alloctype == CD_REFERENCE)
                flag |= CD_FLAG_NOFREE;
@@ -1544,25 +1627,25 @@ static CustomDataLayer *customData_add_layer__internal(CustomData *data,
        data->totlayer++;
 
        /* keep layers ordered by type */
-       for ( ; index > 0 && data->layers[index - 1].type > type; --index)
+       for (; index > 0 && data->layers[index - 1].type > type; --index)
                data->layers[index] = data->layers[index - 1];
 
        data->layers[index].type = type;
        data->layers[index].flag = flag;
        data->layers[index].data = newlayerdata;
 
-       if (name || (name=typeInfo->defaultname)) {
+       if (name || (name = typeInfo->defaultname)) {
                BLI_strncpy(data->layers[index].name, name, sizeof(data->layers[index].name));
                CustomData_set_layer_unique_name(data, index);
        }
        else
                data->layers[index].name[0] = '\0';
 
-       if (index > 0 && data->layers[index-1].type == type) {
-               data->layers[index].active = data->layers[index-1].active;
-               data->layers[index].active_rnd = data->layers[index-1].active_rnd;
-               data->layers[index].active_clone = data->layers[index-1].active_clone;
-               data->layers[index].active_mask = data->layers[index-1].active_mask;
+       if (index > 0 && data->layers[index - 1].type == type) {
+               data->layers[index].active = data->layers[index - 1].active;
+               data->layers[index].active_rnd = data->layers[index - 1].active_rnd;
+               data->layers[index].active_clone = data->layers[index - 1].active_clone;
+               data->layers[index].active_mask = data->layers[index - 1].active_mask;
        }
        else {
                data->layers[index].active = 0;
@@ -1577,13 +1660,13 @@ static CustomDataLayer *customData_add_layer__internal(CustomData *data,
 }
 
 void *CustomData_add_layer(CustomData *data, int type, int alloctype,
-                                                  void *layerdata, int totelem)
+                           void *layerdata, int totelem)
 {
        CustomDataLayer *layer;
-       const LayerTypeInfo *typeInfo= layerType_getInfo(type);
+       const LayerTypeInfo *typeInfo = layerType_getInfo(type);
        
        layer = customData_add_layer__internal(data, type, alloctype, layerdata,
-                                                                                  totelem, typeInfo->defaultname);
+                                              totelem, typeInfo->defaultname);
        CustomData_update_typemap(data);
 
        if (layer)
@@ -1594,12 +1677,12 @@ void *CustomData_add_layer(CustomData *data, int type, int alloctype,
 
 /*same as above but accepts a name*/
 void *CustomData_add_layer_named(CustomData *data, int type, int alloctype,
-                                                  void *layerdata, int totelem, const char *name)
+                                 void *layerdata, int totelem, const char *name)
 {
        CustomDataLayer *layer;
        
        layer = customData_add_layer__internal(data, type, alloctype, layerdata,
-                                                                                  totelem, name);
+                                              totelem, name);
        CustomData_update_typemap(data);
 
        if (layer)
@@ -1617,8 +1700,8 @@ int CustomData_free_layer(CustomData *data, int type, int totelem, int index)
 
        customData_free_layer__internal(&data->layers[index], totelem);
 
-       for (i=index+1; i < data->totlayer; ++i)
-               data->layers[i-1] = data->layers[i];
+       for (i = index + 1; i < data->totlayer; ++i)
+               data->layers[i - 1] = data->layers[i];
 
        data->totlayer--;
 
@@ -1635,7 +1718,7 @@ int CustomData_free_layer(CustomData *data, int type, int totelem, int index)
                        }
        }
 
-       if (data->totlayer <= data->maxlayer-CUSTOMDATA_GROW)
+       if (data->totlayer <= data->maxlayer - CUSTOMDATA_GROW)
                customData_resize(data, -CUSTOMDATA_GROW);
 
        customData_update_offsets(data);
@@ -1708,7 +1791,7 @@ void *CustomData_duplicate_referenced_layer(struct CustomData *data, const int t
 }
 
 void *CustomData_duplicate_referenced_layer_named(struct CustomData *data,
-                                                                                                 const int type, const char *name, const int totelem)
+                                                  const int type, const char *name, const int totelem)
 {
        CustomDataLayer *layer;
        int layer_index;
@@ -1773,7 +1856,7 @@ void CustomData_free_temporary(CustomData *data, int totelem)
 
        data->totlayer = j;
 
-       if (data->totlayer <= data->maxlayer-CUSTOMDATA_GROW)
+       if (data->totlayer <= data->maxlayer - CUSTOMDATA_GROW)
                customData_resize(data, -CUSTOMDATA_GROW);
 
        customData_update_offsets(data);
@@ -1796,11 +1879,11 @@ void CustomData_copy_elements(int type, void *source, void *dest, int count)
        if (typeInfo->copy)
                typeInfo->copy(source, dest, count);
        else
-               memcpy(dest, source, typeInfo->size*count);
+               memcpy(dest, source, typeInfo->size * count);
 }
 
 void CustomData_copy_data(const CustomData *source, CustomData *dest,
-                                                 int source_index, int dest_index, int count)
+                          int source_index, int dest_index, int count)
 {
        const LayerTypeInfo *typeInfo;
        int src_i, dest_i;
@@ -1842,12 +1925,12 @@ void CustomData_copy_data(const CustomData *source, CustomData *dest,
                        
                        if (typeInfo->copy)
                                typeInfo->copy(src_data + src_offset,
-                                                               dest_data + dest_offset,
-                                                               count);
+                                              dest_data + dest_offset,
+                                              count);
                        else
                                memcpy(dest_data + dest_offset,
-                                          src_data + src_offset,
-                                          count * typeInfo->size);
+                                      src_data + src_offset,
+                                      count * typeInfo->size);
 
                        /* if there are multiple source & dest layers of the same type,
                         * we don't want to copy all source layers to the same dest, so
@@ -1871,7 +1954,7 @@ void CustomData_free_elem(CustomData *data, int index, int count)
                                int offset = typeInfo->size * index;
 
                                typeInfo->free((char *)data->layers[i].data + offset,
-                                                          count, typeInfo->size);
+                                              count, typeInfo->size);
                        }
                }
        }
@@ -1880,8 +1963,8 @@ void CustomData_free_elem(CustomData *data, int index, int count)
 #define SOURCE_BUF_SIZE 100
 
 void CustomData_interp(const CustomData *source, CustomData *dest,
-                                          int *src_indices, float *weights, float *sub_weights,
-                                          int count, int dest_index)
+                       int *src_indices, float *weights, float *sub_weights,
+                       int count, int dest_index)
 {
        int src_i, dest_i;
        int dest_offset;
@@ -1894,12 +1977,12 @@ void CustomData_interp(const CustomData *source, CustomData *dest,
         */
        if (count > SOURCE_BUF_SIZE)
                sources = MEM_callocN(sizeof(*sources) * count,
-                                                         "CustomData_interp sources");
+                                     "CustomData_interp sources");
 
        /* interpolates a layer at a time */
        dest_i = 0;
        for (src_i = 0; src_i < source->totlayer; ++src_i) {
-               const LayerTypeInfo *typeInfo= layerType_getInfo(source->layers[src_i].type);
+               const LayerTypeInfo *typeInfo = layerType_getInfo(source->layers[src_i].type);
                if (!typeInfo->interp) continue;
 
                /* find the first dest layer with type >= the source type
@@ -1917,13 +2000,12 @@ void CustomData_interp(const CustomData *source, CustomData *dest,
                        void *src_data = source->layers[src_i].data;
 
                        for (j = 0; j < count; ++j)
-                               sources[j] = (char *)src_data
-                                                        + typeInfo->size * src_indices[j];
+                               sources[j] = (char *)src_data + typeInfo->size * src_indices[j];
 
                        dest_offset = dest_index * typeInfo->size;
 
                        typeInfo->interp(sources, weights, sub_weights, count,
-                                                  (char *)dest->layers[dest_i].data + dest_offset);
+                                        (char *)dest->layers[dest_i].data + dest_offset);
 
                        /* if there are multiple source & dest layers of the same type,
                         * we don't want to copy all source layers to the same dest, so
@@ -1977,7 +2059,7 @@ void *CustomData_get_n(const CustomData *data, int type, int index, int n)
        if (layer_index < 0) return NULL;
 
        offset = layerType_getInfo(type)->size * index;
-       return (char *)data->layers[layer_index+n].data + offset;
+       return (char *)data->layers[layer_index + n].data + offset;
 }
 
 void *CustomData_get_layer(const CustomData *data, int type)
@@ -1999,7 +2081,7 @@ void *CustomData_get_layer_n(const CustomData *data, int type, int n)
 }
 
 void *CustomData_get_layer_named(const struct CustomData *data, int type,
-                                                                const char *name)
+                                 const char *name)
 {
        int layer_index = CustomData_get_named_layer_index(data, type, name);
        if (layer_index < 0) return NULL;
@@ -2063,7 +2145,7 @@ void CustomData_to_bmeshpoly(CustomData *fdata, CustomData *pdata, CustomData *l
                              int totloop, int totpoly)
 {
        int i;
-       for (i=0; i < fdata->totlayer; i++) {
+       for (i = 0; i < fdata->totlayer; i++) {
                if (fdata->layers[i].type == CD_MTFACE) {
                        CustomData_add_layer_named(pdata, CD_MTEXPOLY, CD_CALLOC, NULL, totpoly, fdata->layers[i].name);
                        CustomData_add_layer_named(ldata, CD_MLOOPUV, CD_CALLOC, NULL, totloop, fdata->layers[i].name);
@@ -2080,12 +2162,12 @@ void CustomData_to_bmeshpoly(CustomData *fdata, CustomData *pdata, CustomData *l
 void CustomData_from_bmeshpoly(CustomData *fdata, CustomData *pdata, CustomData *ldata, int total)
 {
        int i;
-       for (i=0; i < pdata->totlayer; i++) {
+       for (i = 0; i < pdata->totlayer; i++) {
                if (pdata->layers[i].type == CD_MTEXPOLY) {
                        CustomData_add_layer_named(fdata, CD_MTFACE, CD_CALLOC, NULL, total, pdata->layers[i].name);
                }
        }
-       for (i=0; i < ldata->totlayer; i++) {
+       for (i = 0; i < ldata->totlayer; i++) {
                if (ldata->layers[i].type == CD_MLOOPCOL) {
                        CustomData_add_layer_named(fdata, CD_MCOL, CD_CALLOC, NULL, total, ldata->layers[i].name);
                }
@@ -2137,6 +2219,48 @@ void CustomData_bmesh_update_active_layers(CustomData *fdata, CustomData *pdata,
        }
 }
 
+/* update active indices for active/render/clone/stencil custom data layers
+ * based on indices from fdata layers
+ * used by do_versions in readfile.c when creating pdata and ldata for pre-bmesh
+ * meshes and needed to preserve active/render/clone/stencil flags set in pre-bmesh files
+ */
+void CustomData_bmesh_do_versions_update_active_layers(CustomData *fdata, CustomData *pdata, CustomData *ldata)
+{
+       int act;
+
+       if (CustomData_has_layer(fdata, CD_MTFACE)) {
+               act = CustomData_get_active_layer(fdata, CD_MTFACE);
+               CustomData_set_layer_active(pdata, CD_MTEXPOLY, act);
+               CustomData_set_layer_active(ldata, CD_MLOOPUV, act);
+
+               act = CustomData_get_render_layer(fdata, CD_MTFACE);
+               CustomData_set_layer_render(pdata, CD_MTEXPOLY, act);
+               CustomData_set_layer_render(ldata, CD_MLOOPUV, act);
+
+               act = CustomData_get_clone_layer(fdata, CD_MTFACE);
+               CustomData_set_layer_clone(pdata, CD_MTEXPOLY, act);
+               CustomData_set_layer_clone(ldata, CD_MLOOPUV, act);
+
+               act = CustomData_get_stencil_layer(fdata, CD_MTFACE);
+               CustomData_set_layer_stencil(pdata, CD_MTEXPOLY, act);
+               CustomData_set_layer_stencil(ldata, CD_MLOOPUV, act);
+       }
+
+       if (CustomData_has_layer(fdata, CD_MCOL)) {
+               act = CustomData_get_active_layer(fdata, CD_MCOL);
+               CustomData_set_layer_active(ldata, CD_MLOOPCOL, act);
+
+               act = CustomData_get_render_layer(fdata, CD_MCOL);
+               CustomData_set_layer_render(ldata, CD_MLOOPCOL, act);
+
+               act = CustomData_get_clone_layer(fdata, CD_MCOL);
+               CustomData_set_layer_clone(ldata, CD_MLOOPCOL, act);
+
+               act = CustomData_get_stencil_layer(fdata, CD_MCOL);
+               CustomData_set_layer_stencil(ldata, CD_MLOOPCOL, act);
+       }
+}
+
 void CustomData_bmesh_init_pool(CustomData *data, int totelem, const char htype)
 {
        int chunksize;
@@ -2234,7 +2358,7 @@ void CustomData_bmesh_free_block(CustomData *data, void **block)
 
                        if (typeInfo->free) {
                                int offset = data->layers[i].offset;
-                               typeInfo->free((char*)*block + offset, 1, typeInfo->size);
+                               typeInfo->free((char *)*block + offset, 1, typeInfo->size);
                        }
                }
        }
@@ -2258,7 +2382,7 @@ static void CustomData_bmesh_alloc_block(CustomData *data, void **block)
 }
 
 void CustomData_bmesh_copy_data(const CustomData *source, CustomData *dest,
-                                                       void *src_block, void **dest_block)
+                                void *src_block, void **dest_block)
 {
        const LayerTypeInfo *typeInfo;
        int dest_i, src_i;
@@ -2285,9 +2409,10 @@ void CustomData_bmesh_copy_data(const CustomData *source, CustomData *dest,
 
                /* if we found a matching layer, copy the data */
                if (dest->layers[dest_i].type == source->layers[src_i].type &&
-                       strcmp(dest->layers[dest_i].name, source->layers[src_i].name) == 0) {
-                       char *src_data = (char*)src_block + source->layers[src_i].offset;
-                       char *dest_data = (char*)*dest_block + dest->layers[dest_i].offset;
+                   strcmp(dest->layers[dest_i].name, source->layers[src_i].name) == 0)
+               {
+                       char *src_data = (char *)src_block + source->layers[src_i].offset;
+                       char *dest_data = (char *)*dest_block + dest->layers[dest_i].offset;
 
                        typeInfo = layerType_getInfo(source->layers[src_i].type);
 
@@ -2325,7 +2450,7 @@ void *CustomData_bmesh_get_n(const CustomData *data, void *block, int type, int
        layer_index = CustomData_get_layer_index(data, type);
        if (layer_index < 0) return NULL;
 
-       return (char *)block + data->layers[layer_index+n].offset;
+       return (char *)block + data->layers[layer_index + n].offset;
 }
 
 /*gets from the layer at physical index n, note: doesn't check type.*/
@@ -2447,7 +2572,7 @@ void CustomData_bmesh_set_layer_n(CustomData *data, void *block, int n, void *so
 }
 
 void CustomData_bmesh_interp(CustomData *data, void **src_blocks, float *weights,
-                                                 float *sub_weights, int count, void *dest_block)
+                             float *sub_weights, int count, void *dest_block)
 {
        int i, j;
        void *source_buf[SOURCE_BUF_SIZE];
@@ -2458,7 +2583,7 @@ void CustomData_bmesh_interp(CustomData *data, void **src_blocks, float *weights
         */
        if (count > SOURCE_BUF_SIZE)
                sources = MEM_callocN(sizeof(*sources) * count,
-                                                         "CustomData_interp sources");
+                                     "CustomData_interp sources");
 
        /* interpolates a layer at a time */
        for (i = 0; i < data->totlayer; ++i) {
@@ -2469,7 +2594,7 @@ void CustomData_bmesh_interp(CustomData *data, void **src_blocks, float *weights
                                sources[j] = (char *)src_blocks[j] + layer->offset;
 
                        typeInfo->interp(sources, weights, sub_weights, count,
-                                                         (char *)dest_block + layer->offset);
+                                        (char *)dest_block + layer->offset);
                }
        }
 
@@ -2490,13 +2615,13 @@ void CustomData_bmesh_set_default(CustomData *data, void **block)
                typeInfo = layerType_getInfo(data->layers[i].type);
 
                if (typeInfo->set_default)
-                       typeInfo->set_default((char*)*block + offset, 1);
-               else memset((char*)*block + offset, 0, typeInfo->size);
+                       typeInfo->set_default((char *)*block + offset, 1);
+               else memset((char *)*block + offset, 0, typeInfo->size);
        }
 }
 
 void CustomData_to_bmesh_block(const CustomData *source, CustomData *dest,
-                                                       int src_index, void **dest_block)
+                               int src_index, void **dest_block)
 {
        const LayerTypeInfo *typeInfo;
        int dest_i, src_i, src_offset;
@@ -2522,7 +2647,7 @@ void CustomData_to_bmesh_block(const CustomData *source, CustomData *dest,
                if (dest->layers[dest_i].type == source->layers[src_i].type) {
                        int offset = dest->layers[dest_i].offset;
                        char *src_data = source->layers[src_i].data;
-                       char *dest_data = (char*)*dest_block + offset;
+                       char *dest_data = (char *)*dest_block + offset;
 
                        typeInfo = layerType_getInfo(dest->layers[dest_i].type);
                        src_offset = src_index * typeInfo->size;
@@ -2542,7 +2667,7 @@ void CustomData_to_bmesh_block(const CustomData *source, CustomData *dest,
 }
 
 void CustomData_from_bmesh_block(const CustomData *source, CustomData *dest,
-                                                         void *src_block, int dest_index)
+                                 void *src_block, int dest_index)
 {
        const LayerTypeInfo *typeInfo;
        int dest_i, src_i, dest_offset;
@@ -2564,7 +2689,7 @@ void CustomData_from_bmesh_block(const CustomData *source, CustomData *dest,
                /* if we found a matching layer, copy the data */
                if (dest->layers[dest_i].type == source->layers[src_i].type) {
                        int offset = source->layers[src_i].offset;
-                       char *src_data = (char*)src_block + offset;
+                       char *src_data = (char *)src_block + offset;
                        char *dest_data = dest->layers[dest_i].data;
 
                        typeInfo = layerType_getInfo(dest->layers[dest_i].type);
@@ -2612,7 +2737,7 @@ const char *CustomData_layertype_name(int type)
 int CustomData_layertype_is_singleton(int type)
 {
        const LayerTypeInfo *typeInfo = layerType_getInfo(type);
-       return typeInfo->defaultname != NULL;
+       return typeInfo->defaultname == NULL;
 }
 
 static int  CustomData_is_property_layer(int type)
@@ -2626,17 +2751,17 @@ static int cd_layer_find_dupe(CustomData *data, const char *name, int type, int
 {
        int i;
        /* see if there is a duplicate */
-       for (i=0; i<data->totlayer; i++) {
+       for (i = 0; i < data->totlayer; i++) {
                if (i != index) {
-                       CustomDataLayer *layer= &data->layers[i];
+                       CustomDataLayer *layer = &data->layers[i];
                        
                        if (CustomData_is_property_layer(type)) {
-                               if (CustomData_is_property_layer(layer->type) && strcmp(layer->name, name)==0) {
+                               if (CustomData_is_property_layer(layer->type) && strcmp(layer->name, name) == 0) {
                                        return 1;
                                }
                        }
                        else {
-                               if (i!=index && layer->type==type && strcmp(layer->name, name)==0) {
+                               if (i != index && layer->type == type && strcmp(layer->name, name) == 0) {
                                        return 1;
                                }
                        }
@@ -2648,19 +2773,19 @@ static int cd_layer_find_dupe(CustomData *data, const char *name, int type, int
 
 static int customdata_unique_check(void *arg, const char *name)
 {
-       struct {CustomData *data; int type; int index;} *data_arg= arg;
+       struct {CustomData *data; int type; int index; } *data_arg = arg;
        return cd_layer_find_dupe(data_arg->data, name, data_arg->type, data_arg->index);
 }
 
 void CustomData_set_layer_unique_name(CustomData *data, int index)
 {      
-       CustomDataLayer *nlayer= &data->layers[index];
-       const LayerTypeInfo *typeInfo= layerType_getInfo(nlayer->type);
+       CustomDataLayer *nlayer = &data->layers[index];
+       const LayerTypeInfo *typeInfo = layerType_getInfo(nlayer->type);
 
-       struct {CustomData *data; int type; int index;} data_arg;
-       data_arg.data= data;
-       data_arg.type= nlayer->type;
-       data_arg.index= index;
+       struct {CustomData *data; int type; int index; } data_arg;
+       data_arg.data = data;
+       data_arg.type = nlayer->type;
+       data_arg.index = index;
 
        if (!typeInfo->defaultname)
                return;
@@ -2700,15 +2825,15 @@ int CustomData_verify_versions(struct CustomData *data, int index)
                typeInfo = layerType_getInfo(layer->type);
 
                if (!typeInfo->defaultname && (index > 0) &&
-                       data->layers[index-1].type == layer->type)
+                   data->layers[index - 1].type == layer->type)
                {
                        keeplayer = 0; /* multiple layers of which we only support one */
                }
        }
 
        if (!keeplayer) {
-               for (i=index+1; i < data->totlayer; ++i)
-                       data->layers[i-1] = data->layers[i];
+               for (i = index + 1; i < data->totlayer; ++i)
+                       data->layers[i - 1] = data->layers[i];
                data->totlayer--;
        }
 
@@ -2729,11 +2854,11 @@ void CustomData_external_reload(CustomData *data, ID *UNUSED(id), CustomDataMask
        const LayerTypeInfo *typeInfo;
        int i;
 
-       for (i=0; i<data->totlayer; i++) {
+       for (i = 0; i < data->totlayer; i++) {
                layer = &data->layers[i];
                typeInfo = layerType_getInfo(layer->type);
 
-               if (!(mask & CD_TYPE_AS_MASK(layer->type)));
+               if (!(mask & CD_TYPE_AS_MASK(layer->type))) ;
                else if ((layer->flag & CD_FLAG_EXTERNAL) && (layer->flag & CD_FLAG_IN_MEMORY)) {
                        if (typeInfo->free)
                                typeInfo->free(layer->data, totelem, typeInfo->size);
@@ -2744,7 +2869,7 @@ void CustomData_external_reload(CustomData *data, ID *UNUSED(id), CustomDataMask
 
 void CustomData_external_read(CustomData *data, ID *id, CustomDataMask mask, int totelem)
 {
-       CustomDataExternal *external= data->external;
+       CustomDataExternal *external = data->external;
        CustomDataLayer *layer;
        CDataFile *cdf;
        CDataFileLayer *blay;
@@ -2755,14 +2880,14 @@ void CustomData_external_read(CustomData *data, ID *id, CustomDataMask mask, int
        if (!external)
                return;
        
-       for (i=0; i<data->totlayer; i++) {
+       for (i = 0; i < data->totlayer; i++) {
                layer = &data->layers[i];
                typeInfo = layerType_getInfo(layer->type);
 
-               if (!(mask & CD_TYPE_AS_MASK(layer->type)));
-               else if (layer->flag & CD_FLAG_IN_MEMORY);
+               if (!(mask & CD_TYPE_AS_MASK(layer->type))) ;
+               else if (layer->flag & CD_FLAG_IN_MEMORY) ;
                else if ((layer->flag & CD_FLAG_EXTERNAL) && typeInfo->read)
-                       update= 1;
+                       update = 1;
        }
 
        if (!update)
@@ -2770,24 +2895,24 @@ void CustomData_external_read(CustomData *data, ID *id, CustomDataMask mask, int
 
        customdata_external_filename(filename, id, external);
 
-       cdf= cdf_create(CDF_TYPE_MESH);
+       cdf = cdf_create(CDF_TYPE_MESH);
        if (!cdf_read_open(cdf, filename)) {
                fprintf(stderr, "Failed to read %s layer from %s.\n", layerType_getName(layer->type), filename);
                return;
        }
 
-       for (i=0; i<data->totlayer; i++) {
+       for (i = 0; i < data->totlayer; i++) {
                layer = &data->layers[i];
                typeInfo = layerType_getInfo(layer->type);
 
-               if (!(mask & CD_TYPE_AS_MASK(layer->type)));
-               else if (layer->flag & CD_FLAG_IN_MEMORY);
+               if (!(mask & CD_TYPE_AS_MASK(layer->type))) ;
+               else if (layer->flag & CD_FLAG_IN_MEMORY) ;
                else if ((layer->flag & CD_FLAG_EXTERNAL) && typeInfo->read) {
-                       blay= cdf_layer_find(cdf, layer->type, layer->name);
+                       blay = cdf_layer_find(cdf, layer->type, layer->name);
 
                        if (blay) {
                                if (cdf_read_layer(cdf, blay)) {
-                                       if (typeInfo->read(cdf, layer->data, totelem));
+                                       if (typeInfo->read(cdf, layer->data, totelem)) ;
                                        else break;
                                        layer->flag |= CD_FLAG_IN_MEMORY;
                                }
@@ -2803,7 +2928,7 @@ void CustomData_external_read(CustomData *data, ID *id, CustomDataMask mask, int
 
 void CustomData_external_write(CustomData *data, ID *id, CustomDataMask mask, int totelem, int free)
 {
-       CustomDataExternal *external= data->external;
+       CustomDataExternal *external = data->external;
        CustomDataLayer *layer;
        CDataFile *cdf;
        CDataFileLayer *blay;
@@ -2815,13 +2940,13 @@ void CustomData_external_write(CustomData *data, ID *id, CustomDataMask mask, in
                return;
 
        /* test if there is anything to write */
-       for (i=0; i<data->totlayer; i++) {
+       for (i = 0; i < data->totlayer; i++) {
                layer = &data->layers[i];
                typeInfo = layerType_getInfo(layer->type);
 
-               if (!(mask & CD_TYPE_AS_MASK(layer->type)));
+               if (!(mask & CD_TYPE_AS_MASK(layer->type))) ;
                else if ((layer->flag & CD_FLAG_EXTERNAL) && typeInfo->write)
-                       update= 1;
+                       update = 1;
        }
 
        if (!update)
@@ -2831,16 +2956,16 @@ void CustomData_external_write(CustomData *data, ID *id, CustomDataMask mask, in
        CustomData_external_read(data, id, mask, totelem);
        customdata_external_filename(filename, id, external);
 
-       cdf= cdf_create(CDF_TYPE_MESH);
+       cdf = cdf_create(CDF_TYPE_MESH);
 
-       for (i=0; i<data->totlayer; i++) {
+       for (i = 0; i < data->totlayer; i++) {
                layer = &data->layers[i];
                typeInfo = layerType_getInfo(layer->type);
 
                if ((layer->flag & CD_FLAG_EXTERNAL) && typeInfo->filesize) {
                        if (layer->flag & CD_FLAG_IN_MEMORY) {
                                cdf_layer_add(cdf, layer->type, layer->name,
-                                       typeInfo->filesize(cdf, layer->data, totelem));
+                                             typeInfo->filesize(cdf, layer->data, totelem));
                        }
                        else {
                                cdf_free(cdf);
@@ -2854,15 +2979,15 @@ void CustomData_external_write(CustomData *data, ID *id, CustomDataMask mask, in
                return;
        }
 
-       for (i=0; i<data->totlayer; i++) {
+       for (i = 0; i < data->totlayer; i++) {
                layer = &data->layers[i];
                typeInfo = layerType_getInfo(layer->type);
 
                if ((layer->flag & CD_FLAG_EXTERNAL) && typeInfo->write) {
-                       blay= cdf_layer_find(cdf, layer->type, layer->name);
+                       blay = cdf_layer_find(cdf, layer->type, layer->name);
 
                        if (cdf_write_layer(cdf, blay)) {
-                               if (typeInfo->write(cdf, layer->data, totelem));
+                               if (typeInfo->write(cdf, layer->data, totelem)) ;
                                else break;
                        }
                        else
@@ -2876,7 +3001,7 @@ void CustomData_external_write(CustomData *data, ID *id, CustomDataMask mask, in
                return;
        }
 
-       for (i=0; i<data->totlayer; i++) {
+       for (i = 0; i < data->totlayer; i++) {
                layer = &data->layers[i];
                typeInfo = layerType_getInfo(layer->type);
 
@@ -2895,7 +3020,7 @@ void CustomData_external_write(CustomData *data, ID *id, CustomDataMask mask, in
 
 void CustomData_external_add(CustomData *data, ID *UNUSED(id), int type, int UNUSED(totelem), const char *filename)
 {
-       CustomDataExternal *external= data->external;
+       CustomDataExternal *external = data->external;
        CustomDataLayer *layer;
        int layer_index;
 
@@ -2908,17 +3033,17 @@ void CustomData_external_add(CustomData *data, ID *UNUSED(id), int type, int UNU
                return;
 
        if (!external) {
-               external= MEM_callocN(sizeof(CustomDataExternal), "CustomDataExternal");
-               data->external= external;
+               external = MEM_callocN(sizeof(CustomDataExternal), "CustomDataExternal");
+               data->external = external;
        }
        BLI_strncpy(external->filename, filename, sizeof(external->filename));
 
-       layer->flag |= CD_FLAG_EXTERNAL|CD_FLAG_IN_MEMORY;
+       layer->flag |= CD_FLAG_EXTERNAL | CD_FLAG_IN_MEMORY;
 }
 
 void CustomData_external_remove(CustomData *data, ID *id, int type, int totelem)
 {
-       CustomDataExternal *external= data->external;
+       CustomDataExternal *external = data->external;
        CustomDataLayer *layer;
        //char filename[FILE_MAX];
        int layer_index; // i, remove_file;
@@ -2938,10 +3063,10 @@ void CustomData_external_remove(CustomData *data, ID *id, int type, int totelem)
                layer->flag &= ~CD_FLAG_EXTERNAL;
 
 #if 0
-               remove_file= 1;
-               for (i=0; i<data->totlayer; i++)
+               remove_file = 1;
+               for (i = 0; i < data->totlayer; i++)
                        if (data->layers[i].flag & CD_FLAG_EXTERNAL)
-                               remove_file= 0;
+                               remove_file = 0;
 
                if (remove_file) {
                        customdata_external_filename(filename, id, external);
@@ -2967,7 +3092,7 @@ int CustomData_external_test(CustomData *data, int type)
 #if 0
 void CustomData_external_remove_object(CustomData *data, ID *id)
 {
-       CustomDataExternal *external= data->external;
+       CustomDataExternal *external = data->external;
        char filename[FILE_MAX];
 
        if (!external)