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