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