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