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