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