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