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