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