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