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