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