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