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