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