Refactor to Dyntopo node customdata commit.
[blender.git] / source / blender / blenkernel / intern / customdata.c
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software  Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * The Original Code is Copyright (C) 2006 Blender Foundation.
19  * All rights reserved.
20  *
21  * The Original Code is: all of this file.
22  *
23  * Contributor(s): Ben Batt <benbatt@gmail.com>
24  *
25  * ***** END GPL LICENSE BLOCK *****
26  *
27  * Implementation of CustomData.
28  *
29  * BKE_customdata.h contains the function prototypes for this file.
30  *
31  */
32
33 /** \file blender/blenkernel/intern/customdata.c
34  *  \ingroup bke
35  */
36  
37
38 #include <math.h>
39 #include <string.h>
40 #include <assert.h>
41
42 #include "MEM_guardedalloc.h"
43
44 #include "DNA_meshdata_types.h"
45 #include "DNA_ID.h"
46
47 #include "BLI_utildefines.h"
48 #include "BLI_string.h"
49 #include "BLI_path_util.h"
50 #include "BLI_math.h"
51 #include "BLI_mempool.h"
52 #include "BLI_alloca.h"
53
54 #include "BLF_translation.h"
55
56 #include "BKE_customdata.h"
57 #include "BKE_customdata_file.h"
58 #include "BKE_global.h"
59 #include "BKE_main.h"
60 #include "BKE_multires.h"
61
62 #include "bmesh.h"
63
64 #include <math.h>
65 #include <string.h>
66
67 /* number of layers to add when growing a CustomData object */
68 #define CUSTOMDATA_GROW 5
69
70 /* ensure typemap size is ok */
71 BLI_STATIC_ASSERT(sizeof(((CustomData *)NULL)->typemap) /
72                   sizeof(((CustomData *)NULL)->typemap[0]) == CD_NUMTYPES,
73                   "size mismatch");
74
75
76 /********************* Layer type information **********************/
77 typedef struct LayerTypeInfo {
78         int size;          /* the memory size of one element of this layer's data */
79
80         /** name of the struct used, for file writing */
81         const char *structname;
82         /** number of structs per element, for file writing */
83         int structnum;
84
85         /**
86          * default layer name.
87          * note! when NULL this is a way to ensure there is only ever one item
88          * see: CustomData_layertype_is_singleton() */
89         const char *defaultname;
90
91         /**
92          * a function to copy count elements of this layer's data
93          * (deep copy if appropriate)
94          * if NULL, memcpy is used
95          */
96         void (*copy)(const void *source, void *dest, int count);
97
98         /**
99          * a function to free any dynamically allocated components of this
100          * layer's data (note the data pointer itself should not be freed)
101          * size should be the size of one element of this layer's data (e.g.
102          * LayerTypeInfo.size)
103          */
104         void (*free)(void *data, int count, int size);
105
106         /**
107          * a function to interpolate between count source elements of this
108          * layer's data and store the result in dest
109          * if weights == NULL or sub_weights == NULL, they should default to 1
110          *
111          * weights gives the weight for each element in sources
112          * sub_weights gives the sub-element weights for each element in sources
113          *    (there should be (sub element count)^2 weights per element)
114          * count gives the number of elements in sources
115          *
116          * \note in some cases \a dest pointer is in \a sources
117          *       so all functions have to take this into account and delay
118          *       applying changes while reading from sources.
119          *       See bug [#32395] - Campbell.
120          */
121         void (*interp)(void **sources, const float *weights, const float *sub_weights,
122                        int count, void *dest);
123
124         /** a function to swap the data in corners of the element */
125         void (*swap)(void *data, const int *corner_indices);
126
127         /**
128          * a function to set a layer's data to default values. if NULL, the
129          * default is assumed to be all zeros */
130         void (*set_default)(void *data, int count);
131
132         /** functions necessary for geometry collapse */
133         bool (*equal)(void *data1, void *data2);
134         void (*multiply)(void *data, float fac);
135         void (*initminmax)(void *min, void *max);
136         void (*add)(void *data1, void *data2);
137         void (*dominmax)(void *data1, void *min, void *max);
138         void (*copyvalue)(void *source, void *dest);
139
140         /** a function to read data from a cdf file */
141         int (*read)(CDataFile *cdf, void *data, int count);
142
143         /** a function to write data to a cdf file */
144         int (*write)(CDataFile *cdf, void *data, int count);
145
146         /** a function to determine file size */
147         size_t (*filesize)(CDataFile *cdf, void *data, int count);
148 } LayerTypeInfo;
149
150 static void layerCopy_mdeformvert(const void *source, void *dest,
151                                   int count)
152 {
153         int i, size = sizeof(MDeformVert);
154
155         memcpy(dest, source, count * size);
156
157         for (i = 0; i < count; ++i) {
158                 MDeformVert *dvert = (MDeformVert *)((char *)dest + i * size);
159
160                 if (dvert->totweight) {
161                         MDeformWeight *dw = MEM_mallocN(dvert->totweight * sizeof(*dw),
162                                                         "layerCopy_mdeformvert dw");
163
164                         memcpy(dw, dvert->dw, dvert->totweight * sizeof(*dw));
165                         dvert->dw = dw;
166                 }
167                 else
168                         dvert->dw = NULL;
169         }
170 }
171
172 static void layerFree_mdeformvert(void *data, int count, int size)
173 {
174         int i;
175
176         for (i = 0; i < count; ++i) {
177                 MDeformVert *dvert = (MDeformVert *)((char *)data + i * size);
178
179                 if (dvert->dw) {
180                         MEM_freeN(dvert->dw);
181                         dvert->dw = NULL;
182                         dvert->totweight = 0;
183                 }
184         }
185 }
186
187 /* copy just zeros in this case */
188 static void layerCopy_bmesh_elem_py_ptr(const void *UNUSED(source), void *dest,
189                                         int count)
190 {
191         int i, size = sizeof(void *);
192
193         for (i = 0; i < count; ++i) {
194                 void **ptr = (void **)((char *)dest + i * size);
195                 *ptr = NULL;
196         }
197 }
198
199 #ifndef WITH_PYTHON
200 void bpy_bm_generic_invalidate(struct BPy_BMGeneric *UNUSED(self))
201 {
202         /* dummy */
203 }
204 #endif
205
206 static void layerFree_bmesh_elem_py_ptr(void *data, int count, int size)
207 {
208         int i;
209
210         for (i = 0; i < count; ++i) {
211                 void **ptr = (void *)((char *)data + i * size);
212                 if (*ptr) {
213                         bpy_bm_generic_invalidate(*ptr);
214                 }
215         }
216 }
217
218 static void layerInterp_mdeformvert(void **sources, const float *weights,
219                                     const float *UNUSED(sub_weights), int count, void *dest)
220 {
221         /* a single linked list of MDeformWeight's
222          * use this to avoid double allocs (which LinkNode would do) */
223         struct MDeformWeight_Link {
224                 struct MDeformWeight_Link *next;
225                 MDeformWeight dw;
226         };
227
228         MDeformVert *dvert = dest;
229         struct MDeformWeight_Link *dest_dwlink = NULL;
230         struct MDeformWeight_Link *node;
231         int i, j, totweight;
232
233         if (count <= 0) return;
234
235         /* build a list of unique def_nrs for dest */
236         totweight = 0;
237         for (i = 0; i < count; ++i) {
238                 MDeformVert *source = sources[i];
239                 float interp_weight = weights ? weights[i] : 1.0f;
240
241                 for (j = 0; j < source->totweight; ++j) {
242                         MDeformWeight *dw = &source->dw[j];
243                         float weight = dw->weight * interp_weight;
244
245                         if (weight == 0.0f)
246                                 continue;
247
248                         for (node = dest_dwlink; node; node = node->next) {
249                                 MDeformWeight *tmp_dw = &node->dw;
250
251                                 if (tmp_dw->def_nr == dw->def_nr) {
252                                         tmp_dw->weight += weight;
253                                         break;
254                                 }
255                         }
256
257                         /* if this def_nr is not in the list, add it */
258                         if (!node) {
259                                 struct MDeformWeight_Link *tmp_dwlink = alloca(sizeof(*tmp_dwlink));
260                                 tmp_dwlink->dw.def_nr = dw->def_nr;
261                                 tmp_dwlink->dw.weight = weight;
262
263                                 /* inline linklist */
264                                 tmp_dwlink->next = dest_dwlink;
265                                 dest_dwlink = tmp_dwlink;
266
267                                 totweight++;
268                         }
269                 }
270         }
271
272         /* delay writing to the destination incase dest is in sources */
273
274         /* now we know how many unique deform weights there are, so realloc */
275         if (dvert->dw && (dvert->totweight == totweight)) {
276                 /* pass (fastpath if we don't need to realloc) */
277         }
278         else {
279                 if (dvert->dw) {
280                         MEM_freeN(dvert->dw);
281                 }
282
283                 if (totweight) {
284                         dvert->dw = MEM_mallocN(sizeof(*dvert->dw) * totweight, __func__);
285                 }
286         }
287
288         if (totweight) {
289                 dvert->totweight = totweight;
290                 for (i = 0, node = dest_dwlink; node; node = node->next, i++) {
291                         dvert->dw[i] = node->dw;
292                 }
293         }
294         else {
295                 memset(dvert, 0, sizeof(*dvert));
296         }
297 }
298
299 static void layerCopy_tface(const void *source, void *dest, int count)
300 {
301         const MTFace *source_tf = (const MTFace *)source;
302         MTFace *dest_tf = (MTFace *)dest;
303         int i;
304
305         for (i = 0; i < count; ++i)
306                 dest_tf[i] = source_tf[i];
307 }
308
309 static void layerInterp_tface(void **sources, const float *weights,
310                               const float *sub_weights, int count, void *dest)
311 {
312         MTFace *tf = dest;
313         int i, j, k;
314         float uv[4][2] = {{0.0f}};
315         const float *sub_weight;
316
317         if (count <= 0) return;
318
319         sub_weight = sub_weights;
320         for (i = 0; i < count; ++i) {
321                 float weight = weights ? weights[i] : 1;
322                 MTFace *src = sources[i];
323
324                 for (j = 0; j < 4; ++j) {
325                         if (sub_weights) {
326                                 for (k = 0; k < 4; ++k, ++sub_weight) {
327                                         madd_v2_v2fl(uv[j], src->uv[k], (*sub_weight) * weight);
328                                 }
329                         }
330                         else {
331                                 madd_v2_v2fl(uv[j], src->uv[j], weight);
332                         }
333                 }
334         }
335
336         /* delay writing to the destination incase dest is in sources */
337         *tf = *(MTFace *)(*sources);
338         memcpy(tf->uv, uv, sizeof(tf->uv));
339 }
340
341 static void layerSwap_tface(void *data, const int *corner_indices)
342 {
343         MTFace *tf = data;
344         float uv[4][2];
345         static const short pin_flags[4] = { TF_PIN1, TF_PIN2, TF_PIN3, TF_PIN4 };
346         static const char sel_flags[4] = { TF_SEL1, TF_SEL2, TF_SEL3, TF_SEL4 };
347         short unwrap = tf->unwrap & ~(TF_PIN1 | TF_PIN2 | TF_PIN3 | TF_PIN4);
348         char flag = tf->flag & ~(TF_SEL1 | TF_SEL2 | TF_SEL3 | TF_SEL4);
349         int j;
350
351         for (j = 0; j < 4; ++j) {
352                 const int source_index = corner_indices[j];
353
354                 copy_v2_v2(uv[j], tf->uv[source_index]);
355
356                 /* swap pinning flags around */
357                 if (tf->unwrap & pin_flags[source_index]) {
358                         unwrap |= pin_flags[j];
359                 }
360
361                 /* swap selection flags around */
362                 if (tf->flag & sel_flags[source_index]) {
363                         flag |= sel_flags[j];
364                 }
365         }
366
367         memcpy(tf->uv, uv, sizeof(tf->uv));
368         tf->unwrap = unwrap;
369         tf->flag = flag;
370 }
371
372 static void layerDefault_tface(void *data, int count)
373 {
374         static MTFace default_tf = {{{0, 0}, {1, 0}, {1, 1}, {0, 1}}, NULL,
375                                         0, 0, TF_DYNAMIC | TF_CONVERTED, 0, 0};
376         MTFace *tf = (MTFace *)data;
377         int i;
378
379         for (i = 0; i < count; i++)
380                 tf[i] = default_tf;
381 }
382
383 static void layerCopy_propFloat(const void *source, void *dest,
384                                 int count)
385 {
386         memcpy(dest, source, sizeof(MFloatProperty) * count);
387 }
388
389 static void layerCopy_propInt(const void *source, void *dest,
390                               int count)
391 {
392         memcpy(dest, source, sizeof(MIntProperty) * count);
393 }
394
395 static void layerCopy_propString(const void *source, void *dest,
396                                  int count)
397 {
398         memcpy(dest, source, sizeof(MStringProperty) * count);
399 }
400
401 static void layerCopy_origspace_face(const void *source, void *dest, int count)
402 {
403         const OrigSpaceFace *source_tf = (const OrigSpaceFace *)source;
404         OrigSpaceFace *dest_tf = (OrigSpaceFace *)dest;
405         int i;
406
407         for (i = 0; i < count; ++i)
408                 dest_tf[i] = source_tf[i];
409 }
410
411 static void layerInterp_origspace_face(void **sources, const float *weights,
412                                        const float *sub_weights, int count, void *dest)
413 {
414         OrigSpaceFace *osf = dest;
415         int i, j, k;
416         float uv[4][2] = {{0.0f}};
417         const float *sub_weight;
418
419         if (count <= 0) return;
420
421         sub_weight = sub_weights;
422         for (i = 0; i < count; ++i) {
423                 float weight = weights ? weights[i] : 1;
424                 OrigSpaceFace *src = sources[i];
425
426                 for (j = 0; j < 4; ++j) {
427                         if (sub_weights) {
428                                 for (k = 0; k < 4; ++k, ++sub_weight) {
429                                         madd_v2_v2fl(uv[j], src->uv[k], (*sub_weight) * weight);
430                                 }
431                         }
432                         else {
433                                 madd_v2_v2fl(uv[j], src->uv[j], weight);
434                         }
435                 }
436         }
437
438         /* delay writing to the destination incase dest is in sources */
439
440 #if 0 /* no need, this ONLY contains UV's */
441         *osf = *(OrigSpaceFace *)(*sources);
442 #endif
443         memcpy(osf->uv, uv, sizeof(osf->uv));
444 }
445
446 static void layerSwap_origspace_face(void *data, const int *corner_indices)
447 {
448         OrigSpaceFace *osf = data;
449         float uv[4][2];
450         int j;
451
452         for (j = 0; j < 4; ++j) {
453                 copy_v2_v2(uv[j], osf->uv[corner_indices[j]]);
454         }
455         memcpy(osf->uv, uv, sizeof(osf->uv));
456 }
457
458 static void layerDefault_origspace_face(void *data, int count)
459 {
460         static OrigSpaceFace default_osf = {{{0, 0}, {1, 0}, {1, 1}, {0, 1}}};
461         OrigSpaceFace *osf = (OrigSpaceFace *)data;
462         int i;
463
464         for (i = 0; i < count; i++)
465                 osf[i] = default_osf;
466 }
467
468 static void layerSwap_mdisps(void *data, const int *ci)
469 {
470         MDisps *s = data;
471         float (*d)[3] = NULL;
472         int corners, cornersize, S;
473
474         if (s->disps) {
475                 int nverts = (ci[1] == 3) ? 4 : 3; /* silly way to know vertex count of face */
476                 corners = multires_mdisp_corners(s);
477                 cornersize = s->totdisp / corners;
478
479                 if (corners != nverts) {
480                         /* happens when face changed vertex count in edit mode
481                          * if it happened, just forgot displacement */
482
483                         MEM_freeN(s->disps);
484                         s->totdisp = (s->totdisp / corners) * nverts;
485                         s->disps = MEM_callocN(s->totdisp * sizeof(float) * 3, "mdisp swap");
486                         return;
487                 }
488
489                 d = MEM_callocN(sizeof(float) * 3 * s->totdisp, "mdisps swap");
490
491                 for (S = 0; S < corners; S++)
492                         memcpy(d + cornersize * S, s->disps + cornersize * ci[S], cornersize * 3 * sizeof(float));
493                 
494                 MEM_freeN(s->disps);
495                 s->disps = d;
496         }
497 }
498
499 static void layerCopy_mdisps(const void *source, void *dest, int count)
500 {
501         int i;
502         const MDisps *s = source;
503         MDisps *d = dest;
504
505         for (i = 0; i < count; ++i) {
506                 if (s[i].disps) {
507                         d[i].disps = MEM_dupallocN(s[i].disps);
508                         d[i].hidden = MEM_dupallocN(s[i].hidden);
509                 }
510                 else {
511                         d[i].disps = NULL;
512                         d[i].hidden = NULL;
513                 }
514
515                 /* still copy even if not in memory, displacement can be external */
516                 d[i].totdisp = s[i].totdisp;
517                 d[i].level = s[i].level;
518         }
519 }
520
521 static void layerFree_mdisps(void *data, int count, int UNUSED(size))
522 {
523         int i;
524         MDisps *d = data;
525
526         for (i = 0; i < count; ++i) {
527                 if (d[i].disps)
528                         MEM_freeN(d[i].disps);
529                 if (d[i].hidden)
530                         MEM_freeN(d[i].hidden);
531                 d[i].disps = NULL;
532                 d[i].hidden = NULL;
533                 d[i].totdisp = 0;
534                 d[i].level = 0;
535         }
536 }
537
538 static int layerRead_mdisps(CDataFile *cdf, void *data, int count)
539 {
540         MDisps *d = data;
541         int i;
542
543         for (i = 0; i < count; ++i) {
544                 if (!d[i].disps)
545                         d[i].disps = MEM_callocN(sizeof(float) * 3 * d[i].totdisp, "mdisps read");
546
547                 if (!cdf_read_data(cdf, d[i].totdisp * 3 * sizeof(float), d[i].disps)) {
548                         printf("failed to read multires displacement %d/%d %d\n", i, count, d[i].totdisp);
549                         return 0;
550                 }
551         }
552
553         return 1;
554 }
555
556 static int layerWrite_mdisps(CDataFile *cdf, void *data, int count)
557 {
558         MDisps *d = data;
559         int i;
560
561         for (i = 0; i < count; ++i) {
562                 if (!cdf_write_data(cdf, d[i].totdisp * 3 * sizeof(float), d[i].disps)) {
563                         printf("failed to write multires displacement %d/%d %d\n", i, count, d[i].totdisp);
564                         return 0;
565                 }
566         }
567
568         return 1;
569 }
570
571 static size_t layerFilesize_mdisps(CDataFile *UNUSED(cdf), void *data, int count)
572 {
573         MDisps *d = data;
574         size_t size = 0;
575         int i;
576
577         for (i = 0; i < count; ++i)
578                 size += d[i].totdisp * 3 * sizeof(float);
579
580         return size;
581 }
582
583 static void layerCopy_grid_paint_mask(const void *source, void *dest, int count)
584 {
585         int i;
586         const GridPaintMask *s = source;
587         GridPaintMask *d = dest;
588
589         for (i = 0; i < count; ++i) {
590                 if (s[i].data) {
591                         d[i].data = MEM_dupallocN(s[i].data);
592                         d[i].level = s[i].level;
593                 }
594                 else {
595                         d[i].data = NULL;
596                         d[i].level = 0;
597                 }
598                 
599         }
600 }
601
602 static void layerFree_grid_paint_mask(void *data, int count, int UNUSED(size))
603 {
604         int i;
605         GridPaintMask *gpm = data;
606
607         for (i = 0; i < count; ++i) {
608                 if (gpm[i].data)
609                         MEM_freeN(gpm[i].data);
610                 gpm[i].data = NULL;
611                 gpm[i].level = 0;
612         }
613 }
614
615 /* --------- */
616 static void layerCopyValue_mloopcol(void *source, void *dest)
617 {
618         MLoopCol *m1 = source, *m2 = dest;
619         
620         m2->r = m1->r;
621         m2->g = m1->g;
622         m2->b = m1->b;
623         m2->a = m1->a;
624 }
625
626 static bool layerEqual_mloopcol(void *data1, void *data2)
627 {
628         MLoopCol *m1 = data1, *m2 = data2;
629         float r, g, b, a;
630
631         r = m1->r - m2->r;
632         g = m1->g - m2->g;
633         b = m1->b - m2->b;
634         a = m1->a - m2->a;
635
636         return r * r + g * g + b * b + a * a < 0.001f;
637 }
638
639 static void layerMultiply_mloopcol(void *data, float fac)
640 {
641         MLoopCol *m = data;
642
643         m->r = (float)m->r * fac;
644         m->g = (float)m->g * fac;
645         m->b = (float)m->b * fac;
646         m->a = (float)m->a * fac;
647 }
648
649 static void layerAdd_mloopcol(void *data1, void *data2)
650 {
651         MLoopCol *m = data1, *m2 = data2;
652
653         m->r += m2->r;
654         m->g += m2->g;
655         m->b += m2->b;
656         m->a += m2->a;
657 }
658
659 static void layerDoMinMax_mloopcol(void *data, void *vmin, void *vmax)
660 {
661         MLoopCol *m = data;
662         MLoopCol *min = vmin, *max = vmax;
663
664         if (m->r < min->r) min->r = m->r;
665         if (m->g < min->g) min->g = m->g;
666         if (m->b < min->b) min->b = m->b;
667         if (m->a < min->a) min->a = m->a;
668         
669         if (m->r > max->r) max->r = m->r;
670         if (m->g > max->g) max->g = m->g;
671         if (m->b > max->b) max->b = m->b;
672         if (m->a > max->a) max->a = m->a;
673 }
674
675 static void layerInitMinMax_mloopcol(void *vmin, void *vmax)
676 {
677         MLoopCol *min = vmin, *max = vmax;
678
679         min->r = 255;
680         min->g = 255;
681         min->b = 255;
682         min->a = 255;
683
684         max->r = 0;
685         max->g = 0;
686         max->b = 0;
687         max->a = 0;
688 }
689
690 static void layerDefault_mloopcol(void *data, int count)
691 {
692         MLoopCol default_mloopcol = {255, 255, 255, 255};
693         MLoopCol *mlcol = (MLoopCol *)data;
694         int i;
695         for (i = 0; i < count; i++)
696                 mlcol[i] = default_mloopcol;
697
698 }
699
700 static void layerInterp_mloopcol(void **sources, const float *weights,
701                                  const float *sub_weights, int count, void *dest)
702 {
703         MLoopCol *mc = dest;
704         int i;
705         const float *sub_weight;
706         struct {
707                 float a;
708                 float r;
709                 float g;
710                 float b;
711         } col;
712         col.a = col.r = col.g = col.b = 0;
713
714         sub_weight = sub_weights;
715         for (i = 0; i < count; ++i) {
716                 float weight = weights ? weights[i] : 1;
717                 MLoopCol *src = sources[i];
718                 if (sub_weights) {
719                         col.r += src->r * (*sub_weight) * weight;
720                         col.g += src->g * (*sub_weight) * weight;
721                         col.b += src->b * (*sub_weight) * weight;
722                         col.a += src->a * (*sub_weight) * weight;
723                         sub_weight++;
724                 }
725                 else {
726                         col.r += src->r * weight;
727                         col.g += src->g * weight;
728                         col.b += src->b * weight;
729                         col.a += src->a * weight;
730                 }
731         }
732         
733         /* Subdivide smooth or fractal can cause problems without clamping
734          * although weights should also not cause this situation */
735         CLAMP(col.a, 0.0f, 255.0f);
736         CLAMP(col.r, 0.0f, 255.0f);
737         CLAMP(col.g, 0.0f, 255.0f);
738         CLAMP(col.b, 0.0f, 255.0f);
739
740         /* delay writing to the destination incase dest is in sources */
741         mc->r = (int)col.r;
742         mc->g = (int)col.g;
743         mc->b = (int)col.b;
744         mc->a = (int)col.a;
745 }
746
747 static void layerCopyValue_mloopuv(void *source, void *dest)
748 {
749         MLoopUV *luv1 = source, *luv2 = dest;
750
751         copy_v2_v2(luv2->uv, luv1->uv);
752 }
753
754 static bool layerEqual_mloopuv(void *data1, void *data2)
755 {
756         MLoopUV *luv1 = data1, *luv2 = data2;
757
758         return len_squared_v2v2(luv1->uv, luv2->uv) < 0.00001f;
759 }
760
761 static void layerMultiply_mloopuv(void *data, float fac)
762 {
763         MLoopUV *luv = data;
764
765         mul_v2_fl(luv->uv, fac);
766 }
767
768 static void layerInitMinMax_mloopuv(void *vmin, void *vmax)
769 {
770         MLoopUV *min = vmin, *max = vmax;
771
772         INIT_MINMAX2(min->uv, max->uv);
773 }
774
775 static void layerDoMinMax_mloopuv(void *data, void *vmin, void *vmax)
776 {
777         MLoopUV *min = vmin, *max = vmax, *luv = data;
778
779         minmax_v2v2_v2(min->uv, max->uv, luv->uv);
780 }
781
782 static void layerAdd_mloopuv(void *data1, void *data2)
783 {
784         MLoopUV *l1 = data1, *l2 = data2;
785
786         add_v2_v2(l1->uv, l2->uv);
787 }
788
789 static void layerInterp_mloopuv(void **sources, const float *weights,
790                                 const float *sub_weights, int count, void *dest)
791 {
792         float uv[2];
793         int i;
794
795         zero_v2(uv);
796
797         if (sub_weights) {
798                 const float *sub_weight = sub_weights;
799                 for (i = 0; i < count; i++) {
800                         float weight = weights ? weights[i] : 1.0f;
801                         MLoopUV *src = sources[i];
802                         madd_v2_v2fl(uv, src->uv, (*sub_weight) * weight);
803                         sub_weight++;
804                 }
805         }
806         else {
807                 for (i = 0; i < count; i++) {
808                         float weight = weights ? weights[i] : 1;
809                         MLoopUV *src = sources[i];
810                         madd_v2_v2fl(uv, src->uv, weight);
811                 }
812         }
813
814         /* delay writing to the destination incase dest is in sources */
815         copy_v2_v2(((MLoopUV *)dest)->uv, uv);
816 }
817
818 /* origspace is almost exact copy of mloopuv's, keep in sync */
819 static void layerCopyValue_mloop_origspace(void *source, void *dest)
820 {
821         OrigSpaceLoop *luv1 = source, *luv2 = dest;
822
823         copy_v2_v2(luv2->uv, luv1->uv);
824 }
825
826 static bool layerEqual_mloop_origspace(void *data1, void *data2)
827 {
828         OrigSpaceLoop *luv1 = data1, *luv2 = data2;
829
830         return len_squared_v2v2(luv1->uv, luv2->uv) < 0.00001f;
831 }
832
833 static void layerMultiply_mloop_origspace(void *data, float fac)
834 {
835         OrigSpaceLoop *luv = data;
836
837         mul_v2_fl(luv->uv, fac);
838 }
839
840 static void layerInitMinMax_mloop_origspace(void *vmin, void *vmax)
841 {
842         OrigSpaceLoop *min = vmin, *max = vmax;
843
844         INIT_MINMAX2(min->uv, max->uv);
845 }
846
847 static void layerDoMinMax_mloop_origspace(void *data, void *vmin, void *vmax)
848 {
849         OrigSpaceLoop *min = vmin, *max = vmax, *luv = data;
850
851         minmax_v2v2_v2(min->uv, max->uv, luv->uv);
852 }
853
854 static void layerAdd_mloop_origspace(void *data1, void *data2)
855 {
856         OrigSpaceLoop *l1 = data1, *l2 = data2;
857
858         add_v2_v2(l1->uv, l2->uv);
859 }
860
861 static void layerInterp_mloop_origspace(void **sources, const float *weights,
862                                         const float *sub_weights, int count, void *dest)
863 {
864         float uv[2];
865         int i;
866
867         zero_v2(uv);
868
869         if (sub_weights) {
870                 const float *sub_weight = sub_weights;
871                 for (i = 0; i < count; i++) {
872                         float weight = weights ? weights[i] : 1.0f;
873                         OrigSpaceLoop *src = sources[i];
874                         madd_v2_v2fl(uv, src->uv, (*sub_weight) * weight);
875                         sub_weight++;
876                 }
877         }
878         else {
879                 for (i = 0; i < count; i++) {
880                         float weight = weights ? weights[i] : 1.0f;
881                         OrigSpaceLoop *src = sources[i];
882                         madd_v2_v2fl(uv, src->uv, weight);
883                 }
884         }
885
886         /* delay writing to the destination incase dest is in sources */
887         copy_v2_v2(((OrigSpaceLoop *)dest)->uv, uv);
888 }
889 /* --- end copy */
890
891 static void layerInterp_mcol(void **sources, const float *weights,
892                              const float *sub_weights, int count, void *dest)
893 {
894         MCol *mc = dest;
895         int i, j, k;
896         struct {
897                 float a;
898                 float r;
899                 float g;
900                 float b;
901         } col[4] = {{0.0f}};
902
903         const float *sub_weight;
904
905         if (count <= 0) return;
906         
907         sub_weight = sub_weights;
908         for (i = 0; i < count; ++i) {
909                 float weight = weights ? weights[i] : 1;
910
911                 for (j = 0; j < 4; ++j) {
912                         if (sub_weights) {
913                                 MCol *src = sources[i];
914                                 for (k = 0; k < 4; ++k, ++sub_weight, ++src) {
915                                         const float w = (*sub_weight) * weight;
916                                         col[j].a += src->a * w;
917                                         col[j].r += src->r * w;
918                                         col[j].g += src->g * w;
919                                         col[j].b += src->b * w;
920                                 }
921                         }
922                         else {
923                                 MCol *src = sources[i];
924                                 col[j].a += src[j].a * weight;
925                                 col[j].r += src[j].r * weight;
926                                 col[j].g += src[j].g * weight;
927                                 col[j].b += src[j].b * weight;
928                         }
929                 }
930         }
931
932         /* delay writing to the destination incase dest is in sources */
933         for (j = 0; j < 4; ++j) {
934                 
935                 /* Subdivide smooth or fractal can cause problems without clamping
936                  * although weights should also not cause this situation */
937                 CLAMP(col[j].a, 0.0f, 255.0f);
938                 CLAMP(col[j].r, 0.0f, 255.0f);
939                 CLAMP(col[j].g, 0.0f, 255.0f);
940                 CLAMP(col[j].b, 0.0f, 255.0f);
941                 
942                 mc[j].a = (int)col[j].a;
943                 mc[j].r = (int)col[j].r;
944                 mc[j].g = (int)col[j].g;
945                 mc[j].b = (int)col[j].b;
946         }
947 }
948
949 static void layerSwap_mcol(void *data, const int *corner_indices)
950 {
951         MCol *mcol = data;
952         MCol col[4];
953         int j;
954
955         for (j = 0; j < 4; ++j)
956                 col[j] = mcol[corner_indices[j]];
957
958         memcpy(mcol, col, sizeof(col));
959 }
960
961 static void layerDefault_mcol(void *data, int count)
962 {
963         static MCol default_mcol = {255, 255, 255, 255};
964         MCol *mcol = (MCol *)data;
965         int i;
966
967         for (i = 0; i < 4 * count; i++) {
968                 mcol[i] = default_mcol;
969         }
970 }
971
972 static void layerDefault_origindex(void *data, int count)
973 {
974         fill_vn_i((int *)data, count, ORIGINDEX_NONE);
975 }
976
977 static void layerInterp_bweight(void **sources, const float *weights,
978                                 const float *UNUSED(sub_weights), int count, void *dest)
979 {
980         float f;
981         float **in = (float **)sources;
982         int i;
983         
984         if (count <= 0) return;
985
986         f = 0.0f;
987
988         if (weights) {
989                 for (i = 0; i < count; ++i) {
990                         f += *in[i] * weights[i];
991                 }
992         }
993         else {
994                 for (i = 0; i < count; ++i) {
995                         f += *in[i];
996                 }
997         }
998
999         /* delay writing to the destination incase dest is in sources */
1000         *((float *)dest) = f;
1001 }
1002
1003 static void layerInterp_shapekey(void **sources, const float *weights,
1004                                  const float *UNUSED(sub_weights), int count, void *dest)
1005 {
1006         float co[3];
1007         float **in = (float **)sources;
1008         int i;
1009
1010         if (count <= 0) return;
1011
1012         zero_v3(co);
1013
1014         if (weights) {
1015                 for (i = 0; i < count; ++i) {
1016                         madd_v3_v3fl(co, in[i], weights[i]);
1017                 }
1018         }
1019         else {
1020                 for (i = 0; i < count; ++i) {
1021                         add_v3_v3(co, in[i]);
1022                 }
1023         }
1024
1025         /* delay writing to the destination incase dest is in sources */
1026         copy_v3_v3((float *)dest, co);
1027 }
1028
1029 static void layerDefault_mvert_skin(void *data, int count)
1030 {
1031         MVertSkin *vs = data;
1032         int i;
1033         
1034         for (i = 0; i < count; i++) {
1035                 copy_v3_fl(vs[i].radius, 0.25f);
1036                 vs[i].flag = 0;
1037         }
1038 }
1039
1040 static void layerInterp_mvert_skin(void **sources, const float *weights,
1041                                    const float *UNUSED(sub_weights),
1042                                    int count, void *dest)
1043 {
1044         float radius[3], w;
1045         MVertSkin *vs;
1046         int i;
1047
1048         zero_v3(radius);
1049         for (i = 0; i < count; i++) {
1050                 w = weights ? weights[i] : 1.0f;
1051                 vs = sources[i];
1052
1053                 madd_v3_v3fl(radius, vs->radius, w);
1054         }
1055
1056         /* delay writing to the destination incase dest is in sources */
1057         vs = dest;
1058         copy_v3_v3(vs->radius, radius);
1059         vs->flag &= ~MVERT_SKIN_ROOT;
1060 }
1061
1062 static void layerSwap_flnor(void *data, const int *corner_indices)
1063 {
1064         short (*flnors)[4][3] = data;
1065         short nors[4][3];
1066         int i = 4;
1067
1068         while (i--) {
1069                 copy_v3_v3_short(nors[i], (*flnors)[corner_indices[i]]);
1070         }
1071
1072         memcpy(flnors, nors, sizeof(nors));
1073 }
1074
1075 static const LayerTypeInfo LAYERTYPEINFO[CD_NUMTYPES] = {
1076         /* 0: CD_MVERT */
1077         {sizeof(MVert), "MVert", 1, NULL, NULL, NULL, NULL, NULL, NULL},
1078         /* 1: CD_MSTICKY */  /* DEPRECATED */
1079         {sizeof(float) * 2, "", 1, NULL, NULL, NULL, NULL, NULL,
1080          NULL},
1081         /* 2: CD_MDEFORMVERT */
1082         {sizeof(MDeformVert), "MDeformVert", 1, NULL, layerCopy_mdeformvert,
1083          layerFree_mdeformvert, layerInterp_mdeformvert, NULL, NULL},
1084         /* 3: CD_MEDGE */
1085         {sizeof(MEdge), "MEdge", 1, NULL, NULL, NULL, NULL, NULL, NULL},
1086         /* 4: CD_MFACE */
1087         {sizeof(MFace), "MFace", 1, NULL, NULL, NULL, NULL, NULL, NULL},
1088         /* 5: CD_MTFACE */
1089         {sizeof(MTFace), "MTFace", 1, N_("UVMap"), layerCopy_tface, NULL,
1090          layerInterp_tface, layerSwap_tface, layerDefault_tface},
1091         /* 6: CD_MCOL */
1092         /* 4 MCol structs per face */
1093         {sizeof(MCol) * 4, "MCol", 4, N_("Col"), NULL, NULL, layerInterp_mcol,
1094          layerSwap_mcol, layerDefault_mcol},
1095         /* 7: CD_ORIGINDEX */
1096         {sizeof(int), "", 0, NULL, NULL, NULL, NULL, NULL, layerDefault_origindex},
1097         /* 8: CD_NORMAL */
1098         /* 3 floats per normal vector */
1099         {sizeof(float) * 3, "vec3f", 1, NULL, NULL, NULL, NULL, NULL, NULL},
1100         /* 9: CD_POLYINDEX (deprecated) */
1101         {sizeof(int), "", 0, NULL, NULL, NULL, NULL, NULL, NULL},
1102         /* 10: CD_PROP_FLT */
1103         {sizeof(MFloatProperty), "MFloatProperty", 1, N_("Float"), layerCopy_propFloat, NULL, NULL, NULL},
1104         /* 11: CD_PROP_INT */
1105         {sizeof(MIntProperty), "MIntProperty", 1, N_("Int"), layerCopy_propInt, NULL, NULL, NULL},
1106         /* 12: CD_PROP_STR */
1107         {sizeof(MStringProperty), "MStringProperty", 1, N_("String"), layerCopy_propString, NULL, NULL, NULL},
1108         /* 13: CD_ORIGSPACE */
1109         {sizeof(OrigSpaceFace), "OrigSpaceFace", 1, N_("UVMap"), layerCopy_origspace_face, NULL,
1110          layerInterp_origspace_face, layerSwap_origspace_face, layerDefault_origspace_face},
1111         /* 14: CD_ORCO */
1112         {sizeof(float) * 3, "", 0, NULL, NULL, NULL, NULL, NULL, NULL},
1113         /* 15: CD_MTEXPOLY */
1114         /* note, when we expose the UV Map / TexFace split to the user, change this back to face Texture */
1115         {sizeof(MTexPoly), "MTexPoly", 1, N_("UVMap") /* "Face Texture" */, NULL, NULL, NULL, NULL, NULL},
1116         /* 16: CD_MLOOPUV */
1117         {sizeof(MLoopUV), "MLoopUV", 1, N_("UVMap"), NULL, NULL, layerInterp_mloopuv, NULL, NULL,
1118          layerEqual_mloopuv, layerMultiply_mloopuv, layerInitMinMax_mloopuv, 
1119          layerAdd_mloopuv, layerDoMinMax_mloopuv, layerCopyValue_mloopuv},
1120         /* 17: CD_MLOOPCOL */
1121         {sizeof(MLoopCol), "MLoopCol", 1, N_("Col"), NULL, NULL, layerInterp_mloopcol, NULL,
1122          layerDefault_mloopcol, layerEqual_mloopcol, layerMultiply_mloopcol, layerInitMinMax_mloopcol, 
1123          layerAdd_mloopcol, layerDoMinMax_mloopcol, layerCopyValue_mloopcol},
1124         /* 18: CD_TANGENT */
1125         {sizeof(float) * 4 * 4, "", 0, NULL, NULL, NULL, NULL, NULL, NULL},
1126         /* 19: CD_MDISPS */
1127         {sizeof(MDisps), "MDisps", 1, NULL, layerCopy_mdisps,
1128          layerFree_mdisps, NULL, layerSwap_mdisps, NULL,
1129          NULL, NULL, NULL, NULL, NULL, NULL, 
1130          layerRead_mdisps, layerWrite_mdisps, layerFilesize_mdisps},
1131         /* 20: CD_PREVIEW_MCOL */
1132         {sizeof(MCol) * 4, "MCol", 4, N_("PreviewCol"), NULL, NULL, layerInterp_mcol,
1133          layerSwap_mcol, layerDefault_mcol},
1134         /* 21: CD_ID_MCOL */
1135         {sizeof(MCol) * 4, "MCol", 4, N_("IDCol"), NULL, NULL, layerInterp_mcol,
1136          layerSwap_mcol, layerDefault_mcol},
1137         /* 22: CD_TEXTURE_MCOL */
1138         {sizeof(MCol) * 4, "MCol", 4, N_("TexturedCol"), NULL, NULL, layerInterp_mcol,
1139          layerSwap_mcol, layerDefault_mcol},
1140         /* 23: CD_CLOTH_ORCO */
1141         {sizeof(float) * 3, "", 0, NULL, NULL, NULL, NULL, NULL, NULL},
1142         /* 24: CD_RECAST */
1143         {sizeof(MRecast), "MRecast", 1, N_("Recast"), NULL, NULL, NULL, NULL},
1144
1145 /* BMESH ONLY */
1146         /* 25: CD_MPOLY */
1147         {sizeof(MPoly), "MPoly", 1, N_("NGon Face"), NULL, NULL, NULL, NULL, NULL},
1148         /* 26: CD_MLOOP */
1149         {sizeof(MLoop), "MLoop", 1, N_("NGon Face-Vertex"), NULL, NULL, NULL, NULL, NULL},
1150         /* 27: CD_SHAPE_KEYINDEX */
1151         {sizeof(int), "", 0, NULL, NULL, NULL, NULL, NULL, NULL},
1152         /* 28: CD_SHAPEKEY */
1153         {sizeof(float) * 3, "", 0, N_("ShapeKey"), NULL, NULL, layerInterp_shapekey},
1154         /* 29: CD_BWEIGHT */
1155         {sizeof(float), "", 0, N_("BevelWeight"), NULL, NULL, layerInterp_bweight},
1156         /* 30: CD_CREASE */
1157         {sizeof(float), "", 0, N_("SubSurfCrease"), NULL, NULL, layerInterp_bweight},
1158         /* 31: CD_ORIGSPACE_MLOOP */
1159         {sizeof(OrigSpaceLoop), "OrigSpaceLoop", 1, N_("OS Loop"), NULL, NULL, layerInterp_mloop_origspace, NULL, NULL,
1160          layerEqual_mloop_origspace, layerMultiply_mloop_origspace, layerInitMinMax_mloop_origspace,
1161          layerAdd_mloop_origspace, layerDoMinMax_mloop_origspace, layerCopyValue_mloop_origspace},
1162         /* 32: CD_PREVIEW_MLOOPCOL */
1163         {sizeof(MLoopCol), "MLoopCol", 1, N_("PreviewLoopCol"), NULL, NULL, layerInterp_mloopcol, NULL,
1164          layerDefault_mloopcol, layerEqual_mloopcol, layerMultiply_mloopcol, layerInitMinMax_mloopcol,
1165          layerAdd_mloopcol, layerDoMinMax_mloopcol, layerCopyValue_mloopcol},
1166         /* 33: CD_BM_ELEM_PYPTR */
1167         {sizeof(void *), "", 1, NULL, layerCopy_bmesh_elem_py_ptr,
1168          layerFree_bmesh_elem_py_ptr, NULL, NULL, NULL},
1169
1170 /* END BMESH ONLY */
1171
1172         /* 34: CD_PAINT_MASK */
1173         {sizeof(float), "", 0, NULL, NULL, NULL, NULL, NULL, NULL},
1174         /* 35: CD_GRID_PAINT_MASK */
1175         {sizeof(GridPaintMask), "GridPaintMask", 1, NULL, layerCopy_grid_paint_mask,
1176          layerFree_grid_paint_mask, NULL, NULL, NULL},
1177         /* 36: CD_SKIN_NODE */
1178         {sizeof(MVertSkin), "MVertSkin", 1, NULL, NULL, NULL,
1179          layerInterp_mvert_skin, NULL, layerDefault_mvert_skin},
1180         /* 37: CD_FREESTYLE_EDGE */
1181         {sizeof(FreestyleEdge), "FreestyleEdge", 1, NULL, NULL, NULL, NULL, NULL, NULL},
1182         /* 38: CD_FREESTYLE_FACE */
1183         {sizeof(FreestyleFace), "FreestyleFace", 1, NULL, NULL, NULL, NULL, NULL, NULL},
1184         /* 39: CD_MLOOPTANGENT */
1185         {sizeof(float[4]), "", 0, NULL, NULL, NULL, NULL, NULL, NULL},
1186         /* 40: CD_TESSLOOPNORMAL */
1187         {sizeof(short[4][3]), "", 0, NULL, NULL, NULL, NULL, layerSwap_flnor, NULL},
1188 };
1189
1190 /* note, numbers are from trunk and need updating for bmesh */
1191
1192 static const char *LAYERTYPENAMES[CD_NUMTYPES] = {
1193         /*   0-4 */ "CDMVert", "CDMSticky", "CDMDeformVert", "CDMEdge", "CDMFace",
1194         /*   5-9 */ "CDMTFace", "CDMCol", "CDOrigIndex", "CDNormal", "CDFlags",
1195         /* 10-14 */ "CDMFloatProperty", "CDMIntProperty", "CDMStringProperty", "CDOrigSpace", "CDOrco",
1196         /* 15-19 */ "CDMTexPoly", "CDMLoopUV", "CDMloopCol", "CDTangent", "CDMDisps",
1197         /* 20-24 */ "CDPreviewMCol", "CDIDMCol", "CDTextureMCol", "CDClothOrco", "CDMRecast",
1198
1199 /* BMESH ONLY */
1200         /* 25-29 */ "CDMPoly", "CDMLoop", "CDShapeKeyIndex", "CDShapeKey", "CDBevelWeight",
1201         /* 30-34 */ "CDSubSurfCrease", "CDOrigSpaceLoop", "CDPreviewLoopCol", "CDBMElemPyPtr", "CDPaintMask",
1202         /* 35-36 */ "CDGridPaintMask", "CDMVertSkin",
1203         /* 37-40 */ "CDFreestyleEdge", "CDFreestyleFace", "CDMLoopTangent", "CDTessLoopNormal",
1204 };
1205
1206
1207 const CustomDataMask CD_MASK_BAREMESH =
1208     CD_MASK_MVERT | CD_MASK_MEDGE | CD_MASK_MFACE | CD_MASK_MLOOP | CD_MASK_MPOLY | CD_MASK_BWEIGHT;
1209 const CustomDataMask CD_MASK_MESH =
1210     CD_MASK_MVERT | CD_MASK_MEDGE | CD_MASK_MFACE |
1211     CD_MASK_MSTICKY | CD_MASK_MDEFORMVERT | CD_MASK_MTFACE | CD_MASK_MCOL |
1212     CD_MASK_PROP_FLT | CD_MASK_PROP_INT | CD_MASK_PROP_STR | CD_MASK_MDISPS |
1213     CD_MASK_MLOOPUV | CD_MASK_MLOOPCOL | CD_MASK_MPOLY | CD_MASK_MLOOP |
1214     CD_MASK_MTEXPOLY | CD_MASK_RECAST | CD_MASK_PAINT_MASK |
1215     CD_MASK_GRID_PAINT_MASK | CD_MASK_MVERT_SKIN | CD_MASK_FREESTYLE_EDGE | CD_MASK_FREESTYLE_FACE;
1216 const CustomDataMask CD_MASK_EDITMESH =
1217     CD_MASK_MSTICKY | CD_MASK_MDEFORMVERT | CD_MASK_MTFACE | CD_MASK_MLOOPUV |
1218     CD_MASK_MLOOPCOL | CD_MASK_MTEXPOLY | CD_MASK_SHAPE_KEYINDEX |
1219     CD_MASK_MCOL | CD_MASK_PROP_FLT | CD_MASK_PROP_INT | CD_MASK_PROP_STR |
1220     CD_MASK_MDISPS | CD_MASK_SHAPEKEY | CD_MASK_RECAST | CD_MASK_PAINT_MASK |
1221     CD_MASK_GRID_PAINT_MASK | CD_MASK_MVERT_SKIN;
1222 const CustomDataMask CD_MASK_DERIVEDMESH =
1223     CD_MASK_MSTICKY | CD_MASK_MDEFORMVERT | CD_MASK_MTFACE |
1224     CD_MASK_MCOL | CD_MASK_PROP_FLT | CD_MASK_PROP_INT | CD_MASK_CLOTH_ORCO |
1225     CD_MASK_MLOOPUV | CD_MASK_MLOOPCOL | CD_MASK_MTEXPOLY | CD_MASK_PREVIEW_MLOOPCOL |
1226     CD_MASK_PROP_STR | CD_MASK_ORIGSPACE | CD_MASK_ORIGSPACE_MLOOP | CD_MASK_ORCO | CD_MASK_TANGENT |
1227     CD_MASK_PREVIEW_MCOL | CD_MASK_SHAPEKEY | CD_MASK_RECAST |
1228     CD_MASK_ORIGINDEX | CD_MASK_MVERT_SKIN | CD_MASK_FREESTYLE_EDGE | CD_MASK_FREESTYLE_FACE;
1229 const CustomDataMask CD_MASK_BMESH =
1230     CD_MASK_MLOOPUV | CD_MASK_MLOOPCOL | CD_MASK_MTEXPOLY |
1231     CD_MASK_MSTICKY | CD_MASK_MDEFORMVERT | CD_MASK_PROP_FLT | CD_MASK_PROP_INT |
1232     CD_MASK_PROP_STR | CD_MASK_SHAPEKEY | CD_MASK_SHAPE_KEYINDEX | CD_MASK_MDISPS |
1233     CD_MASK_CREASE | CD_MASK_BWEIGHT | CD_MASK_RECAST | CD_MASK_PAINT_MASK |
1234     CD_MASK_GRID_PAINT_MASK | CD_MASK_MVERT_SKIN | CD_MASK_FREESTYLE_EDGE | CD_MASK_FREESTYLE_FACE;
1235 const CustomDataMask CD_MASK_FACECORNERS =  /* XXX Not used anywhere! */
1236     CD_MASK_MTFACE | CD_MASK_MCOL | CD_MASK_MTEXPOLY | CD_MASK_MLOOPUV |
1237     CD_MASK_MLOOPCOL | CD_MASK_NORMAL | CD_MASK_MLOOPTANGENT;
1238 const CustomDataMask CD_MASK_EVERYTHING =
1239     CD_MASK_MVERT | CD_MASK_MSTICKY /* DEPRECATED */ | CD_MASK_MDEFORMVERT | CD_MASK_MEDGE | CD_MASK_MFACE |
1240     CD_MASK_MTFACE | CD_MASK_MCOL | CD_MASK_ORIGINDEX | CD_MASK_NORMAL /* | CD_MASK_POLYINDEX */ | CD_MASK_PROP_FLT |
1241     CD_MASK_PROP_INT | CD_MASK_PROP_STR | CD_MASK_ORIGSPACE | CD_MASK_ORCO | CD_MASK_MTEXPOLY | CD_MASK_MLOOPUV |
1242     CD_MASK_MLOOPCOL | CD_MASK_TANGENT | CD_MASK_MDISPS | CD_MASK_PREVIEW_MCOL | CD_MASK_CLOTH_ORCO | CD_MASK_RECAST |
1243     /* BMESH ONLY START */
1244     CD_MASK_MPOLY | CD_MASK_MLOOP | CD_MASK_SHAPE_KEYINDEX | CD_MASK_SHAPEKEY | CD_MASK_BWEIGHT | CD_MASK_CREASE |
1245     CD_MASK_ORIGSPACE_MLOOP | CD_MASK_PREVIEW_MLOOPCOL | CD_MASK_BM_ELEM_PYPTR |
1246     /* BMESH ONLY END */
1247     CD_MASK_PAINT_MASK | CD_MASK_GRID_PAINT_MASK | CD_MASK_MVERT_SKIN |
1248     CD_MASK_FREESTYLE_EDGE | CD_MASK_FREESTYLE_FACE |
1249     CD_MASK_MLOOPTANGENT | CD_MASK_TESSLOOPNORMAL;
1250
1251 static const LayerTypeInfo *layerType_getInfo(int type)
1252 {
1253         if (type < 0 || type >= CD_NUMTYPES) return NULL;
1254
1255         return &LAYERTYPEINFO[type];
1256 }
1257
1258 static const char *layerType_getName(int type)
1259 {
1260         if (type < 0 || type >= CD_NUMTYPES) return NULL;
1261
1262         return LAYERTYPENAMES[type];
1263 }
1264
1265 void customData_mask_layers__print(CustomDataMask mask)
1266 {
1267         int i;
1268
1269         printf("mask=0x%lx:\n", (long unsigned int)mask);
1270         for (i = 0; i < CD_NUMTYPES; i++) {
1271                 if (mask & CD_TYPE_AS_MASK(i)) {
1272                         printf("  %s\n", layerType_getName(i));
1273                 }
1274         }
1275 }
1276
1277 /********************* CustomData functions *********************/
1278 static void customData_update_offsets(CustomData *data);
1279
1280 static CustomDataLayer *customData_add_layer__internal(CustomData *data, int type, int alloctype, void *layerdata,
1281                                                        int totelem, const char *name);
1282
1283 void CustomData_update_typemap(CustomData *data)
1284 {
1285         int i, lasttype = -1;
1286
1287         for (i = 0; i < CD_NUMTYPES; i++) {
1288                 data->typemap[i] = -1;
1289         }
1290
1291         for (i = 0; i < data->totlayer; i++) {
1292                 if (data->layers[i].type != lasttype) {
1293                         data->typemap[data->layers[i].type] = i;
1294                 }
1295                 lasttype = data->layers[i].type;
1296         }
1297 }
1298
1299 /* currently only used in BLI_assert */
1300 #ifndef NDEBUG
1301 static bool customdata_typemap_is_valid(const CustomData *data)
1302 {
1303         CustomData data_copy = *data;
1304         CustomData_update_typemap(&data_copy);
1305         return (memcmp(data->typemap, data_copy.typemap, sizeof(data->typemap)) == 0);
1306 }
1307 #endif
1308
1309 bool CustomData_merge(const struct CustomData *source, struct CustomData *dest,
1310                       CustomDataMask mask, int alloctype, int totelem)
1311 {
1312         /*const LayerTypeInfo *typeInfo;*/
1313         CustomDataLayer *layer, *newlayer;
1314         void *data;
1315         int i, type, number = 0, lasttype = -1, lastactive = 0, lastrender = 0, lastclone = 0, lastmask = 0, lastflag = 0;
1316         bool changed = false;
1317
1318         for (i = 0; i < source->totlayer; ++i) {
1319                 layer = &source->layers[i];
1320                 /*typeInfo = layerType_getInfo(layer->type);*/ /*UNUSED*/
1321
1322                 type = layer->type;
1323
1324                 if (type != lasttype) {
1325                         number = 0;
1326                         lastactive = layer->active;
1327                         lastrender = layer->active_rnd;
1328                         lastclone = layer->active_clone;
1329                         lastmask = layer->active_mask;
1330                         lasttype = type;
1331                         lastflag = layer->flag;
1332                 }
1333                 else
1334                         number++;
1335
1336                 if (lastflag & CD_FLAG_NOCOPY) continue;
1337                 else if (!(mask & CD_TYPE_AS_MASK(type))) continue;
1338                 else if (CustomData_get_layer_named(dest, type, layer->name)) continue;
1339
1340                 switch (alloctype) {
1341                         case CD_ASSIGN:
1342                         case CD_REFERENCE:
1343                         case CD_DUPLICATE:
1344                                 data = layer->data;
1345                                 break;
1346                         default:
1347                                 data = NULL;
1348                                 break;
1349                 }
1350
1351                 if ((alloctype == CD_ASSIGN) && (lastflag & CD_FLAG_NOFREE))
1352                         newlayer = customData_add_layer__internal(dest, type, CD_REFERENCE,
1353                                                                   data, totelem, layer->name);
1354                 else
1355                         newlayer = customData_add_layer__internal(dest, type, alloctype,
1356                                                                   data, totelem, layer->name);
1357                 
1358                 if (newlayer) {
1359                         newlayer->uid = layer->uid;
1360                         
1361                         newlayer->active = lastactive;
1362                         newlayer->active_rnd = lastrender;
1363                         newlayer->active_clone = lastclone;
1364                         newlayer->active_mask = lastmask;
1365                         newlayer->flag |= lastflag & (CD_FLAG_EXTERNAL | CD_FLAG_IN_MEMORY);
1366                         changed = true;
1367                 }
1368         }
1369
1370         CustomData_update_typemap(dest);
1371         return changed;
1372 }
1373
1374 void CustomData_copy(const struct CustomData *source, struct CustomData *dest,
1375                      CustomDataMask mask, int alloctype, int totelem)
1376 {
1377         CustomData_reset(dest);
1378
1379         if (source->external)
1380                 dest->external = MEM_dupallocN(source->external);
1381
1382         CustomData_merge(source, dest, mask, alloctype, totelem);
1383 }
1384
1385 static void customData_free_layer__internal(CustomDataLayer *layer, int totelem)
1386 {
1387         const LayerTypeInfo *typeInfo;
1388
1389         if (!(layer->flag & CD_FLAG_NOFREE) && layer->data) {
1390                 typeInfo = layerType_getInfo(layer->type);
1391
1392                 if (typeInfo->free)
1393                         typeInfo->free(layer->data, totelem, typeInfo->size);
1394
1395                 if (layer->data)
1396                         MEM_freeN(layer->data);
1397         }
1398 }
1399
1400 static void CustomData_external_free(CustomData *data)
1401 {
1402         if (data->external) {
1403                 MEM_freeN(data->external);
1404                 data->external = NULL;
1405         }
1406 }
1407
1408 void CustomData_reset(CustomData *data)
1409 {
1410         memset(data, 0, sizeof(*data));
1411         fill_vn_i(data->typemap, CD_NUMTYPES, -1);
1412 }
1413
1414 void CustomData_free(CustomData *data, int totelem)
1415 {
1416         int i;
1417
1418         for (i = 0; i < data->totlayer; ++i)
1419                 customData_free_layer__internal(&data->layers[i], totelem);
1420
1421         if (data->layers)
1422                 MEM_freeN(data->layers);
1423         
1424         CustomData_external_free(data);
1425         CustomData_reset(data);
1426 }
1427
1428 static void customData_update_offsets(CustomData *data)
1429 {
1430         const LayerTypeInfo *typeInfo;
1431         int i, offset = 0;
1432
1433         for (i = 0; i < data->totlayer; ++i) {
1434                 typeInfo = layerType_getInfo(data->layers[i].type);
1435
1436                 data->layers[i].offset = offset;
1437                 offset += typeInfo->size;
1438         }
1439
1440         data->totsize = offset;
1441         CustomData_update_typemap(data);
1442 }
1443
1444 /* to use when we're in the middle of modifying layers */
1445 static int CustomData_get_layer_index__notypemap(const CustomData *data, int type)
1446 {
1447         int i;
1448
1449         for (i = 0; i < data->totlayer; ++i)
1450                 if (data->layers[i].type == type)
1451                         return i;
1452
1453         return -1;
1454 }
1455
1456 /* -------------------------------------------------------------------- */
1457 /* index values to access the layers (offset from the layer start) */
1458
1459 int CustomData_get_layer_index(const CustomData *data, int type)
1460 {
1461         BLI_assert(customdata_typemap_is_valid(data));
1462         return data->typemap[type];
1463 }
1464
1465 int CustomData_get_layer_index_n(const struct CustomData *data, int type, int n)
1466 {
1467         int i = CustomData_get_layer_index(data, type);
1468
1469         if (i != -1) {
1470                 BLI_assert(i + n < data->totlayer);
1471                 i = (data->layers[i + n].type == type) ? (i + n) : (-1);
1472         }
1473
1474         return i;
1475 }
1476
1477 int CustomData_get_named_layer_index(const CustomData *data, int type, const char *name)
1478 {
1479         int i;
1480
1481         for (i = 0; i < data->totlayer; ++i)
1482                 if (data->layers[i].type == type)
1483                         if (strcmp(data->layers[i].name, name) == 0)
1484                                 return i;
1485
1486         return -1;
1487 }
1488
1489 int CustomData_get_active_layer_index(const CustomData *data, int type)
1490 {
1491         const int layer_index = data->typemap[type];
1492         BLI_assert(customdata_typemap_is_valid(data));
1493         return (layer_index != -1) ? layer_index + data->layers[layer_index].active : -1;
1494 }
1495
1496 int CustomData_get_render_layer_index(const CustomData *data, int type)
1497 {
1498         const int layer_index = data->typemap[type];
1499         BLI_assert(customdata_typemap_is_valid(data));
1500         return (layer_index != -1) ? layer_index + data->layers[layer_index].active_rnd : -1;
1501 }
1502
1503 int CustomData_get_clone_layer_index(const CustomData *data, int type)
1504 {
1505         const int layer_index = data->typemap[type];
1506         BLI_assert(customdata_typemap_is_valid(data));
1507         return (layer_index != -1) ? layer_index + data->layers[layer_index].active_clone : -1;
1508 }
1509
1510 int CustomData_get_stencil_layer_index(const CustomData *data, int type)
1511 {
1512         const int layer_index = data->typemap[type];
1513         BLI_assert(customdata_typemap_is_valid(data));
1514         return (layer_index != -1) ? layer_index + data->layers[layer_index].active_mask : -1;
1515 }
1516
1517
1518 /* -------------------------------------------------------------------- */
1519 /* index values per layer type */
1520
1521 int CustomData_get_named_layer(const struct CustomData *data, int type, const char *name)
1522 {
1523         const int named_index = CustomData_get_named_layer_index(data, type, name);
1524         const int layer_index = data->typemap[type];
1525         BLI_assert(customdata_typemap_is_valid(data));
1526         return (named_index != -1) ? named_index - layer_index : -1;
1527 }
1528
1529 int CustomData_get_active_layer(const CustomData *data, int type)
1530 {
1531         const int layer_index = data->typemap[type];
1532         BLI_assert(customdata_typemap_is_valid(data));
1533         return (layer_index != -1) ? data->layers[layer_index].active : -1;
1534 }
1535
1536 int CustomData_get_render_layer(const CustomData *data, int type)
1537 {
1538         const int layer_index = data->typemap[type];
1539         BLI_assert(customdata_typemap_is_valid(data));
1540         return (layer_index != -1) ? data->layers[layer_index].active_rnd : -1;
1541 }
1542
1543 int CustomData_get_clone_layer(const CustomData *data, int type)
1544 {
1545         const int layer_index = data->typemap[type];
1546         BLI_assert(customdata_typemap_is_valid(data));
1547         return (layer_index != -1) ? data->layers[layer_index].active_clone : -1;
1548 }
1549
1550 int CustomData_get_stencil_layer(const CustomData *data, int type)
1551 {
1552         const int layer_index = data->typemap[type];
1553         BLI_assert(customdata_typemap_is_valid(data));
1554         return (layer_index != -1) ? data->layers[layer_index].active_mask : -1;
1555 }
1556
1557 void CustomData_set_layer_active(CustomData *data, int type, int n)
1558 {
1559         int i;
1560
1561         for (i = 0; i < data->totlayer; ++i)
1562                 if (data->layers[i].type == type)
1563                         data->layers[i].active = n;
1564 }
1565
1566 void CustomData_set_layer_render(CustomData *data, int type, int n)
1567 {
1568         int i;
1569
1570         for (i = 0; i < data->totlayer; ++i)
1571                 if (data->layers[i].type == type)
1572                         data->layers[i].active_rnd = n;
1573 }
1574
1575 void CustomData_set_layer_clone(CustomData *data, int type, int n)
1576 {
1577         int i;
1578
1579         for (i = 0; i < data->totlayer; ++i)
1580                 if (data->layers[i].type == type)
1581                         data->layers[i].active_clone = n;
1582 }
1583
1584 void CustomData_set_layer_stencil(CustomData *data, int type, int n)
1585 {
1586         int i;
1587
1588         for (i = 0; i < data->totlayer; ++i)
1589                 if (data->layers[i].type == type)
1590                         data->layers[i].active_mask = n;
1591 }
1592
1593 /* for using with an index from CustomData_get_active_layer_index and CustomData_get_render_layer_index */
1594 void CustomData_set_layer_active_index(CustomData *data, int type, int n)
1595 {
1596         int i;
1597
1598         for (i = 0; i < data->totlayer; ++i)
1599                 if (data->layers[i].type == type)
1600                         data->layers[i].active = n - i;
1601 }
1602
1603 void CustomData_set_layer_render_index(CustomData *data, int type, int n)
1604 {
1605         int i;
1606
1607         for (i = 0; i < data->totlayer; ++i)
1608                 if (data->layers[i].type == type)
1609                         data->layers[i].active_rnd = n - i;
1610 }
1611
1612 void CustomData_set_layer_clone_index(CustomData *data, int type, int n)
1613 {
1614         int i;
1615
1616         for (i = 0; i < data->totlayer; ++i)
1617                 if (data->layers[i].type == type)
1618                         data->layers[i].active_clone = n - i;
1619 }
1620
1621 void CustomData_set_layer_stencil_index(CustomData *data, int type, int n)
1622 {
1623         int i;
1624
1625         for (i = 0; i < data->totlayer; ++i)
1626                 if (data->layers[i].type == type)
1627                         data->layers[i].active_mask = n - i;
1628 }
1629
1630 void CustomData_set_layer_flag(struct CustomData *data, int type, int flag)
1631 {
1632         int i;
1633
1634         for (i = 0; i < data->totlayer; ++i)
1635                 if (data->layers[i].type == type)
1636                         data->layers[i].flag |= flag;
1637 }
1638
1639 static int customData_resize(CustomData *data, int amount)
1640 {
1641         CustomDataLayer *tmp = MEM_callocN(sizeof(*tmp) * (data->maxlayer + amount),
1642                                            "CustomData->layers");
1643         if (!tmp) return 0;
1644
1645         data->maxlayer += amount;
1646         if (data->layers) {
1647                 memcpy(tmp, data->layers, sizeof(*tmp) * data->totlayer);
1648                 MEM_freeN(data->layers);
1649         }
1650         data->layers = tmp;
1651
1652         return 1;
1653 }
1654
1655 static CustomDataLayer *customData_add_layer__internal(CustomData *data, int type, int alloctype, void *layerdata,
1656                                                        int totelem, const char *name)
1657 {
1658         const LayerTypeInfo *typeInfo = layerType_getInfo(type);
1659         int size = typeInfo->size * totelem, flag = 0, index = data->totlayer;
1660         void *newlayerdata = NULL;
1661
1662         /* Passing a layerdata to copy from with an alloctype that won't copy is
1663          * most likely a bug */
1664         BLI_assert(!layerdata ||
1665                    (alloctype == CD_ASSIGN) ||
1666                    (alloctype == CD_DUPLICATE) ||
1667                    (alloctype == CD_REFERENCE));
1668
1669         BLI_assert(size >= 0);
1670
1671         if (!typeInfo->defaultname && CustomData_has_layer(data, type))
1672                 return &data->layers[CustomData_get_layer_index(data, type)];
1673
1674         if ((alloctype == CD_ASSIGN) || (alloctype == CD_REFERENCE)) {
1675                 newlayerdata = layerdata;
1676         }
1677         else if (size > 0) {
1678                 newlayerdata = MEM_callocN(size, layerType_getName(type));
1679                 if (!newlayerdata)
1680                         return NULL;
1681         }
1682
1683         if (alloctype == CD_DUPLICATE && layerdata) {
1684                 if (typeInfo->copy)
1685                         typeInfo->copy(layerdata, newlayerdata, totelem);
1686                 else
1687                         memcpy(newlayerdata, layerdata, size);
1688         }
1689         else if (alloctype == CD_DEFAULT) {
1690                 if (typeInfo->set_default)
1691                         typeInfo->set_default((char *)newlayerdata, totelem);
1692         }
1693         else if (alloctype == CD_REFERENCE)
1694                 flag |= CD_FLAG_NOFREE;
1695
1696         if (index >= data->maxlayer) {
1697                 if (!customData_resize(data, CUSTOMDATA_GROW)) {
1698                         if (newlayerdata != layerdata)
1699                                 MEM_freeN(newlayerdata);
1700                         return NULL;
1701                 }
1702         }
1703         
1704         data->totlayer++;
1705
1706         /* keep layers ordered by type */
1707         for (; index > 0 && data->layers[index - 1].type > type; --index)
1708                 data->layers[index] = data->layers[index - 1];
1709
1710         data->layers[index].type = type;
1711         data->layers[index].flag = flag;
1712         data->layers[index].data = newlayerdata;
1713
1714         if (name || (name = DATA_(typeInfo->defaultname))) {
1715                 BLI_strncpy(data->layers[index].name, name, sizeof(data->layers[index].name));
1716                 CustomData_set_layer_unique_name(data, index);
1717         }
1718         else
1719                 data->layers[index].name[0] = '\0';
1720
1721         if (index > 0 && data->layers[index - 1].type == type) {
1722                 data->layers[index].active = data->layers[index - 1].active;
1723                 data->layers[index].active_rnd = data->layers[index - 1].active_rnd;
1724                 data->layers[index].active_clone = data->layers[index - 1].active_clone;
1725                 data->layers[index].active_mask = data->layers[index - 1].active_mask;
1726         }
1727         else {
1728                 data->layers[index].active = 0;
1729                 data->layers[index].active_rnd = 0;
1730                 data->layers[index].active_clone = 0;
1731                 data->layers[index].active_mask = 0;
1732         }
1733         
1734         customData_update_offsets(data);
1735
1736         return &data->layers[index];
1737 }
1738
1739 void *CustomData_add_layer(CustomData *data, int type, int alloctype,
1740                            void *layerdata, int totelem)
1741 {
1742         CustomDataLayer *layer;
1743         const LayerTypeInfo *typeInfo = layerType_getInfo(type);
1744         
1745         layer = customData_add_layer__internal(data, type, alloctype, layerdata,
1746                                                totelem, typeInfo->defaultname);
1747         CustomData_update_typemap(data);
1748
1749         if (layer)
1750                 return layer->data;
1751
1752         return NULL;
1753 }
1754
1755 /*same as above but accepts a name*/
1756 void *CustomData_add_layer_named(CustomData *data, int type, int alloctype,
1757                                  void *layerdata, int totelem, const char *name)
1758 {
1759         CustomDataLayer *layer;
1760         
1761         layer = customData_add_layer__internal(data, type, alloctype, layerdata,
1762                                                totelem, name);
1763         CustomData_update_typemap(data);
1764
1765         if (layer)
1766                 return layer->data;
1767
1768         return NULL;
1769 }
1770
1771
1772 bool CustomData_free_layer(CustomData *data, int type, int totelem, int index)
1773 {
1774         const int n = index - CustomData_get_layer_index(data, type);
1775         int i;
1776         
1777         if (index < 0) return 0;
1778
1779         customData_free_layer__internal(&data->layers[index], totelem);
1780
1781         for (i = index + 1; i < data->totlayer; ++i)
1782                 data->layers[i - 1] = data->layers[i];
1783
1784         data->totlayer--;
1785
1786         /* if layer was last of type in array, set new active layer */
1787         i = CustomData_get_layer_index__notypemap(data, type);
1788
1789         if (i != -1) {
1790                 /* don't decrement zero index */
1791                 const int index_nonzero = n ? n : 1;
1792                 CustomDataLayer *layer;
1793
1794                 for (layer = &data->layers[i]; i < data->totlayer && layer->type == type; i++, layer++) {
1795                         if (layer->active       >= index_nonzero) layer->active--;
1796                         if (layer->active_rnd   >= index_nonzero) layer->active_rnd--;
1797                         if (layer->active_clone >= index_nonzero) layer->active_clone--;
1798                         if (layer->active_mask  >= index_nonzero) layer->active_mask--;
1799                 }
1800         }
1801
1802         if (data->totlayer <= data->maxlayer - CUSTOMDATA_GROW)
1803                 customData_resize(data, -CUSTOMDATA_GROW);
1804
1805         customData_update_offsets(data);
1806
1807         return 1;
1808 }
1809
1810 bool CustomData_free_layer_active(CustomData *data, int type, int totelem)
1811 {
1812         int index = 0;
1813         index = CustomData_get_active_layer_index(data, type);
1814         if (index == -1) return 0;
1815         return CustomData_free_layer(data, type, totelem, index);
1816 }
1817
1818
1819 void CustomData_free_layers(CustomData *data, int type, int totelem)
1820 {
1821         while (CustomData_has_layer(data, type))
1822                 CustomData_free_layer_active(data, type, totelem);
1823 }
1824
1825 bool CustomData_has_layer(const CustomData *data, int type)
1826 {
1827         return (CustomData_get_layer_index(data, type) != -1);
1828 }
1829
1830 int CustomData_number_of_layers(const CustomData *data, int type)
1831 {
1832         int i, number = 0;
1833
1834         for (i = 0; i < data->totlayer; i++)
1835                 if (data->layers[i].type == type)
1836                         number++;
1837         
1838         return number;
1839 }
1840
1841 int CustomData_number_of_layers_typemask(const CustomData *data, CustomDataMask mask)
1842 {
1843         int i, number = 0;
1844
1845         for (i = 0; i < data->totlayer; i++)
1846                 if (mask & CD_TYPE_AS_MASK(data->layers[i].type))
1847                         number++;
1848
1849         return number;
1850 }
1851
1852 void *CustomData_duplicate_referenced_layer(struct CustomData *data, const int type, const int totelem)
1853 {
1854         CustomDataLayer *layer;
1855         int layer_index;
1856
1857         /* get the layer index of the first layer of type */
1858         layer_index = CustomData_get_active_layer_index(data, type);
1859         if (layer_index == -1) return NULL;
1860
1861         layer = &data->layers[layer_index];
1862
1863         if (layer->flag & CD_FLAG_NOFREE) {
1864                 /* MEM_dupallocN won't work in case of complex layers, like e.g.
1865                  * CD_MDEFORMVERT, which has pointers to allocated data...
1866                  * So in case a custom copy function is defined, use it!
1867                  */
1868                 const LayerTypeInfo *typeInfo = layerType_getInfo(layer->type);
1869
1870                 if (typeInfo->copy) {
1871                         char *dest_data = MEM_mallocN(typeInfo->size * totelem, "CD duplicate ref layer");
1872                         typeInfo->copy(layer->data, dest_data, totelem);
1873                         layer->data = dest_data;
1874                 }
1875                 else
1876                         layer->data = MEM_dupallocN(layer->data);
1877
1878                 layer->flag &= ~CD_FLAG_NOFREE;
1879         }
1880
1881         return layer->data;
1882 }
1883
1884 void *CustomData_duplicate_referenced_layer_named(struct CustomData *data,
1885                                                   const int type, const char *name, const int totelem)
1886 {
1887         CustomDataLayer *layer;
1888         int layer_index;
1889
1890         /* get the layer index of the desired layer */
1891         layer_index = CustomData_get_named_layer_index(data, type, name);
1892         if (layer_index == -1) return NULL;
1893
1894         layer = &data->layers[layer_index];
1895
1896         if (layer->flag & CD_FLAG_NOFREE) {
1897                 /* MEM_dupallocN won't work in case of complex layers, like e.g.
1898                  * CD_MDEFORMVERT, which has pointers to allocated data...
1899                  * So in case a custom copy function is defined, use it!
1900                  */
1901                 const LayerTypeInfo *typeInfo = layerType_getInfo(layer->type);
1902
1903                 if (typeInfo->copy) {
1904                         char *dest_data = MEM_mallocN(typeInfo->size * totelem, "CD duplicate ref layer");
1905                         typeInfo->copy(layer->data, dest_data, totelem);
1906                         layer->data = dest_data;
1907                 }
1908                 else
1909                         layer->data = MEM_dupallocN(layer->data);
1910
1911                 layer->flag &= ~CD_FLAG_NOFREE;
1912         }
1913
1914         return layer->data;
1915 }
1916
1917 bool CustomData_is_referenced_layer(struct CustomData *data, int type)
1918 {
1919         CustomDataLayer *layer;
1920         int layer_index;
1921
1922         /* get the layer index of the first layer of type */
1923         layer_index = CustomData_get_active_layer_index(data, type);
1924         if (layer_index == -1) return 0;
1925
1926         layer = &data->layers[layer_index];
1927
1928         return (layer->flag & CD_FLAG_NOFREE) != 0;
1929 }
1930
1931 void CustomData_free_temporary(CustomData *data, int totelem)
1932 {
1933         CustomDataLayer *layer;
1934         int i, j;
1935         bool changed = false;
1936
1937         for (i = 0, j = 0; i < data->totlayer; ++i) {
1938                 layer = &data->layers[i];
1939
1940                 if (i != j)
1941                         data->layers[j] = data->layers[i];
1942
1943                 if ((layer->flag & CD_FLAG_TEMPORARY) == CD_FLAG_TEMPORARY) {
1944                         customData_free_layer__internal(layer, totelem);
1945                         changed = true;
1946                 }
1947                 else
1948                         j++;
1949         }
1950
1951         data->totlayer = j;
1952
1953         if (data->totlayer <= data->maxlayer - CUSTOMDATA_GROW) {
1954                 customData_resize(data, -CUSTOMDATA_GROW);
1955                 changed = true;
1956         }
1957
1958         if (changed) {
1959                 customData_update_offsets(data);
1960         }
1961 }
1962
1963 void CustomData_set_only_copy(const struct CustomData *data,
1964                               CustomDataMask mask)
1965 {
1966         int i;
1967
1968         for (i = 0; i < data->totlayer; ++i)
1969                 if (!(mask & CD_TYPE_AS_MASK(data->layers[i].type)))
1970                         data->layers[i].flag |= CD_FLAG_NOCOPY;
1971 }
1972
1973 void CustomData_copy_elements(int type, void *source, void *dest, int count)
1974 {
1975         const LayerTypeInfo *typeInfo = layerType_getInfo(type);
1976
1977         if (typeInfo->copy)
1978                 typeInfo->copy(source, dest, count);
1979         else
1980                 memcpy(dest, source, typeInfo->size * count);
1981 }
1982
1983 static void CustomData_copy_data_layer(const CustomData *source, CustomData *dest,
1984                                        int src_i, int dest_i,
1985                                        int source_index, int dest_index, int count) {
1986         const LayerTypeInfo *typeInfo;
1987         int src_offset;
1988         int dest_offset;
1989
1990         char *src_data = source->layers[src_i].data;
1991         char *dest_data = dest->layers[dest_i].data;
1992
1993         typeInfo = layerType_getInfo(source->layers[src_i].type);
1994
1995         src_offset = source_index * typeInfo->size;
1996         dest_offset = dest_index * typeInfo->size;
1997
1998         if (!src_data || !dest_data) {
1999                 if (!(src_data == NULL && dest_data == NULL)) {
2000                         printf("%s: warning null data for %s type (%p --> %p), skipping\n",
2001                                    __func__, layerType_getName(source->layers[src_i].type),
2002                                    (void *)src_data, (void *)dest_data);
2003                 }
2004                 return;
2005         }
2006
2007         if (typeInfo->copy)
2008                 typeInfo->copy(src_data + src_offset,
2009                                dest_data + dest_offset,
2010                                count);
2011         else
2012                 memcpy(dest_data + dest_offset,
2013                        src_data + src_offset,
2014                        count * typeInfo->size);
2015 }
2016
2017 void CustomData_copy_data_named(const CustomData *source, CustomData *dest,
2018                                 int source_index, int dest_index, int count)
2019 {
2020         int src_i, dest_i;
2021
2022         /* copies a layer at a time */
2023         for (src_i = 0; src_i < source->totlayer; ++src_i) {
2024
2025                 dest_i = CustomData_get_named_layer_index(dest, source->layers[src_i].type, source->layers[src_i].name);
2026
2027                 /* if we found a matching layer, copy the data */
2028                 if (dest_i != -1) {
2029                         CustomData_copy_data_layer(source, dest, src_i, dest_i, source_index, dest_index, count);
2030                 }
2031         }
2032 }
2033
2034 void CustomData_copy_data(const CustomData *source, CustomData *dest,
2035                           int source_index, int dest_index, int count)
2036 {
2037         int src_i, dest_i;
2038
2039         /* copies a layer at a time */
2040         dest_i = 0;
2041         for (src_i = 0; src_i < source->totlayer; ++src_i) {
2042
2043                 /* find the first dest layer with type >= the source type
2044                  * (this should work because layers are ordered by type)
2045                  */
2046                 while (dest_i < dest->totlayer && dest->layers[dest_i].type < source->layers[src_i].type) {
2047                         dest_i++;
2048                 }
2049
2050                 /* if there are no more dest layers, we're done */
2051                 if (dest_i >= dest->totlayer) return;
2052
2053                 /* if we found a matching layer, copy the data */
2054                 if (dest->layers[dest_i].type == source->layers[src_i].type) {
2055                         CustomData_copy_data_layer(source, dest, src_i, dest_i, source_index, dest_index, count);
2056                         
2057                         /* if there are multiple source & dest layers of the same type,
2058                          * we don't want to copy all source layers to the same dest, so
2059                          * increment dest_i
2060                          */
2061                         dest_i++;
2062                 }
2063         }
2064 }
2065
2066 void CustomData_free_elem(CustomData *data, int index, int count)
2067 {
2068         int i;
2069         const LayerTypeInfo *typeInfo;
2070
2071         for (i = 0; i < data->totlayer; ++i) {
2072                 if (!(data->layers[i].flag & CD_FLAG_NOFREE)) {
2073                         typeInfo = layerType_getInfo(data->layers[i].type);
2074
2075                         if (typeInfo->free) {
2076                                 int offset = typeInfo->size * index;
2077
2078                                 typeInfo->free((char *)data->layers[i].data + offset,
2079                                                count, typeInfo->size);
2080                         }
2081                 }
2082         }
2083 }
2084
2085 #define SOURCE_BUF_SIZE 100
2086
2087 void CustomData_interp(const CustomData *source, CustomData *dest,
2088                        int *src_indices, float *weights, float *sub_weights,
2089                        int count, int dest_index)
2090 {
2091         int src_i, dest_i;
2092         int dest_offset;
2093         int j;
2094         void *source_buf[SOURCE_BUF_SIZE];
2095         void **sources = source_buf;
2096
2097         /* slow fallback in case we're interpolating a ridiculous number of
2098          * elements
2099          */
2100         if (count > SOURCE_BUF_SIZE)
2101                 sources = MEM_callocN(sizeof(*sources) * count,
2102                                       "CustomData_interp sources");
2103
2104         /* interpolates a layer at a time */
2105         dest_i = 0;
2106         for (src_i = 0; src_i < source->totlayer; ++src_i) {
2107                 const LayerTypeInfo *typeInfo = layerType_getInfo(source->layers[src_i].type);
2108                 if (!typeInfo->interp) continue;
2109
2110                 /* find the first dest layer with type >= the source type
2111                  * (this should work because layers are ordered by type)
2112                  */
2113                 while (dest_i < dest->totlayer && dest->layers[dest_i].type < source->layers[src_i].type) {
2114                         dest_i++;
2115                 }
2116
2117                 /* if there are no more dest layers, we're done */
2118                 if (dest_i >= dest->totlayer) break;
2119
2120                 /* if we found a matching layer, copy the data */
2121                 if (dest->layers[dest_i].type == source->layers[src_i].type) {
2122                         void *src_data = source->layers[src_i].data;
2123
2124                         for (j = 0; j < count; ++j) {
2125                                 sources[j] = (char *)src_data + typeInfo->size * src_indices[j];
2126                         }
2127
2128                         dest_offset = dest_index * typeInfo->size;
2129
2130                         typeInfo->interp(sources, weights, sub_weights, count,
2131                                          (char *)dest->layers[dest_i].data + dest_offset);
2132
2133                         /* if there are multiple source & dest layers of the same type,
2134                          * we don't want to copy all source layers to the same dest, so
2135                          * increment dest_i
2136                          */
2137                         dest_i++;
2138                 }
2139         }
2140
2141         if (count > SOURCE_BUF_SIZE) MEM_freeN(sources);
2142 }
2143
2144 void CustomData_swap(struct CustomData *data, int index, const int *corner_indices)
2145 {
2146         const LayerTypeInfo *typeInfo;
2147         int i;
2148
2149         for (i = 0; i < data->totlayer; ++i) {
2150                 typeInfo = layerType_getInfo(data->layers[i].type);
2151
2152                 if (typeInfo->swap) {
2153                         int offset = typeInfo->size * index;
2154
2155                         typeInfo->swap((char *)data->layers[i].data + offset, corner_indices);
2156                 }
2157         }
2158 }
2159
2160 void *CustomData_get(const CustomData *data, int index, int type)
2161 {
2162         int offset;
2163         int layer_index;
2164         
2165         BLI_assert(index >= 0);
2166
2167         /* get the layer index of the active layer of type */
2168         layer_index = CustomData_get_active_layer_index(data, type);
2169         if (layer_index == -1) return NULL;
2170
2171         /* get the offset of the desired element */
2172         offset = layerType_getInfo(type)->size * index;
2173
2174         return (char *)data->layers[layer_index].data + offset;
2175 }
2176
2177 void *CustomData_get_n(const CustomData *data, int type, int index, int n)
2178 {
2179         int layer_index;
2180         int offset;
2181
2182         BLI_assert(index >= 0 && n >= 0);
2183
2184         /* get the layer index of the first layer of type */
2185         layer_index = data->typemap[type];
2186         if (layer_index == -1) return NULL;
2187
2188         offset = layerType_getInfo(type)->size * index;
2189         return (char *)data->layers[layer_index + n].data + offset;
2190 }
2191
2192 void *CustomData_get_layer(const CustomData *data, int type)
2193 {
2194         /* get the layer index of the active layer of type */
2195         int layer_index = CustomData_get_active_layer_index(data, type);
2196         if (layer_index == -1) return NULL;
2197
2198         return data->layers[layer_index].data;
2199 }
2200
2201 void *CustomData_get_layer_n(const CustomData *data, int type, int n)
2202 {
2203         /* get the layer index of the active layer of type */
2204         int layer_index = CustomData_get_layer_index_n(data, type, n);
2205         if (layer_index == -1) return NULL;
2206
2207         return data->layers[layer_index].data;
2208 }
2209
2210 void *CustomData_get_layer_named(const struct CustomData *data, int type,
2211                                  const char *name)
2212 {
2213         int layer_index = CustomData_get_named_layer_index(data, type, name);
2214         if (layer_index == -1) return NULL;
2215
2216         return data->layers[layer_index].data;
2217 }
2218
2219 int CustomData_get_offset(const CustomData *data, int type)
2220 {
2221         /* get the layer index of the active layer of type */
2222         int layer_index = CustomData_get_active_layer_index(data, type);
2223         if (layer_index == -1) return -1;
2224
2225         return data->layers[layer_index].offset;
2226 }
2227
2228 int CustomData_get_n_offset(const CustomData *data, int type, int n)
2229 {
2230         /* get the layer index of the active layer of type */
2231         int layer_index = CustomData_get_layer_index_n(data, type, n);
2232         if (layer_index == -1) return -1;
2233
2234         return data->layers[layer_index].offset;
2235 }
2236
2237 bool CustomData_set_layer_name(const CustomData *data, int type, int n, const char *name)
2238 {
2239         /* get the layer index of the first layer of type */
2240         int layer_index = CustomData_get_layer_index_n(data, type, n);
2241
2242         if (layer_index == -1) return false;
2243         if (!name) return false;
2244         
2245         BLI_strncpy(data->layers[layer_index].name, name, sizeof(data->layers[layer_index].name));
2246         
2247         return true;
2248 }
2249
2250 void *CustomData_set_layer(const CustomData *data, int type, void *ptr)
2251 {
2252         /* get the layer index of the first layer of type */
2253         int layer_index = CustomData_get_active_layer_index(data, type);
2254
2255         if (layer_index == -1) return NULL;
2256
2257         data->layers[layer_index].data = ptr;
2258
2259         return ptr;
2260 }
2261
2262 void *CustomData_set_layer_n(const struct CustomData *data, int type, int n, void *ptr)
2263 {
2264         /* get the layer index of the first layer of type */
2265         int layer_index = CustomData_get_layer_index_n(data, type, n);
2266         if (layer_index == -1) return NULL;
2267
2268         data->layers[layer_index].data = ptr;
2269
2270         return ptr;
2271 }
2272
2273 void CustomData_set(const CustomData *data, int index, int type, void *source)
2274 {
2275         void *dest = CustomData_get(data, index, type);
2276         const LayerTypeInfo *typeInfo = layerType_getInfo(type);
2277
2278         if (!dest) return;
2279
2280         if (typeInfo->copy)
2281                 typeInfo->copy(source, dest, 1);
2282         else
2283                 memcpy(dest, source, typeInfo->size);
2284 }
2285
2286 /* BMesh functions */
2287 /* needed to convert to/from different face reps */
2288 void CustomData_to_bmeshpoly(CustomData *fdata, CustomData *pdata, CustomData *ldata,
2289                              int totloop, int totpoly)
2290 {
2291         int i;
2292         for (i = 0; i < fdata->totlayer; i++) {
2293                 if (fdata->layers[i].type == CD_MTFACE) {
2294                         CustomData_add_layer_named(pdata, CD_MTEXPOLY, CD_CALLOC, NULL, totpoly, fdata->layers[i].name);
2295                         CustomData_add_layer_named(ldata, CD_MLOOPUV, CD_CALLOC, NULL, totloop, fdata->layers[i].name);
2296                 }
2297                 else if (fdata->layers[i].type == CD_MCOL) {
2298                         CustomData_add_layer_named(ldata, CD_MLOOPCOL, CD_CALLOC, NULL, totloop, fdata->layers[i].name);
2299                 }
2300                 else if (fdata->layers[i].type == CD_MDISPS) {
2301                         CustomData_add_layer_named(ldata, CD_MDISPS, CD_CALLOC, NULL, totloop, fdata->layers[i].name);
2302                 }
2303                 else if (fdata->layers[i].type == CD_TESSLOOPNORMAL) {
2304                         CustomData_add_layer_named(ldata, CD_NORMAL, CD_CALLOC, NULL, totloop, fdata->layers[i].name);
2305                 }
2306         }
2307 }
2308
2309 void CustomData_from_bmeshpoly(CustomData *fdata, CustomData *pdata, CustomData *ldata, int total)
2310 {
2311         int i;
2312         for (i = 0; i < pdata->totlayer; i++) {
2313                 if (pdata->layers[i].type == CD_MTEXPOLY) {
2314                         CustomData_add_layer_named(fdata, CD_MTFACE, CD_CALLOC, NULL, total, pdata->layers[i].name);
2315                 }
2316         }
2317         for (i = 0; i < ldata->totlayer; i++) {
2318                 if (ldata->layers[i].type == CD_MLOOPCOL) {
2319                         CustomData_add_layer_named(fdata, CD_MCOL, CD_CALLOC, NULL, total, ldata->layers[i].name);
2320                 }
2321                 else if (ldata->layers[i].type == CD_PREVIEW_MLOOPCOL) {
2322                         CustomData_add_layer_named(fdata, CD_PREVIEW_MCOL, CD_CALLOC, NULL, total, ldata->layers[i].name);
2323                 }
2324                 else if (ldata->layers[i].type == CD_ORIGSPACE_MLOOP) {
2325                         CustomData_add_layer_named(fdata, CD_ORIGSPACE, CD_CALLOC, NULL, total, ldata->layers[i].name);
2326                 }
2327                 else if (ldata->layers[i].type == CD_NORMAL) {
2328                         CustomData_add_layer_named(fdata, CD_TESSLOOPNORMAL, CD_CALLOC, NULL, total, ldata->layers[i].name);
2329                 }
2330         }
2331
2332         CustomData_bmesh_update_active_layers(fdata, pdata, ldata);
2333 }
2334
2335 void CustomData_bmesh_update_active_layers(CustomData *fdata, CustomData *pdata, CustomData *ldata)
2336 {
2337         int act;
2338
2339         if (CustomData_has_layer(pdata, CD_MTEXPOLY)) {
2340                 act = CustomData_get_active_layer(pdata, CD_MTEXPOLY);
2341                 CustomData_set_layer_active(ldata, CD_MLOOPUV, act);
2342                 CustomData_set_layer_active(fdata, CD_MTFACE, act);
2343
2344                 act = CustomData_get_render_layer(pdata, CD_MTEXPOLY);
2345                 CustomData_set_layer_render(ldata, CD_MLOOPUV, act);
2346                 CustomData_set_layer_render(fdata, CD_MTFACE, act);
2347
2348                 act = CustomData_get_clone_layer(pdata, CD_MTEXPOLY);
2349                 CustomData_set_layer_clone(ldata, CD_MLOOPUV, act);
2350                 CustomData_set_layer_clone(fdata, CD_MTFACE, act);
2351
2352                 act = CustomData_get_stencil_layer(pdata, CD_MTEXPOLY);
2353                 CustomData_set_layer_stencil(ldata, CD_MLOOPUV, act);
2354                 CustomData_set_layer_stencil(fdata, CD_MTFACE, act);
2355         }
2356
2357         if (CustomData_has_layer(ldata, CD_MLOOPCOL)) {
2358                 act = CustomData_get_active_layer(ldata, CD_MLOOPCOL);
2359                 CustomData_set_layer_active(fdata, CD_MCOL, act);
2360
2361                 act = CustomData_get_render_layer(ldata, CD_MLOOPCOL);
2362                 CustomData_set_layer_render(fdata, CD_MCOL, act);
2363
2364                 act = CustomData_get_clone_layer(ldata, CD_MLOOPCOL);
2365                 CustomData_set_layer_clone(fdata, CD_MCOL, act);
2366
2367                 act = CustomData_get_stencil_layer(ldata, CD_MLOOPCOL);
2368                 CustomData_set_layer_stencil(fdata, CD_MCOL, act);
2369         }
2370 }
2371
2372 /* update active indices for active/render/clone/stencil custom data layers
2373  * based on indices from fdata layers
2374  * used by do_versions in readfile.c when creating pdata and ldata for pre-bmesh
2375  * meshes and needed to preserve active/render/clone/stencil flags set in pre-bmesh files
2376  */
2377 void CustomData_bmesh_do_versions_update_active_layers(CustomData *fdata, CustomData *pdata, CustomData *ldata)
2378 {
2379         int act;
2380
2381         if (CustomData_has_layer(fdata, CD_MTFACE)) {
2382                 act = CustomData_get_active_layer(fdata, CD_MTFACE);
2383                 CustomData_set_layer_active(pdata, CD_MTEXPOLY, act);
2384                 CustomData_set_layer_active(ldata, CD_MLOOPUV, act);
2385
2386                 act = CustomData_get_render_layer(fdata, CD_MTFACE);
2387                 CustomData_set_layer_render(pdata, CD_MTEXPOLY, act);
2388                 CustomData_set_layer_render(ldata, CD_MLOOPUV, act);
2389
2390                 act = CustomData_get_clone_layer(fdata, CD_MTFACE);
2391                 CustomData_set_layer_clone(pdata, CD_MTEXPOLY, act);
2392                 CustomData_set_layer_clone(ldata, CD_MLOOPUV, act);
2393
2394                 act = CustomData_get_stencil_layer(fdata, CD_MTFACE);
2395                 CustomData_set_layer_stencil(pdata, CD_MTEXPOLY, act);
2396                 CustomData_set_layer_stencil(ldata, CD_MLOOPUV, act);
2397         }
2398
2399         if (CustomData_has_layer(fdata, CD_MCOL)) {
2400                 act = CustomData_get_active_layer(fdata, CD_MCOL);
2401                 CustomData_set_layer_active(ldata, CD_MLOOPCOL, act);
2402
2403                 act = CustomData_get_render_layer(fdata, CD_MCOL);
2404                 CustomData_set_layer_render(ldata, CD_MLOOPCOL, act);
2405
2406                 act = CustomData_get_clone_layer(fdata, CD_MCOL);
2407                 CustomData_set_layer_clone(ldata, CD_MLOOPCOL, act);
2408
2409                 act = CustomData_get_stencil_layer(fdata, CD_MCOL);
2410                 CustomData_set_layer_stencil(ldata, CD_MLOOPCOL, act);
2411         }
2412 }
2413
2414 void CustomData_bmesh_init_pool(CustomData *data, int totelem, const char htype)
2415 {
2416         int chunksize;
2417
2418         /* Dispose old pools before calling here to avoid leaks */
2419         BLI_assert(data->pool == NULL);
2420
2421         switch (htype) {
2422                 case BM_VERT: chunksize = bm_mesh_chunksize_default.totvert;  break;
2423                 case BM_EDGE: chunksize = bm_mesh_chunksize_default.totedge;  break;
2424                 case BM_LOOP: chunksize = bm_mesh_chunksize_default.totloop;  break;
2425                 case BM_FACE: chunksize = bm_mesh_chunksize_default.totface;  break;
2426                 default:
2427                         BLI_assert(0);
2428                         chunksize = 512;
2429                         break;
2430         }
2431
2432         /* If there are no layers, no pool is needed just yet */
2433         if (data->totlayer) {
2434                 data->pool = BLI_mempool_create(data->totsize, totelem, chunksize, BLI_MEMPOOL_NOP);
2435         }
2436 }
2437
2438 bool CustomData_bmesh_merge(CustomData *source, CustomData *dest,
2439                             CustomDataMask mask, int alloctype, BMesh *bm, const char htype)
2440 {
2441         BMHeader *h;
2442         BMIter iter;
2443         CustomData destold;
2444         void *tmp;
2445         int iter_type;
2446         int totelem;
2447
2448         if (CustomData_number_of_layers_typemask(source, mask) == 0) {
2449                 return false;
2450         }
2451
2452         /* copy old layer description so that old data can be copied into
2453          * the new allocation */
2454         destold = *dest;
2455         if (destold.layers) {
2456                 destold.layers = MEM_dupallocN(destold.layers);
2457         }
2458
2459         if (CustomData_merge(source, dest, mask, alloctype, 0) == false) {
2460                 if (destold.layers)
2461                         MEM_freeN(destold.layers);
2462                 return false;
2463         }
2464
2465         switch (htype) {
2466                 case BM_VERT:
2467                         iter_type = BM_VERTS_OF_MESH;
2468                         totelem = bm->totvert;
2469                         break;
2470                 case BM_EDGE:
2471                         iter_type = BM_EDGES_OF_MESH;
2472                         totelem = bm->totedge;
2473                         break;
2474                 case BM_LOOP:
2475                         iter_type = BM_LOOPS_OF_FACE;
2476                         totelem = bm->totloop;
2477                         break;
2478                 case BM_FACE:
2479                         iter_type = BM_FACES_OF_MESH;
2480                         totelem = bm->totface;
2481                         break;
2482                 default: /* should never happen */
2483                         BLI_assert(!"invalid type given");
2484                         iter_type = BM_VERTS_OF_MESH;
2485                         totelem = bm->totvert;
2486                         break;
2487         }
2488
2489         dest->pool = NULL;
2490         CustomData_bmesh_init_pool(dest, totelem, htype);
2491
2492         if (iter_type != BM_LOOPS_OF_FACE) {
2493                 /*ensure all current elements follow new customdata layout*/
2494                 BM_ITER_MESH (h, &iter, bm, iter_type) {
2495                         tmp = NULL;
2496                         CustomData_bmesh_copy_data(&destold, dest, h->data, &tmp);
2497                         CustomData_bmesh_free_block(&destold, &h->data);
2498                         h->data = tmp;
2499                 }
2500         }
2501         else {
2502                 BMFace *f;
2503                 BMLoop *l;
2504                 BMIter liter;
2505
2506                 /*ensure all current elements follow new customdata layout*/
2507                 BM_ITER_MESH (f, &iter, bm, BM_FACES_OF_MESH) {
2508                         BM_ITER_ELEM (l, &liter, f, BM_LOOPS_OF_FACE) {
2509                                 tmp = NULL;
2510                                 CustomData_bmesh_copy_data(&destold, dest, l->head.data, &tmp);
2511                                 CustomData_bmesh_free_block(&destold, &l->head.data);
2512                                 l->head.data = tmp;
2513                         }
2514                 }
2515         }
2516
2517         if (destold.pool) BLI_mempool_destroy(destold.pool);
2518         if (destold.layers) MEM_freeN(destold.layers);
2519         return true;
2520 }
2521
2522 void CustomData_bmesh_free_block(CustomData *data, void **block)
2523 {
2524         const LayerTypeInfo *typeInfo;
2525         int i;
2526
2527         if (*block == NULL)
2528                 return;
2529
2530         for (i = 0; i < data->totlayer; ++i) {
2531                 if (!(data->layers[i].flag & CD_FLAG_NOFREE)) {
2532                         typeInfo = layerType_getInfo(data->layers[i].type);
2533
2534                         if (typeInfo->free) {
2535                                 int offset = data->layers[i].offset;
2536                                 typeInfo->free((char *)*block + offset, 1, typeInfo->size);
2537                         }
2538                 }
2539         }
2540
2541         if (data->totsize)
2542                 BLI_mempool_free(data->pool, *block);
2543
2544         *block = NULL;
2545 }
2546
2547 /**
2548  * Same as #CustomData_bmesh_free_block but zero the memory rather then freeing.
2549  */
2550 void CustomData_bmesh_free_block_data(CustomData *data, void **block)
2551 {
2552         const LayerTypeInfo *typeInfo;
2553         int i;
2554
2555         if (*block == NULL)
2556                 return;
2557
2558         for (i = 0; i < data->totlayer; ++i) {
2559                 if (!(data->layers[i].flag & CD_FLAG_NOFREE)) {
2560                         typeInfo = layerType_getInfo(data->layers[i].type);
2561
2562                         if (typeInfo->free) {
2563                                 int offset = data->layers[i].offset;
2564                                 typeInfo->free((char *)*block + offset, 1, typeInfo->size);
2565                         }
2566                 }
2567         }
2568
2569         if (data->totsize)
2570                 memset(*block, 0, data->totsize);
2571 }
2572
2573 static void CustomData_bmesh_alloc_block(CustomData *data, void **block)
2574 {
2575
2576         if (*block)
2577                 CustomData_bmesh_free_block(data, block);
2578
2579         if (data->totsize > 0)
2580                 *block = BLI_mempool_alloc(data->pool);
2581         else
2582                 *block = NULL;
2583 }
2584
2585 void CustomData_bmesh_copy_data(const CustomData *source, CustomData *dest,
2586                                 void *src_block, void **dest_block)
2587 {
2588         const LayerTypeInfo *typeInfo;
2589         int dest_i, src_i;
2590
2591         if (*dest_block == NULL) {
2592                 CustomData_bmesh_alloc_block(dest, dest_block);
2593                 if (*dest_block)
2594                         memset(*dest_block, 0, dest->totsize);
2595         }
2596         
2597         /* copies a layer at a time */
2598         dest_i = 0;
2599         for (src_i = 0; src_i < source->totlayer; ++src_i) {
2600
2601                 /* find the first dest layer with type >= the source type
2602                  * (this should work because layers are ordered by type)
2603                  */
2604                 while (dest_i < dest->totlayer && dest->layers[dest_i].type < source->layers[src_i].type) {
2605                         dest_i++;
2606                 }
2607
2608                 /* if there are no more dest layers, we're done */
2609                 if (dest_i >= dest->totlayer) return;
2610
2611                 /* if we found a matching layer, copy the data */
2612                 if (dest->layers[dest_i].type == source->layers[src_i].type &&
2613                     strcmp(dest->layers[dest_i].name, source->layers[src_i].name) == 0)
2614                 {
2615                         char *src_data = (char *)src_block + source->layers[src_i].offset;
2616                         char *dest_data = (char *)*dest_block + dest->layers[dest_i].offset;
2617
2618                         typeInfo = layerType_getInfo(source->layers[src_i].type);
2619
2620                         if (typeInfo->copy)
2621                                 typeInfo->copy(src_data, dest_data, 1);
2622                         else
2623                                 memcpy(dest_data, src_data, typeInfo->size);
2624
2625                         /* if there are multiple source & dest layers of the same type,
2626                          * we don't want to copy all source layers to the same dest, so
2627                          * increment dest_i
2628                          */
2629                         dest_i++;
2630                 }
2631         }
2632 }
2633
2634 /*Bmesh Custom Data Functions. Should replace editmesh ones with these as well, due to more effecient memory alloc*/
2635 void *CustomData_bmesh_get(const CustomData *data, void *block, int type)
2636 {
2637         int layer_index;
2638         
2639         /* get the layer index of the first layer of type */
2640         layer_index = CustomData_get_active_layer_index(data, type);
2641         if (layer_index == -1) return NULL;
2642
2643         return (char *)block + data->layers[layer_index].offset;
2644 }
2645
2646 void *CustomData_bmesh_get_n(const CustomData *data, void *block, int type, int n)
2647 {
2648         int layer_index;
2649         
2650         /* get the layer index of the first layer of type */
2651         layer_index = CustomData_get_layer_index(data, type);
2652         if (layer_index == -1) return NULL;
2653
2654         return (char *)block + data->layers[layer_index + n].offset;
2655 }
2656
2657 /*gets from the layer at physical index n, note: doesn't check type.*/
2658 void *CustomData_bmesh_get_layer_n(const CustomData *data, void *block, int n)
2659 {
2660         if (n < 0 || n >= data->totlayer) return NULL;
2661
2662         return (char *)block + data->layers[n].offset;
2663 }
2664
2665 bool CustomData_layer_has_math(struct CustomData *data, int layer_n)
2666 {
2667         const LayerTypeInfo *typeInfo = layerType_getInfo(data->layers[layer_n].type);
2668         
2669         if (typeInfo->equal && typeInfo->add && typeInfo->multiply && 
2670             typeInfo->initminmax && typeInfo->dominmax)
2671         {
2672                 return true;
2673         }
2674         
2675         return false;
2676 }
2677
2678 bool CustomData_layer_has_interp(struct CustomData *data, int layer_n)
2679 {
2680         const LayerTypeInfo *typeInfo = layerType_getInfo(data->layers[layer_n].type);
2681
2682         if (typeInfo->interp) {
2683                 return true;
2684         }
2685
2686         return false;
2687 }
2688
2689 bool CustomData_has_math(struct CustomData *data)
2690 {
2691         int i;
2692
2693         /* interpolates a layer at a time */
2694         for (i = 0; i < data->totlayer; ++i) {
2695                 if (CustomData_layer_has_math(data, i)) {
2696                         return true;
2697                 }
2698         }
2699
2700         return false;
2701 }
2702
2703 /* a non bmesh version would have to check layer->data */
2704 bool CustomData_bmesh_has_free(struct CustomData *data)
2705 {
2706         const LayerTypeInfo *typeInfo;
2707         int i;
2708
2709         for (i = 0; i < data->totlayer; ++i) {
2710                 if (!(data->layers[i].flag & CD_FLAG_NOFREE)) {
2711                         typeInfo = layerType_getInfo(data->layers[i].type);
2712                         if (typeInfo->free) {
2713                                 return true;
2714                         }
2715                 }
2716         }
2717         return false;
2718 }
2719
2720 bool CustomData_has_interp(struct CustomData *data)
2721 {
2722         int i;
2723
2724         /* interpolates a layer at a time */
2725         for (i = 0; i < data->totlayer; ++i) {
2726                 if (CustomData_layer_has_interp(data, i)) {
2727                         return true;
2728                 }
2729         }
2730
2731         return false;
2732 }
2733
2734 /* copies the "value" (e.g. mloopuv uv or mloopcol colors) from one block to
2735  * another, while not overwriting anything else (e.g. flags)*/
2736 void CustomData_data_copy_value(int type, void *source, void *dest)
2737 {
2738         const LayerTypeInfo *typeInfo = layerType_getInfo(type);
2739
2740         if (!dest) return;
2741
2742         if (typeInfo->copyvalue)
2743                 typeInfo->copyvalue(source, dest);
2744         else
2745                 memcpy(dest, source, typeInfo->size);
2746 }
2747
2748 bool CustomData_data_equals(int type, void *data1, void *data2)
2749 {
2750         const LayerTypeInfo *typeInfo = layerType_getInfo(type);
2751
2752         if (typeInfo->equal)
2753                 return typeInfo->equal(data1, data2);
2754         else return !memcmp(data1, data2, typeInfo->size);
2755 }
2756
2757 void CustomData_data_initminmax(int type, void *min, void *max)
2758 {
2759         const LayerTypeInfo *typeInfo = layerType_getInfo(type);
2760
2761         if (typeInfo->initminmax)
2762                 typeInfo->initminmax(min, max);
2763 }
2764
2765
2766 void CustomData_data_dominmax(int type, void *data, void *min, void *max)
2767 {
2768         const LayerTypeInfo *typeInfo = layerType_getInfo(type);
2769
2770         if (typeInfo->dominmax)
2771                 typeInfo->dominmax(data, min, max);
2772 }
2773
2774
2775 void CustomData_data_multiply(int type, void *data, float fac)
2776 {
2777         const LayerTypeInfo *typeInfo = layerType_getInfo(type);
2778
2779         if (typeInfo->multiply)
2780                 typeInfo->multiply(data, fac);
2781 }
2782
2783
2784 void CustomData_data_add(int type, void *data1, void *data2)
2785 {
2786         const LayerTypeInfo *typeInfo = layerType_getInfo(type);
2787
2788         if (typeInfo->add)
2789                 typeInfo->add(data1, data2);
2790 }
2791
2792 void CustomData_bmesh_set(const CustomData *data, void *block, int type, void *source)
2793 {
2794         void *dest = CustomData_bmesh_get(data, block, type);
2795         const LayerTypeInfo *typeInfo = layerType_getInfo(type);
2796
2797         if (!dest) return;
2798
2799         if (typeInfo->copy)
2800                 typeInfo->copy(source, dest, 1);
2801         else
2802                 memcpy(dest, source, typeInfo->size);
2803 }
2804
2805 void CustomData_bmesh_set_n(CustomData *data, void *block, int type, int n, void *source)
2806 {
2807         void *dest = CustomData_bmesh_get_n(data, block, type, n);
2808         const LayerTypeInfo *typeInfo = layerType_getInfo(type);
2809
2810         if (!dest) return;
2811
2812         if (typeInfo->copy)
2813                 typeInfo->copy(source, dest, 1);
2814         else
2815                 memcpy(dest, source, typeInfo->size);
2816 }
2817
2818 void CustomData_bmesh_set_layer_n(CustomData *data, void *block, int n, void *source)
2819 {
2820         void *dest = CustomData_bmesh_get_layer_n(data, block, n);
2821         const LayerTypeInfo *typeInfo = layerType_getInfo(data->layers[n].type);
2822
2823         if (!dest) return;
2824
2825         if (typeInfo->copy)
2826                 typeInfo->copy(source, dest, 1);
2827         else
2828                 memcpy(dest, source, typeInfo->size);
2829 }
2830
2831 /**
2832  * \param src_blocks must be pointers to the data, offset by layer->offset already.
2833  */
2834 void CustomData_bmesh_interp_n(CustomData *data, void **src_blocks, const float *weights,
2835                                const float *sub_weights, int count, void *dest_block, int n)
2836 {
2837         CustomDataLayer *layer = &data->layers[n];
2838         const LayerTypeInfo *typeInfo = layerType_getInfo(layer->type);
2839
2840         typeInfo->interp(src_blocks, weights, sub_weights, count,
2841                          (char *)dest_block + layer->offset);
2842 }
2843
2844 void CustomData_bmesh_interp(CustomData *data, void **src_blocks, const float *weights,
2845                              const float *sub_weights, int count, void *dest_block)
2846 {
2847         int i, j;
2848         void *source_buf[SOURCE_BUF_SIZE];
2849         void **sources = source_buf;
2850
2851         /* slow fallback in case we're interpolating a ridiculous number of
2852          * elements
2853          */
2854         if (count > SOURCE_BUF_SIZE)
2855                 sources = MEM_callocN(sizeof(*sources) * count,
2856                                       "CustomData_interp sources");
2857
2858         /* interpolates a layer at a time */
2859         for (i = 0; i < data->totlayer; ++i) {
2860                 CustomDataLayer *layer = &data->layers[i];
2861                 const LayerTypeInfo *typeInfo = layerType_getInfo(layer->type);
2862                 if (typeInfo->interp) {
2863                         for (j = 0; j < count; ++j) {
2864                                 sources[j] = (char *)src_blocks[j] + layer->offset;
2865                         }
2866                         CustomData_bmesh_interp_n(data, sources, weights, sub_weights, count, dest_block, i);
2867                 }
2868         }
2869
2870         if (count > SOURCE_BUF_SIZE) MEM_freeN(sources);
2871 }
2872
2873 static void CustomData_bmesh_set_default_n(CustomData *data, void **block, int n)
2874 {
2875         const LayerTypeInfo *typeInfo;
2876         int offset = data->layers[n].offset;
2877
2878         typeInfo = layerType_getInfo(data->layers[n].type);
2879
2880         if (typeInfo->set_default) {
2881                 typeInfo->set_default((char *)*block + offset, 1);
2882         }
2883         else {
2884                 memset((char *)*block + offset, 0, typeInfo->size);
2885         }
2886 }
2887
2888 void CustomData_bmesh_set_default(CustomData *data, void **block)
2889 {
2890         int i;
2891
2892         if (*block == NULL)
2893                 CustomData_bmesh_alloc_block(data, block);
2894
2895         for (i = 0; i < data->totlayer; ++i) {
2896                 CustomData_bmesh_set_default_n(data, block, i);
2897         }
2898 }
2899
2900 /**
2901  * \param use_default_init initializes data which can't be copied,
2902  * typically you'll want to use this if the BM_xxx create function
2903  * is called with BM_CREATE_SKIP_CD flag
2904  */
2905 void CustomData_to_bmesh_block(const CustomData *source, CustomData *dest,
2906                                int src_index, void **dest_block, bool use_default_init)
2907 {
2908         const LayerTypeInfo *typeInfo;
2909         int dest_i, src_i, src_offset;
2910
2911         if (*dest_block == NULL)
2912                 CustomData_bmesh_alloc_block(dest, dest_block);
2913         
2914         /* copies a layer at a time */
2915         dest_i = 0;
2916         for (src_i = 0; src_i < source->totlayer; ++src_i) {
2917
2918                 /* find the first dest layer with type >= the source type
2919                  * (this should work because layers are ordered by type)
2920                  */
2921                 while (dest_i < dest->totlayer && dest->layers[dest_i].type < source->layers[src_i].type) {
2922                         if (use_default_init) {
2923                                 CustomData_bmesh_set_default_n(dest, dest_block, dest_i);
2924                         }
2925                         dest_i++;
2926                 }
2927
2928                 /* if there are no more dest layers, we're done */
2929                 if (dest_i >= dest->totlayer) break;
2930
2931                 /* if we found a matching layer, copy the data */
2932                 if (dest->layers[dest_i].type == source->layers[src_i].type) {
2933                         int offset = dest->layers[dest_i].offset;
2934                         char *src_data = source->layers[src_i].data;
2935                         char *dest_data = (char *)*dest_block + offset;
2936
2937                         typeInfo = layerType_getInfo(dest->layers[dest_i].type);
2938                         src_offset = src_index * typeInfo->size;
2939
2940                         if (typeInfo->copy)
2941                                 typeInfo->copy(src_data + src_offset, dest_data, 1);
2942                         else
2943                                 memcpy(dest_data, src_data + src_offset, typeInfo->size);
2944
2945                         /* if there are multiple source & dest layers of the same type,
2946                          * we don't want to copy all source layers to the same dest, so
2947                          * increment dest_i
2948                          */
2949                         dest_i++;
2950                 }
2951         }
2952
2953         if (use_default_init) {
2954                 while (dest_i < dest->totlayer) {
2955                         CustomData_bmesh_set_default_n(dest, dest_block, dest_i);
2956                         dest_i++;
2957                 }
2958         }
2959 }
2960
2961 void CustomData_from_bmesh_block(const CustomData *source, CustomData *dest,
2962                                  void *src_block, int dest_index)
2963 {
2964         const LayerTypeInfo *typeInfo;
2965         int dest_i, src_i, dest_offset;
2966
2967         /* copies a layer at a time */
2968         dest_i = 0;
2969         for (src_i = 0; src_i < source->totlayer; ++src_i) {
2970
2971                 /* find the first dest layer with type >= the source type
2972                  * (this should work because layers are ordered by type)
2973                  */
2974                 while (dest_i < dest->totlayer && dest->layers[dest_i].type < source->layers[src_i].type) {
2975                         dest_i++;
2976                 }
2977
2978                 /* if there are no more dest layers, we're done */
2979                 if (dest_i >= dest->totlayer) return;
2980
2981                 /* if we found a matching layer, copy the data */
2982                 if (dest->layers[dest_i].type == source->layers[src_i].type) {
2983                         int offset = source->layers[src_i].offset;
2984                         char *src_data = (char *)src_block + offset;
2985                         char *dest_data = dest->layers[dest_i].data;
2986
2987                         typeInfo = layerType_getInfo(dest->layers[dest_i].type);
2988                         dest_offset = dest_index * typeInfo->size;
2989
2990                         if (typeInfo->copy)
2991                                 typeInfo->copy(src_data, dest_data + dest_offset, 1);
2992                         else
2993                                 memcpy(dest_data + dest_offset, src_data, typeInfo->size);
2994
2995                         /* if there are multiple source & dest layers of the same type,
2996                          * we don't want to copy all source layers to the same dest, so
2997                          * increment dest_i
2998                          */
2999                         dest_i++;
3000                 }
3001         }
3002
3003 }
3004
3005 void CustomData_file_write_info(int type, const char **structname, int *structnum)
3006 {
3007         const LayerTypeInfo *typeInfo = layerType_getInfo(type);
3008
3009         *structname = typeInfo->structname;
3010         *structnum = typeInfo->structnum;
3011 }
3012
3013 int CustomData_sizeof(int type)
3014 {
3015         const LayerTypeInfo *typeInfo = layerType_getInfo(type);
3016
3017         return typeInfo->size;
3018 }
3019
3020 const char *CustomData_layertype_name(int type)
3021 {
3022         return layerType_getName(type);
3023 }
3024
3025
3026 /**
3027  * Can only ever be one of these.
3028  */
3029 bool CustomData_layertype_is_singleton(int type)
3030 {
3031         const LayerTypeInfo *typeInfo = layerType_getInfo(type);
3032         return typeInfo->defaultname == NULL;
3033 }
3034
3035 static bool CustomData_is_property_layer(int type)
3036 {
3037         if ((type == CD_PROP_FLT) || (type == CD_PROP_INT) || (type == CD_PROP_STR))
3038                 return true;
3039         return false;
3040 }
3041
3042 static bool cd_layer_find_dupe(CustomData *data, const char *name, int type, int index)
3043 {
3044         int i;
3045         /* see if there is a duplicate */
3046         for (i = 0; i < data->totlayer; i++) {
3047                 if (i != index) {
3048                         CustomDataLayer *layer = &data->layers[i];
3049                         
3050                         if (CustomData_is_property_layer(type)) {
3051                                 if (CustomData_is_property_layer(layer->type) && strcmp(layer->name, name) == 0) {
3052                                         return true;
3053                                 }
3054                         }
3055                         else {
3056                                 if (i != index && layer->type == type && strcmp(layer->name, name) == 0) {
3057                                         return true;
3058                                 }
3059                         }
3060                 }
3061         }
3062         
3063         return false;
3064 }
3065
3066 static bool customdata_unique_check(void *arg, const char *name)
3067 {
3068         struct {CustomData *data; int type; int index; } *data_arg = arg;
3069         return cd_layer_find_dupe(data_arg->data, name, data_arg->type, data_arg->index);
3070 }
3071
3072 void CustomData_set_layer_unique_name(CustomData *data, int index)
3073 {       
3074         CustomDataLayer *nlayer = &data->layers[index];
3075         const LayerTypeInfo *typeInfo = layerType_getInfo(nlayer->type);
3076
3077         struct {CustomData *data; int type; int index; } data_arg;
3078         data_arg.data = data;
3079         data_arg.type = nlayer->type;
3080         data_arg.index = index;
3081
3082         if (!typeInfo->defaultname)
3083                 return;
3084
3085         BLI_uniquename_cb(customdata_unique_check, &data_arg, DATA_(typeInfo->defaultname), '.', nlayer->name,
3086                           sizeof(nlayer->name));
3087 }
3088
3089 void CustomData_validate_layer_name(const CustomData *data, int type, const char *name, char *outname)
3090 {
3091         int index = -1;
3092
3093         /* if a layer name was given, try to find that layer */
3094         if (name[0])
3095                 index = CustomData_get_named_layer_index(data, type, name);
3096
3097         if (index == -1) {
3098                 /* either no layer was specified, or the layer we want has been
3099                  * deleted, so assign the active layer to name
3100                  */
3101                 index = CustomData_get_active_layer_index(data, type);
3102                 BLI_strncpy(outname, data->layers[index].name, MAX_CUSTOMDATA_LAYER_NAME);
3103         }
3104         else {
3105                 BLI_strncpy(outname, name, MAX_CUSTOMDATA_LAYER_NAME);
3106         }
3107 }
3108
3109 bool CustomData_verify_versions(struct CustomData *data, int index)
3110 {
3111         const LayerTypeInfo *typeInfo;
3112         CustomDataLayer *layer = &data->layers[index];
3113         bool keeplayer = true;
3114         int i;
3115
3116         if (layer->type >= CD_NUMTYPES) {
3117                 keeplayer = false; /* unknown layer type from future version */
3118         }
3119         else {
3120                 typeInfo = layerType_getInfo(layer->type);
3121
3122                 if (!typeInfo->defaultname && (index > 0) &&
3123                     data->layers[index - 1].type == layer->type)
3124                 {
3125                         keeplayer = false; /* multiple layers of which we only support one */
3126                 }
3127         }
3128
3129         if (!keeplayer) {
3130                 for (i = index + 1; i < data->totlayer; ++i)
3131                         data->layers[i - 1] = data->layers[i];
3132                 data->totlayer--;
3133         }
3134
3135         return keeplayer;
3136 }
3137
3138 /****************************** External Files *******************************/
3139
3140 static void customdata_external_filename(char filename[FILE_MAX], ID *id, CustomDataExternal *external)
3141 {
3142         BLI_strncpy(filename, external->filename, FILE_MAX);
3143         BLI_path_abs(filename, ID_BLEND_PATH(G.main, id));
3144 }
3145
3146 void CustomData_external_reload(CustomData *data, ID *UNUSED(id), CustomDataMask mask, int totelem)
3147 {
3148         CustomDataLayer *layer;
3149         const LayerTypeInfo *typeInfo;
3150         int i;
3151
3152         for (i = 0; i < data->totlayer; i++) {
3153                 layer = &data->layers[i];
3154                 typeInfo = layerType_getInfo(layer->type);
3155
3156                 if (!(mask & CD_TYPE_AS_MASK(layer->type))) {
3157                         /* pass */
3158                 }
3159                 else if ((layer->flag & CD_FLAG_EXTERNAL) && (layer->flag & CD_FLAG_IN_MEMORY)) {
3160                         if (typeInfo->free)
3161                                 typeInfo->free(layer->data, totelem, typeInfo->size);
3162                         layer->flag &= ~CD_FLAG_IN_MEMORY;
3163                 }
3164         }
3165 }
3166
3167 void CustomData_external_read(CustomData *data, ID *id, CustomDataMask mask, int totelem)
3168 {
3169         CustomDataExternal *external = data->external;
3170         CustomDataLayer *layer;
3171         CDataFile *cdf;
3172         CDataFileLayer *blay;
3173         char filename[FILE_MAX];
3174         const LayerTypeInfo *typeInfo;
3175         int i, update = 0;
3176
3177         if (!external)
3178                 return;
3179         
3180         for (i = 0; i < data->totlayer; i++) {
3181                 layer = &data->layers[i];
3182                 typeInfo = layerType_getInfo(layer->type);
3183
3184                 if (!(mask & CD_TYPE_AS_MASK(layer->type))) {
3185                         /* pass */
3186                 }
3187                 else if (layer->flag & CD_FLAG_IN_MEMORY) {
3188                         /* pass */
3189                 }
3190                 else if ((layer->flag & CD_FLAG_EXTERNAL) && typeInfo->read) {
3191                         update = 1;
3192                 }
3193         }
3194
3195         if (!update)
3196                 return;
3197
3198         customdata_external_filename(filename, id, external);
3199
3200         cdf = cdf_create(CDF_TYPE_MESH);
3201         if (!cdf_read_open(cdf, filename)) {
3202                 fprintf(stderr, "Failed to read %s layer from %s.\n", layerType_getName(layer->type), filename);
3203                 return;
3204         }
3205
3206         for (i = 0; i < data->totlayer; i++) {
3207                 layer = &data->layers[i];
3208                 typeInfo = layerType_getInfo(layer->type);
3209
3210                 if (!(mask & CD_TYPE_AS_MASK(layer->type))) {
3211                         /* pass */
3212                 }
3213                 else if (layer->flag & CD_FLAG_IN_MEMORY) {
3214                         /* pass */
3215                 }
3216                 else if ((layer->flag & CD_FLAG_EXTERNAL) && typeInfo->read) {
3217                         blay = cdf_layer_find(cdf, layer->type, layer->name);
3218
3219                         if (blay) {
3220                                 if (cdf_read_layer(cdf, blay)) {
3221                                         if (typeInfo->read(cdf, layer->data, totelem)) {
3222                                                 /* pass */
3223                                         }
3224                                         else {
3225                                                 break;
3226                                         }
3227                                         layer->flag |= CD_FLAG_IN_MEMORY;
3228                                 }
3229                                 else
3230                                         break;
3231                         }
3232                 }
3233         }
3234
3235         cdf_read_close(cdf);
3236         cdf_free(cdf);
3237 }
3238
3239 void CustomData_external_write(CustomData *data, ID *id, CustomDataMask mask, int totelem, int free)
3240 {
3241         CustomDataExternal *external = data->external;
3242         CustomDataLayer *layer;
3243         CDataFile *cdf;
3244         CDataFileLayer *blay;
3245         const LayerTypeInfo *typeInfo;
3246         int i, update = 0;
3247         char filename[FILE_MAX];
3248
3249         if (!external)
3250                 return;
3251
3252         /* test if there is anything to write */
3253         for (i = 0; i < data->totlayer; i++) {
3254                 layer = &data->layers[i];
3255                 typeInfo = layerType_getInfo(layer->type);
3256
3257                 if (!(mask & CD_TYPE_AS_MASK(layer->type))) {
3258                         /* pass */
3259                 }
3260                 else if ((layer->flag & CD_FLAG_EXTERNAL) && typeInfo->write) {
3261                         update = 1;
3262                 }
3263         }
3264
3265         if (!update)
3266                 return;
3267
3268         /* make sure data is read before we try to write */
3269         CustomData_external_read(data, id, mask, totelem);
3270         customdata_external_filename(filename, id, external);
3271
3272         cdf = cdf_create(CDF_TYPE_MESH);
3273
3274         for (i = 0; i < data->totlayer; i++) {
3275                 layer = &data->layers[i];
3276                 typeInfo = layerType_getInfo(layer->type);
3277
3278                 if ((layer->flag & CD_FLAG_EXTERNAL) && typeInfo->filesize) {
3279                         if (layer->flag & CD_FLAG_IN_MEMORY) {
3280                                 cdf_layer_add(cdf, layer->type, layer->name,
3281                                               typeInfo->filesize(cdf, layer->data, totelem));
3282                         }
3283                         else {
3284                                 cdf_free(cdf);
3285                                 return; /* read failed for a layer! */
3286                         }
3287                 }
3288         }
3289
3290         if (!cdf_write_open(cdf, filename)) {
3291                 fprintf(stderr, "Failed to open %s for writing.\n", filename);
3292                 return;
3293         }
3294
3295         for (i = 0; i < data->totlayer; i++) {
3296                 layer = &data->layers[i];
3297                 typeInfo = layerType_getInfo(layer->type);
3298
3299                 if ((layer->flag & CD_FLAG_EXTERNAL) && typeInfo->write) {
3300                         blay = cdf_layer_find(cdf, layer->type, layer->name);
3301
3302                         if (cdf_write_layer(cdf, blay)) {
3303                                 if (typeInfo->write(cdf, layer->data, totelem)) {
3304                                         /* pass */
3305                                 }
3306                                 else {
3307                                         break;
3308                                 }
3309                         }
3310                         else {
3311                                 break;
3312                         }
3313                 }
3314         }
3315
3316         if (i != data->totlayer) {
3317                 fprintf(stderr, "Failed to write data to %s.\n", filename);
3318                 cdf_free(cdf);
3319                 return;
3320         }
3321
3322         for (i = 0; i < data->totlayer; i++) {
3323                 layer = &data->layers[i];