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