correct assert for customdata overlap, also quiet `uninitialized` warning in transform.
[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, const float *weights, const 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, const float *weights,
207                                     const 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, const float *weights,
265                                 const 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, const float *weights,
295                               const 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         const 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, const float *weights,
396                                        const float *sub_weights, int count, void *dest)
397 {
398         OrigSpaceFace *osf = dest;
399         int i, j, k;
400         float uv[4][2] = {{0.0f}};
401         const float *sub_weight;
402
403         if (count <= 0) return;
404
405         sub_weight = sub_weights;
406         for (i = 0; i < count; ++i) {
407                 float weight = weights ? weights[i] : 1;
408                 OrigSpaceFace *src = sources[i];
409
410                 for (j = 0; j < 4; ++j) {
411                         if (sub_weights) {
412                                 for (k = 0; k < 4; ++k, ++sub_weight) {
413                                         madd_v2_v2fl(uv[j], src->uv[k], (*sub_weight) * weight);
414                                 }
415                         }
416                         else {
417                                 madd_v2_v2fl(uv[j], src->uv[j], weight);
418                         }
419                 }
420         }
421
422 #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, const float *weights,
684                                  const float *sub_weights, int count, void *dest)
685 {
686         MLoopCol *mc = dest;
687         int i;
688         const 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, const float *weights,
772                                 const 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, const float *weights,
842                                         const 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, const float *weights,
870                              const 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         const 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, const float *weights,
950                                 const 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, const float *weights,
973                                  const 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, const float *weights,
1007                                    const 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 | CD_MASK_MVERT_SKIN;
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 | CD_MASK_MVERT_SKIN;
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 void customData_mask_layers__print(CustomDataMask mask)
1197 {
1198         int i;
1199
1200         printf("mask=0x%lx:\n", (long unsigned int)mask);
1201         for (i = 0; i < CD_NUMTYPES; i++) {
1202                 if (mask & CD_TYPE_AS_MASK(i)) {
1203                         printf("  %s\n", layerType_getName(i));
1204                 }
1205         }
1206 }
1207
1208 /********************* CustomData functions *********************/
1209 static void customData_update_offsets(CustomData *data);
1210
1211 static CustomDataLayer *customData_add_layer__internal(CustomData *data,
1212                                                        int type, int alloctype, void *layerdata, int totelem, const char *name);
1213
1214 void CustomData_update_typemap(CustomData *data)
1215 {
1216         int i, lasttype = -1;
1217
1218         /* since we cant do in a pre-processor do here as an assert */
1219         BLI_assert(sizeof(data->typemap) / sizeof(int) >= CD_NUMTYPES);
1220
1221         for (i = 0; i < CD_NUMTYPES; i++) {
1222                 data->typemap[i] = -1;
1223         }
1224
1225         for (i = 0; i < data->totlayer; i++) {
1226                 if (data->layers[i].type != lasttype) {
1227                         data->typemap[data->layers[i].type] = i;
1228                 }
1229                 lasttype = data->layers[i].type;
1230         }
1231 }
1232
1233 void CustomData_merge(const struct CustomData *source, struct CustomData *dest,
1234                       CustomDataMask mask, int alloctype, int totelem)
1235 {
1236         /*const LayerTypeInfo *typeInfo;*/
1237         CustomDataLayer *layer, *newlayer;
1238         void *data;
1239         int i, type, number = 0, lasttype = -1, lastactive = 0, lastrender = 0, lastclone = 0, lastmask = 0, lastflag = 0;
1240
1241         for (i = 0; i < source->totlayer; ++i) {
1242                 layer = &source->layers[i];
1243                 /*typeInfo = layerType_getInfo(layer->type);*/ /*UNUSED*/
1244
1245                 type = layer->type;
1246
1247                 if (type != lasttype) {
1248                         number = 0;
1249                         lastactive = layer->active;
1250                         lastrender = layer->active_rnd;
1251                         lastclone = layer->active_clone;
1252                         lastmask = layer->active_mask;
1253                         lasttype = type;
1254                         lastflag = layer->flag;
1255                 }
1256                 else
1257                         number++;
1258
1259                 if (lastflag & CD_FLAG_NOCOPY) continue;
1260                 else if (!(mask & CD_TYPE_AS_MASK(type))) continue;
1261                 else if (number < CustomData_number_of_layers(dest, type)) continue;
1262
1263                 switch (alloctype) {
1264                         case CD_ASSIGN:
1265                         case CD_REFERENCE:
1266                         case CD_DUPLICATE:
1267                                 data = layer->data;
1268                                 break;
1269                         default:
1270                                 data = NULL;
1271                                 break;
1272                 }
1273
1274                 if ((alloctype == CD_ASSIGN) && (lastflag & CD_FLAG_NOFREE))
1275                         newlayer = customData_add_layer__internal(dest, type, CD_REFERENCE,
1276                                                                   data, totelem, layer->name);
1277                 else
1278                         newlayer = customData_add_layer__internal(dest, type, alloctype,
1279                                                                   data, totelem, layer->name);
1280                 
1281                 if (newlayer) {
1282                         newlayer->uid = layer->uid;
1283                         
1284                         newlayer->active = lastactive;
1285                         newlayer->active_rnd = lastrender;
1286                         newlayer->active_clone = lastclone;
1287                         newlayer->active_mask = lastmask;
1288                         newlayer->flag |= lastflag & (CD_FLAG_EXTERNAL | CD_FLAG_IN_MEMORY);
1289                 }
1290         }
1291
1292         CustomData_update_typemap(dest);
1293 }
1294
1295 void CustomData_copy(const struct CustomData *source, struct CustomData *dest,
1296                      CustomDataMask mask, int alloctype, int totelem)
1297 {
1298         memset(dest, 0, sizeof(*dest));
1299
1300         if (source->external)
1301                 dest->external = MEM_dupallocN(source->external);
1302
1303         CustomData_merge(source, dest, mask, alloctype, totelem);
1304 }
1305
1306 static void customData_free_layer__internal(CustomDataLayer *layer, int totelem)
1307 {
1308         const LayerTypeInfo *typeInfo;
1309
1310         if (!(layer->flag & CD_FLAG_NOFREE) && layer->data) {
1311                 typeInfo = layerType_getInfo(layer->type);
1312
1313                 if (typeInfo->free)
1314                         typeInfo->free(layer->data, totelem, typeInfo->size);
1315
1316                 if (layer->data)
1317                         MEM_freeN(layer->data);
1318         }
1319 }
1320
1321 static void CustomData_external_free(CustomData *data)
1322 {
1323         if (data->external) {
1324                 MEM_freeN(data->external);
1325                 data->external = NULL;
1326         }
1327 }
1328
1329 void CustomData_free(CustomData *data, int totelem)
1330 {
1331         int i;
1332
1333         for (i = 0; i < data->totlayer; ++i)
1334                 customData_free_layer__internal(&data->layers[i], totelem);
1335
1336         if (data->layers)
1337                 MEM_freeN(data->layers);
1338         
1339         CustomData_external_free(data);
1340         
1341         memset(data, 0, sizeof(*data));
1342 }
1343
1344 static void customData_update_offsets(CustomData *data)
1345 {
1346         const LayerTypeInfo *typeInfo;
1347         int i, offset = 0;
1348
1349         for (i = 0; i < data->totlayer; ++i) {
1350                 typeInfo = layerType_getInfo(data->layers[i].type);
1351
1352                 data->layers[i].offset = offset;
1353                 offset += typeInfo->size;
1354         }
1355
1356         data->totsize = offset;
1357         CustomData_update_typemap(data);
1358 }
1359
1360 int CustomData_get_layer_index(const CustomData *data, int type)
1361 {
1362         int i; 
1363
1364         for (i = 0; i < data->totlayer; ++i)
1365                 if (data->layers[i].type == type)
1366                         return i;
1367
1368         return -1;
1369 }
1370
1371 int CustomData_get_layer_index_n(const struct CustomData *data, int type, int n)
1372 {
1373         int i = CustomData_get_layer_index(data, type);
1374
1375         if (i != -1) {
1376                 i = (data->layers[i + n].type == type) ? (i + n) : (-1);
1377         }
1378
1379         return i;
1380 }
1381
1382 int CustomData_get_named_layer_index(const CustomData *data, int type, const char *name)
1383 {
1384         int i;
1385
1386         for (i = 0; i < data->totlayer; ++i)
1387                 if (data->layers[i].type == type && strcmp(data->layers[i].name, name) == 0)
1388                         return i;
1389
1390         return -1;
1391 }
1392
1393 int CustomData_get_active_layer_index(const CustomData *data, int type)
1394 {
1395         if (!data->totlayer)
1396                 return -1;
1397
1398         if (data->typemap[type] != -1) {
1399                 return data->typemap[type] + data->layers[data->typemap[type]].active;
1400         }
1401
1402         return -1;
1403 }
1404
1405 int CustomData_get_render_layer_index(const CustomData *data, int type)
1406 {
1407         int i;
1408
1409         for (i = 0; i < data->totlayer; ++i)
1410                 if (data->layers[i].type == type)
1411                         return i + data->layers[i].active_rnd;
1412
1413         return -1;
1414 }
1415
1416 int CustomData_get_clone_layer_index(const CustomData *data, int type)
1417 {
1418         int i;
1419
1420         for (i = 0; i < data->totlayer; ++i)
1421                 if (data->layers[i].type == type)
1422                         return i + data->layers[i].active_clone;
1423
1424         return -1;
1425 }
1426
1427 int CustomData_get_stencil_layer_index(const CustomData *data, int type)
1428 {
1429         int i;
1430
1431         for (i = 0; i < data->totlayer; ++i)
1432                 if (data->layers[i].type == type)
1433                         return i + data->layers[i].active_mask;
1434
1435         return -1;
1436 }
1437
1438 int CustomData_get_active_layer(const CustomData *data, int type)
1439 {
1440         int i;
1441
1442         for (i = 0; i < data->totlayer; ++i)
1443                 if (data->layers[i].type == type)
1444                         return data->layers[i].active;
1445
1446         return -1;
1447 }
1448
1449 int CustomData_get_render_layer(const CustomData *data, int type)
1450 {
1451         int i;
1452
1453         for (i = 0; i < data->totlayer; ++i)
1454                 if (data->layers[i].type == type)
1455                         return data->layers[i].active_rnd;
1456
1457         return -1;
1458 }
1459
1460 int CustomData_get_clone_layer(const CustomData *data, int type)
1461 {
1462         int i;
1463
1464         for (i = 0; i < data->totlayer; ++i)
1465                 if (data->layers[i].type == type)
1466                         return data->layers[i].active_clone;
1467
1468         return -1;
1469 }
1470
1471 int CustomData_get_stencil_layer(const CustomData *data, int type)
1472 {
1473         int i;
1474
1475         for (i = 0; i < data->totlayer; ++i)
1476                 if (data->layers[i].type == type)
1477                         return data->layers[i].active_mask;
1478
1479         return -1;
1480 }
1481
1482 void CustomData_set_layer_active(CustomData *data, int type, int n)
1483 {
1484         int i;
1485
1486         for (i = 0; i < data->totlayer; ++i)
1487                 if (data->layers[i].type == type)
1488                         data->layers[i].active = n;
1489 }
1490
1491 void CustomData_set_layer_render(CustomData *data, int type, int n)
1492 {
1493         int i;
1494
1495         for (i = 0; i < data->totlayer; ++i)
1496                 if (data->layers[i].type == type)
1497                         data->layers[i].active_rnd = n;
1498 }
1499
1500 void CustomData_set_layer_clone(CustomData *data, int type, int n)
1501 {
1502         int i;
1503
1504         for (i = 0; i < data->totlayer; ++i)
1505                 if (data->layers[i].type == type)
1506                         data->layers[i].active_clone = n;
1507 }
1508
1509 void CustomData_set_layer_stencil(CustomData *data, int type, int n)
1510 {
1511         int i;
1512
1513         for (i = 0; i < data->totlayer; ++i)
1514                 if (data->layers[i].type == type)
1515                         data->layers[i].active_mask = n;
1516 }
1517
1518 /* for using with an index from CustomData_get_active_layer_index and CustomData_get_render_layer_index */
1519 void CustomData_set_layer_active_index(CustomData *data, int type, int n)
1520 {
1521         int i;
1522
1523         for (i = 0; i < data->totlayer; ++i)
1524                 if (data->layers[i].type == type)
1525                         data->layers[i].active = n - i;
1526 }
1527
1528 void CustomData_set_layer_render_index(CustomData *data, int type, int n)
1529 {
1530         int i;
1531
1532         for (i = 0; i < data->totlayer; ++i)
1533                 if (data->layers[i].type == type)
1534                         data->layers[i].active_rnd = n - i;
1535 }
1536
1537 void CustomData_set_layer_clone_index(CustomData *data, int type, int n)
1538 {
1539         int i;
1540
1541         for (i = 0; i < data->totlayer; ++i)
1542                 if (data->layers[i].type == type)
1543                         data->layers[i].active_clone = n - i;
1544 }
1545
1546 void CustomData_set_layer_stencil_index(CustomData *data, int type, int n)
1547 {
1548         int i;
1549
1550         for (i = 0; i < data->totlayer; ++i)
1551                 if (data->layers[i].type == type)
1552                         data->layers[i].active_mask = n - i;
1553 }
1554
1555 void CustomData_set_layer_flag(struct CustomData *data, int type, int flag)
1556 {
1557         int i;
1558
1559         for (i = 0; i < data->totlayer; ++i)
1560                 if (data->layers[i].type == type)
1561                         data->layers[i].flag |= flag;
1562 }
1563
1564 static int customData_resize(CustomData *data, int amount)
1565 {
1566         CustomDataLayer *tmp = MEM_callocN(sizeof(*tmp) * (data->maxlayer + amount),
1567                                            "CustomData->layers");
1568         if (!tmp) return 0;
1569
1570         data->maxlayer += amount;
1571         if (data->layers) {
1572                 memcpy(tmp, data->layers, sizeof(*tmp) * data->totlayer);
1573                 MEM_freeN(data->layers);
1574         }
1575         data->layers = tmp;
1576
1577         return 1;
1578 }
1579
1580 static CustomDataLayer *customData_add_layer__internal(CustomData *data,
1581                                                        int type, int alloctype, void *layerdata, int totelem, const char *name)
1582 {
1583         const LayerTypeInfo *typeInfo = layerType_getInfo(type);
1584         int size = typeInfo->size * totelem, flag = 0, index = data->totlayer;
1585         void *newlayerdata = NULL;
1586
1587         /* Passing a layerdata to copy from with an alloctype that won't copy is
1588          * most likely a bug */
1589         BLI_assert(!layerdata ||
1590                    (alloctype == CD_ASSIGN) ||
1591                    (alloctype == CD_DUPLICATE) ||
1592                    (alloctype == CD_REFERENCE));
1593
1594         if (!typeInfo->defaultname && CustomData_has_layer(data, type))
1595                 return &data->layers[CustomData_get_layer_index(data, type)];
1596
1597         if ((alloctype == CD_ASSIGN) || (alloctype == CD_REFERENCE)) {
1598                 newlayerdata = layerdata;
1599         }
1600         else if (size > 0) {
1601                 newlayerdata = MEM_callocN(size, layerType_getName(type));
1602                 if (!newlayerdata)
1603                         return NULL;
1604         }
1605
1606         if (alloctype == CD_DUPLICATE && layerdata) {
1607                 if (typeInfo->copy)
1608                         typeInfo->copy(layerdata, newlayerdata, totelem);
1609                 else
1610                         memcpy(newlayerdata, layerdata, size);
1611         }
1612         else if (alloctype == CD_DEFAULT) {
1613                 if (typeInfo->set_default)
1614                         typeInfo->set_default((char *)newlayerdata, totelem);
1615         }
1616         else if (alloctype == CD_REFERENCE)
1617                 flag |= CD_FLAG_NOFREE;
1618
1619         if (index >= data->maxlayer) {
1620                 if (!customData_resize(data, CUSTOMDATA_GROW)) {
1621                         if (newlayerdata != layerdata)
1622                                 MEM_freeN(newlayerdata);
1623                         return NULL;
1624                 }
1625         }
1626         
1627         data->totlayer++;
1628
1629         /* keep layers ordered by type */
1630         for (; index > 0 && data->layers[index - 1].type > type; --index)
1631                 data->layers[index] = data->layers[index - 1];
1632
1633         data->layers[index].type = type;
1634         data->layers[index].flag = flag;
1635         data->layers[index].data = newlayerdata;
1636
1637         if (name || (name = typeInfo->defaultname)) {
1638                 BLI_strncpy(data->layers[index].name, name, sizeof(data->layers[index].name));
1639                 CustomData_set_layer_unique_name(data, index);
1640         }
1641         else
1642                 data->layers[index].name[0] = '\0';
1643
1644         if (index > 0 && data->layers[index - 1].type == type) {
1645                 data->layers[index].active = data->layers[index - 1].active;
1646                 data->layers[index].active_rnd = data->layers[index - 1].active_rnd;
1647                 data->layers[index].active_clone = data->layers[index - 1].active_clone;
1648                 data->layers[index].active_mask = data->layers[index - 1].active_mask;
1649         }
1650         else {
1651                 data->layers[index].active = 0;
1652                 data->layers[index].active_rnd = 0;
1653                 data->layers[index].active_clone = 0;
1654                 data->layers[index].active_mask = 0;
1655         }
1656         
1657         customData_update_offsets(data);
1658
1659         return &data->layers[index];
1660 }
1661
1662 void *CustomData_add_layer(CustomData *data, int type, int alloctype,
1663                            void *layerdata, int totelem)
1664 {
1665         CustomDataLayer *layer;
1666         const LayerTypeInfo *typeInfo = layerType_getInfo(type);
1667         
1668         layer = customData_add_layer__internal(data, type, alloctype, layerdata,
1669                                                totelem, typeInfo->defaultname);
1670         CustomData_update_typemap(data);
1671
1672         if (layer)
1673                 return layer->data;
1674
1675         return NULL;
1676 }
1677
1678 /*same as above but accepts a name*/
1679 void *CustomData_add_layer_named(CustomData *data, int type, int alloctype,
1680                                  void *layerdata, int totelem, const char *name)
1681 {
1682         CustomDataLayer *layer;
1683         
1684         layer = customData_add_layer__internal(data, type, alloctype, layerdata,
1685                                                totelem, name);
1686         CustomData_update_typemap(data);
1687
1688         if (layer)
1689                 return layer->data;
1690
1691         return NULL;
1692 }
1693
1694
1695 int CustomData_free_layer(CustomData *data, int type, int totelem, int index)
1696 {
1697         int i;
1698         
1699         if (index < 0) return 0;
1700
1701         customData_free_layer__internal(&data->layers[index], totelem);
1702
1703         for (i = index + 1; i < data->totlayer; ++i)
1704                 data->layers[i - 1] = data->layers[i];
1705
1706         data->totlayer--;
1707
1708         /* if layer was last of type in array, set new active layer */
1709         if ((index >= data->totlayer) || (data->layers[index].type != type)) {
1710                 i = CustomData_get_layer_index(data, type);
1711                 
1712                 if (i >= 0)
1713                         for (; i < data->totlayer && data->layers[i].type == type; i++) {
1714                                 data->layers[i].active--;
1715                                 data->layers[i].active_rnd--;
1716                                 data->layers[i].active_clone--;
1717                                 data->layers[i].active_mask--;
1718                         }
1719         }
1720
1721         if (data->totlayer <= data->maxlayer - CUSTOMDATA_GROW)
1722                 customData_resize(data, -CUSTOMDATA_GROW);
1723
1724         customData_update_offsets(data);
1725         CustomData_update_typemap(data);
1726
1727         return 1;
1728 }
1729
1730 int CustomData_free_layer_active(CustomData *data, int type, int totelem)
1731 {
1732         int index = 0;
1733         index = CustomData_get_active_layer_index(data, type);
1734         if (index < 0) return 0;
1735         return CustomData_free_layer(data, type, totelem, index);
1736 }
1737
1738
1739 void CustomData_free_layers(CustomData *data, int type, int totelem)
1740 {
1741         while (CustomData_has_layer(data, type))
1742                 CustomData_free_layer_active(data, type, totelem);
1743 }
1744
1745 int CustomData_has_layer(const CustomData *data, int type)
1746 {
1747         return (CustomData_get_layer_index(data, type) != -1);
1748 }
1749
1750 int CustomData_number_of_layers(const CustomData *data, int type)
1751 {
1752         int i, number = 0;
1753
1754         for (i = 0; i < data->totlayer; i++)
1755                 if (data->layers[i].type == type)
1756                         number++;
1757         
1758         return number;
1759 }
1760
1761 void *CustomData_duplicate_referenced_layer(struct CustomData *data, const int type, const int totelem)
1762 {
1763         CustomDataLayer *layer;
1764         int layer_index;
1765
1766         /* get the layer index of the first layer of type */
1767         layer_index = CustomData_get_active_layer_index(data, type);
1768         if (layer_index < 0) return NULL;
1769
1770         layer = &data->layers[layer_index];
1771
1772         if (layer->flag & CD_FLAG_NOFREE) {
1773                 /* MEM_dupallocN won't work in case of complex layers, like e.g.
1774                  * CD_MDEFORMVERT, which has pointers to allocated data...
1775                  * So in case a custom copy function is defined, use it!
1776                  */
1777                 const LayerTypeInfo *typeInfo = layerType_getInfo(layer->type);
1778
1779                 if (typeInfo->copy) {
1780                         char *dest_data = MEM_mallocN(typeInfo->size * totelem, "CD duplicate ref layer");
1781                         typeInfo->copy(layer->data, dest_data, totelem);
1782                         layer->data = dest_data;
1783                 }
1784                 else
1785                         layer->data = MEM_dupallocN(layer->data);
1786
1787                 layer->flag &= ~CD_FLAG_NOFREE;
1788         }
1789
1790         return layer->data;
1791 }
1792
1793 void *CustomData_duplicate_referenced_layer_named(struct CustomData *data,
1794                                                   const int type, const char *name, const int totelem)
1795 {
1796         CustomDataLayer *layer;
1797         int layer_index;
1798
1799         /* get the layer index of the desired layer */
1800         layer_index = CustomData_get_named_layer_index(data, type, name);
1801         if (layer_index < 0) return NULL;
1802
1803         layer = &data->layers[layer_index];
1804
1805         if (layer->flag & CD_FLAG_NOFREE) {
1806                 /* MEM_dupallocN won't work in case of complex layers, like e.g.
1807                  * CD_MDEFORMVERT, which has pointers to allocated data...
1808                  * So in case a custom copy function is defined, use it!
1809                  */
1810                 const LayerTypeInfo *typeInfo = layerType_getInfo(layer->type);
1811
1812                 if (typeInfo->copy) {
1813                         char *dest_data = MEM_mallocN(typeInfo->size * totelem, "CD duplicate ref layer");
1814                         typeInfo->copy(layer->data, dest_data, totelem);
1815                         layer->data = dest_data;
1816                 }
1817                 else
1818                         layer->data = MEM_dupallocN(layer->data);
1819
1820                 layer->flag &= ~CD_FLAG_NOFREE;
1821         }
1822
1823         return layer->data;
1824 }
1825
1826 int CustomData_is_referenced_layer(struct CustomData *data, int type)
1827 {
1828         CustomDataLayer *layer;
1829         int layer_index;
1830
1831         /* get the layer index of the first layer of type */
1832         layer_index = CustomData_get_active_layer_index(data, type);
1833         if (layer_index < 0) return 0;
1834
1835         layer = &data->layers[layer_index];
1836
1837         return (layer->flag & CD_FLAG_NOFREE) != 0;
1838 }
1839
1840 void CustomData_free_temporary(CustomData *data, int totelem)
1841 {
1842         CustomDataLayer *layer;
1843         int i, j;
1844
1845         for (i = 0, j = 0; i < data->totlayer; ++i) {
1846                 layer = &data->layers[i];
1847
1848                 if (i != j)
1849                         data->layers[j] = data->layers[i];
1850
1851                 if ((layer->flag & CD_FLAG_TEMPORARY) == CD_FLAG_TEMPORARY)
1852                         customData_free_layer__internal(layer, totelem);
1853                 else
1854                         j++;
1855         }
1856
1857         data->totlayer = j;
1858
1859         if (data->totlayer <= data->maxlayer - CUSTOMDATA_GROW)
1860                 customData_resize(data, -CUSTOMDATA_GROW);
1861
1862         customData_update_offsets(data);
1863 }
1864
1865 void CustomData_set_only_copy(const struct CustomData *data,
1866                               CustomDataMask mask)
1867 {
1868         int i;
1869
1870         for (i = 0; i < data->totlayer; ++i)
1871                 if (!(mask & CD_TYPE_AS_MASK(data->layers[i].type)))
1872                         data->layers[i].flag |= CD_FLAG_NOCOPY;
1873 }
1874
1875 void CustomData_copy_elements(int type, void *source, void *dest, int count)
1876 {
1877         const LayerTypeInfo *typeInfo = layerType_getInfo(type);
1878
1879         if (typeInfo->copy)
1880                 typeInfo->copy(source, dest, count);
1881         else
1882                 memcpy(dest, source, typeInfo->size * count);
1883 }
1884
1885 void CustomData_copy_data(const CustomData *source, CustomData *dest,
1886                           int source_index, int dest_index, int count)
1887 {
1888         const LayerTypeInfo *typeInfo;
1889         int src_i, dest_i;
1890         int src_offset;
1891         int dest_offset;
1892
1893         /* copies a layer at a time */
1894         dest_i = 0;
1895         for (src_i = 0; src_i < source->totlayer; ++src_i) {
1896
1897                 /* find the first dest layer with type >= the source type
1898                  * (this should work because layers are ordered by type)
1899                  */
1900                 while (dest_i < dest->totlayer && dest->layers[dest_i].type < source->layers[src_i].type) {
1901                         dest_i++;
1902                 }
1903
1904                 /* if there are no more dest layers, we're done */
1905                 if (dest_i >= dest->totlayer) return;
1906
1907                 /* if we found a matching layer, copy the data */
1908                 if (dest->layers[dest_i].type == source->layers[src_i].type) {
1909                         char *src_data = source->layers[src_i].data;
1910                         char *dest_data = dest->layers[dest_i].data;
1911
1912                         typeInfo = layerType_getInfo(source->layers[src_i].type);
1913
1914                         src_offset = source_index * typeInfo->size;
1915                         dest_offset = dest_index * typeInfo->size;
1916                         
1917                         if (!src_data || !dest_data) {
1918                                 if (src_data != NULL && dest_data != NULL) {
1919                                         printf("%s: warning null data for %s type (%p --> %p), skipping\n",
1920                                                __func__, layerType_getName(source->layers[src_i].type),
1921                                                (void *)src_data, (void *)dest_data);
1922                                 }
1923                                 continue;
1924                         }
1925                         
1926                         if (typeInfo->copy)
1927                                 typeInfo->copy(src_data + src_offset,
1928                                                dest_data + dest_offset,
1929                                                count);
1930                         else
1931                                 memcpy(dest_data + dest_offset,
1932                                        src_data + src_offset,
1933                                        count * typeInfo->size);
1934
1935                         /* if there are multiple source & dest layers of the same type,
1936                          * we don't want to copy all source layers to the same dest, so
1937                          * increment dest_i
1938                          */
1939                         dest_i++;
1940                 }
1941         }
1942 }
1943
1944 void CustomData_free_elem(CustomData *data, int index, int count)
1945 {
1946         int i;
1947         const LayerTypeInfo *typeInfo;
1948
1949         for (i = 0; i < data->totlayer; ++i) {
1950                 if (!(data->layers[i].flag & CD_FLAG_NOFREE)) {
1951                         typeInfo = layerType_getInfo(data->layers[i].type);
1952
1953                         if (typeInfo->free) {
1954                                 int offset = typeInfo->size * index;
1955
1956                                 typeInfo->free((char *)data->layers[i].data + offset,
1957                                                count, typeInfo->size);
1958                         }
1959                 }
1960         }
1961 }
1962
1963 #define SOURCE_BUF_SIZE 100
1964
1965 /* This define makes it so when we are interpolating customdata,
1966  * the source is checked if it matches the destination.
1967  *
1968  * There are 2 ways to get around this,
1969  * - Each interp function could accumulate the final result in a local, stack variable,
1970  *   then apply the result at the end.
1971  *
1972  * - Or we can make a temp copy of the destinations custom data before applying it.
1973  *   This isn't so efficient but avoids having to consider feedback loop on each interp function.
1974  *   Since this is more of a corner case its also not worth worrying about speed too much.
1975  *
1976  * (opted for the second option for now), keeping as an ifdef since we may wan't to change how works.
1977  *
1978  * see bug [#32395] - Campbell.
1979  */
1980 #define USE_INTERP_OVERLAP_FIX
1981
1982 void CustomData_interp(const CustomData *source, CustomData *dest,
1983                        int *src_indices, float *weights, float *sub_weights,
1984                        int count, int dest_index)
1985 {
1986         int src_i, dest_i;
1987         int dest_offset;
1988         int j;
1989         void *source_buf[SOURCE_BUF_SIZE];
1990         void **sources = source_buf;
1991
1992         /* slow fallback in case we're interpolating a ridiculous number of
1993          * elements
1994          */
1995         if (count > SOURCE_BUF_SIZE)
1996                 sources = MEM_callocN(sizeof(*sources) * count,
1997                                       "CustomData_interp sources");
1998
1999         /* interpolates a layer at a time */
2000         dest_i = 0;
2001         for (src_i = 0; src_i < source->totlayer; ++src_i) {
2002                 const LayerTypeInfo *typeInfo = layerType_getInfo(source->layers[src_i].type);
2003                 if (!typeInfo->interp) continue;
2004
2005                 /* find the first dest layer with type >= the source type
2006                  * (this should work because layers are ordered by type)
2007                  */
2008                 while (dest_i < dest->totlayer && dest->layers[dest_i].type < source->layers[src_i].type) {
2009                         dest_i++;
2010                 }
2011
2012                 /* if there are no more dest layers, we're done */
2013                 if (dest_i >= dest->totlayer) return;
2014
2015                 /* if we found a matching layer, copy the data */
2016                 if (dest->layers[dest_i].type == source->layers[src_i].type) {
2017                         void *src_data = source->layers[src_i].data;
2018
2019                         for (j = 0; j < count; ++j) {
2020                                 /* if this happens we need to do a temp copy, see: USE_INTERP_OVERLAP_FIX */
2021                                 BLI_assert(((source == dest) && (dest_index == src_indices[j])) == FALSE);
2022
2023                                 sources[j] = (char *)src_data + typeInfo->size * src_indices[j];
2024                         }
2025
2026                         dest_offset = dest_index * typeInfo->size;
2027
2028                         typeInfo->interp(sources, weights, sub_weights, count,
2029                                          (char *)dest->layers[dest_i].data + dest_offset);
2030
2031                         /* if there are multiple source & dest layers of the same type,
2032                          * we don't want to copy all source layers to the same dest, so
2033                          * increment dest_i
2034                          */
2035                         dest_i++;
2036                 }
2037         }
2038
2039         if (count > SOURCE_BUF_SIZE) MEM_freeN(sources);
2040 }
2041
2042 void CustomData_swap(struct CustomData *data, int index, const int *corner_indices)
2043 {
2044         const LayerTypeInfo *typeInfo;
2045         int i;
2046
2047         for (i = 0; i < data->totlayer; ++i) {
2048                 typeInfo = layerType_getInfo(data->layers[i].type);
2049
2050                 if (typeInfo->swap) {
2051                         int offset = typeInfo->size * index;
2052
2053                         typeInfo->swap((char *)data->layers[i].data + offset, corner_indices);
2054                 }
2055         }
2056 }
2057
2058 void *CustomData_get(const CustomData *data, int index, int type)
2059 {
2060         int offset;
2061         int layer_index;
2062         
2063         /* get the layer index of the active layer of type */
2064         layer_index = CustomData_get_active_layer_index(data, type);
2065         if (layer_index < 0) return NULL;
2066
2067         /* get the offset of the desired element */
2068         offset = layerType_getInfo(type)->size * index;
2069
2070         return (char *)data->layers[layer_index].data + offset;
2071 }
2072
2073 void *CustomData_get_n(const CustomData *data, int type, int index, int n)
2074 {
2075         int layer_index;
2076         int offset;
2077
2078         /* get the layer index of the first layer of type */
2079         layer_index = data->typemap[type];
2080         if (layer_index < 0) return NULL;
2081
2082         offset = layerType_getInfo(type)->size * index;
2083         return (char *)data->layers[layer_index + n].data + offset;
2084 }
2085
2086 void *CustomData_get_layer(const CustomData *data, int type)
2087 {
2088         /* get the layer index of the active layer of type */
2089         int layer_index = CustomData_get_active_layer_index(data, type);
2090         if (layer_index < 0) return NULL;
2091
2092         return data->layers[layer_index].data;
2093 }
2094
2095 void *CustomData_get_layer_n(const CustomData *data, int type, int n)
2096 {
2097         /* get the layer index of the active layer of type */
2098         int layer_index = CustomData_get_layer_index_n(data, type, n);
2099         if (layer_index < 0) return NULL;
2100
2101         return data->layers[layer_index].data;
2102 }
2103
2104 void *CustomData_get_layer_named(const struct CustomData *data, int type,
2105                                  const char *name)
2106 {
2107         int layer_index = CustomData_get_named_layer_index(data, type, name);
2108         if (layer_index < 0) return NULL;
2109
2110         return data->layers[layer_index].data;
2111 }
2112
2113
2114 int CustomData_set_layer_name(const CustomData *data, int type, int n, const char *name)
2115 {
2116         /* get the layer index of the first layer of type */
2117         int layer_index = CustomData_get_layer_index_n(data, type, n);
2118
2119         if (layer_index < 0) return 0;
2120         if (!name) return 0;
2121         
2122         strcpy(data->layers[layer_index].name, name);
2123         
2124         return 1;
2125 }
2126
2127 void *CustomData_set_layer(const CustomData *data, int type, void *ptr)
2128 {
2129         /* get the layer index of the first layer of type */
2130         int layer_index = CustomData_get_active_layer_index(data, type);
2131
2132         if (layer_index < 0) return NULL;
2133
2134         data->layers[layer_index].data = ptr;
2135
2136         return ptr;
2137 }
2138
2139 void *CustomData_set_layer_n(const struct CustomData *data, int type, int n, void *ptr)
2140 {
2141         /* get the layer index of the first layer of type */
2142         int layer_index = CustomData_get_layer_index_n(data, type, n);
2143         if (layer_index < 0) return NULL;
2144
2145         data->layers[layer_index].data = ptr;
2146
2147         return ptr;
2148 }
2149
2150 void CustomData_set(const CustomData *data, int index, int type, void *source)
2151 {
2152         void *dest = CustomData_get(data, index, type);
2153         const LayerTypeInfo *typeInfo = layerType_getInfo(type);
2154
2155         if (!dest) return;
2156
2157         if (typeInfo->copy)
2158                 typeInfo->copy(source, dest, 1);
2159         else
2160                 memcpy(dest, source, typeInfo->size);
2161 }
2162
2163 /* BMesh functions */
2164 /* needed to convert to/from different face reps */
2165 void CustomData_to_bmeshpoly(CustomData *fdata, CustomData *pdata, CustomData *ldata,
2166                              int totloop, int totpoly)
2167 {
2168         int i;
2169         for (i = 0; i < fdata->totlayer; i++) {
2170                 if (fdata->layers[i].type == CD_MTFACE) {
2171                         CustomData_add_layer_named(pdata, CD_MTEXPOLY, CD_CALLOC, NULL, totpoly, fdata->layers[i].name);
2172                         CustomData_add_layer_named(ldata, CD_MLOOPUV, CD_CALLOC, NULL, totloop, fdata->layers[i].name);
2173                 }
2174                 else if (fdata->layers[i].type == CD_MCOL) {
2175                         CustomData_add_layer_named(ldata, CD_MLOOPCOL, CD_CALLOC, NULL, totloop, fdata->layers[i].name);
2176                 }
2177                 else if (fdata->layers[i].type == CD_MDISPS) {
2178                         CustomData_add_layer_named(ldata, CD_MDISPS, CD_CALLOC, NULL, totloop, fdata->layers[i].name);
2179                 }
2180         }
2181 }
2182
2183 void CustomData_from_bmeshpoly(CustomData *fdata, CustomData *pdata, CustomData *ldata, int total)
2184 {
2185         int i;
2186         for (i = 0; i < pdata->totlayer; i++) {
2187                 if (pdata->layers[i].type == CD_MTEXPOLY) {
2188                         CustomData_add_layer_named(fdata, CD_MTFACE, CD_CALLOC, NULL, total, pdata->layers[i].name);
2189                 }
2190         }
2191         for (i = 0; i < ldata->totlayer; i++) {
2192                 if (ldata->layers[i].type == CD_MLOOPCOL) {
2193                         CustomData_add_layer_named(fdata, CD_MCOL, CD_CALLOC, NULL, total, ldata->layers[i].name);
2194                 }
2195                 else if (ldata->layers[i].type == CD_PREVIEW_MLOOPCOL) {
2196                         CustomData_add_layer_named(fdata, CD_PREVIEW_MCOL, CD_CALLOC, NULL, total, ldata->layers[i].name);
2197                 }
2198                 else if (ldata->layers[i].type == CD_ORIGSPACE_MLOOP) {
2199                         CustomData_add_layer_named(fdata, CD_ORIGSPACE, CD_CALLOC, NULL, total, ldata->layers[i].name);
2200                 }
2201         }
2202
2203         CustomData_bmesh_update_active_layers(fdata, pdata, ldata);
2204 }
2205
2206 void CustomData_bmesh_update_active_layers(CustomData *fdata, CustomData *pdata, CustomData *ldata)
2207 {
2208         int act;
2209
2210         if (CustomData_has_layer(pdata, CD_MTEXPOLY)) {
2211                 act = CustomData_get_active_layer(pdata, CD_MTEXPOLY);
2212                 CustomData_set_layer_active(ldata, CD_MLOOPUV, act);
2213                 CustomData_set_layer_active(fdata, CD_MTFACE, act);
2214
2215                 act = CustomData_get_render_layer(pdata, CD_MTEXPOLY);
2216                 CustomData_set_layer_render(ldata, CD_MLOOPUV, act);
2217                 CustomData_set_layer_render(fdata, CD_MTFACE, act);
2218
2219                 act = CustomData_get_clone_layer(pdata, CD_MTEXPOLY);
2220                 CustomData_set_layer_clone(ldata, CD_MLOOPUV, act);
2221                 CustomData_set_layer_clone(fdata, CD_MTFACE, act);
2222
2223                 act = CustomData_get_stencil_layer(pdata, CD_MTEXPOLY);
2224                 CustomData_set_layer_stencil(ldata, CD_MLOOPUV, act);
2225                 CustomData_set_layer_stencil(fdata, CD_MTFACE, act);
2226         }
2227
2228         if (CustomData_has_layer(ldata, CD_MLOOPCOL)) {
2229                 act = CustomData_get_active_layer(ldata, CD_MLOOPCOL);
2230                 CustomData_set_layer_active(fdata, CD_MCOL, act);
2231
2232                 act = CustomData_get_render_layer(ldata, CD_MLOOPCOL);
2233                 CustomData_set_layer_render(fdata, CD_MCOL, act);
2234
2235                 act = CustomData_get_clone_layer(ldata, CD_MLOOPCOL);
2236                 CustomData_set_layer_clone(fdata, CD_MCOL, act);
2237
2238                 act = CustomData_get_stencil_layer(ldata, CD_MLOOPCOL);
2239                 CustomData_set_layer_stencil(fdata, CD_MCOL, act);
2240         }
2241 }
2242
2243 /* update active indices for active/render/clone/stencil custom data layers
2244  * based on indices from fdata layers
2245  * used by do_versions in readfile.c when creating pdata and ldata for pre-bmesh
2246  * meshes and needed to preserve active/render/clone/stencil flags set in pre-bmesh files
2247  */
2248 void CustomData_bmesh_do_versions_update_active_layers(CustomData *fdata, CustomData *pdata, CustomData *ldata)
2249 {
2250         int act;
2251
2252         if (CustomData_has_layer(fdata, CD_MTFACE)) {
2253                 act = CustomData_get_active_layer(fdata, CD_MTFACE);
2254                 CustomData_set_layer_active(pdata, CD_MTEXPOLY, act);
2255                 CustomData_set_layer_active(ldata, CD_MLOOPUV, act);
2256
2257                 act = CustomData_get_render_layer(fdata, CD_MTFACE);
2258                 CustomData_set_layer_render(pdata, CD_MTEXPOLY, act);
2259                 CustomData_set_layer_render(ldata, CD_MLOOPUV, act);
2260
2261                 act = CustomData_get_clone_layer(fdata, CD_MTFACE);
2262                 CustomData_set_layer_clone(pdata, CD_MTEXPOLY, act);
2263                 CustomData_set_layer_clone(ldata, CD_MLOOPUV, act);
2264
2265                 act = CustomData_get_stencil_layer(fdata, CD_MTFACE);
2266                 CustomData_set_layer_stencil(pdata, CD_MTEXPOLY, act);
2267                 CustomData_set_layer_stencil(ldata, CD_MLOOPUV, act);
2268         }
2269
2270         if (CustomData_has_layer(fdata, CD_MCOL)) {
2271                 act = CustomData_get_active_layer(fdata, CD_MCOL);
2272                 CustomData_set_layer_active(ldata, CD_MLOOPCOL, act);
2273
2274                 act = CustomData_get_render_layer(fdata, CD_MCOL);
2275                 CustomData_set_layer_render(ldata, CD_MLOOPCOL, act);
2276
2277                 act = CustomData_get_clone_layer(fdata, CD_MCOL);
2278                 CustomData_set_layer_clone(ldata, CD_MLOOPCOL, act);
2279
2280                 act = CustomData_get_stencil_layer(fdata, CD_MCOL);
2281                 CustomData_set_layer_stencil(ldata, CD_MLOOPCOL, act);
2282         }
2283 }
2284
2285 void CustomData_bmesh_init_pool(CustomData *data, int totelem, const char htype)
2286 {
2287         int chunksize;
2288
2289         /* Dispose old pools before calling here to avoid leaks */
2290         BLI_assert(data->pool == NULL);
2291
2292         switch (htype) {
2293                 case BM_VERT: chunksize = bm_mesh_chunksize_default.totvert;  break;
2294                 case BM_EDGE: chunksize = bm_mesh_chunksize_default.totedge;  break;
2295                 case BM_LOOP: chunksize = bm_mesh_chunksize_default.totloop;  break;
2296                 case BM_FACE: chunksize = bm_mesh_chunksize_default.totface;  break;
2297                 default:
2298                         BLI_assert(0);
2299                         chunksize = 512;
2300                         break;
2301         }
2302
2303         /* If there are no layers, no pool is needed just yet */
2304         if (data->totlayer) {
2305                 data->pool = BLI_mempool_create(data->totsize, totelem, chunksize, BLI_MEMPOOL_SYSMALLOC);
2306         }
2307 }
2308
2309 void CustomData_bmesh_merge(CustomData *source, CustomData *dest, 
2310                             CustomDataMask mask, int alloctype, BMesh *bm, const char htype)
2311 {
2312         BMHeader *h;
2313         BMIter iter;
2314         CustomData destold;
2315         void *tmp;
2316         int t;
2317
2318         /* copy old layer description so that old data can be copied into
2319          * the new allocation */
2320         destold = *dest;
2321         if (destold.layers) destold.layers = MEM_dupallocN(destold.layers);
2322         
2323         CustomData_merge(source, dest, mask, alloctype, 0);
2324         dest->pool = NULL;
2325         CustomData_bmesh_init_pool(dest, 512, htype);
2326
2327         switch (htype) {
2328                 case BM_VERT:
2329                         t = BM_VERTS_OF_MESH; break;
2330                 case BM_EDGE:
2331                         t = BM_EDGES_OF_MESH; break;
2332                 case BM_LOOP:
2333                         t = BM_LOOPS_OF_FACE; break;
2334                 case BM_FACE:
2335                         t = BM_FACES_OF_MESH; break;
2336                 default: /* should never happen */
2337                         BLI_assert(!"invalid type given");
2338                         t = BM_VERTS_OF_MESH;
2339         }
2340
2341         if (t != BM_LOOPS_OF_FACE) {
2342                 /*ensure all current elements follow new customdata layout*/
2343                 BM_ITER_MESH (h, &iter, bm, t) {
2344                         tmp = NULL;
2345                         CustomData_bmesh_copy_data(&destold, dest, h->data, &tmp);
2346                         CustomData_bmesh_free_block(&destold, &h->data);
2347                         h->data = tmp;
2348                 }
2349         }
2350         else {
2351                 BMFace *f;
2352                 BMLoop *l;
2353                 BMIter liter;
2354
2355                 /*ensure all current elements follow new customdata layout*/
2356                 BM_ITER_MESH (f, &iter, bm, BM_FACES_OF_MESH) {
2357                         BM_ITER_ELEM (l, &liter, f, BM_LOOPS_OF_FACE) {
2358                                 tmp = NULL;
2359                                 CustomData_bmesh_copy_data(&destold, dest, l->head.data, &tmp);
2360                                 CustomData_bmesh_free_block(&destold, &l->head.data);
2361                                 l->head.data = tmp;
2362                         }
2363                 }
2364         }
2365
2366         if (destold.pool) BLI_mempool_destroy(destold.pool);
2367         if (destold.layers) MEM_freeN(destold.layers);
2368 }
2369
2370 void CustomData_bmesh_free_block(CustomData *data, void **block)
2371 {
2372         const LayerTypeInfo *typeInfo;
2373         int i;
2374
2375         if (!*block) return;
2376         for (i = 0; i < data->totlayer; ++i) {
2377                 if (!(data->layers[i].flag & CD_FLAG_NOFREE)) {
2378                         typeInfo = layerType_getInfo(data->layers[i].type);
2379
2380                         if (typeInfo->free) {
2381                                 int offset = data->layers[i].offset;
2382                                 typeInfo->free((char *)*block + offset, 1, typeInfo->size);
2383                         }
2384                 }
2385         }
2386
2387         if (data->totsize)
2388                 BLI_mempool_free(data->pool, *block);
2389
2390         *block = NULL;
2391 }
2392
2393 static void CustomData_bmesh_alloc_block(CustomData *data, void **block)
2394 {
2395
2396         if (*block)
2397                 CustomData_bmesh_free_block(data, block);
2398
2399         if (data->totsize > 0)
2400                 *block = BLI_mempool_alloc(data->pool);
2401         else
2402                 *block = NULL;
2403 }
2404
2405 void CustomData_bmesh_copy_data(const CustomData *source, CustomData *dest,
2406                                 void *src_block, void **dest_block)
2407 {
2408         const LayerTypeInfo *typeInfo;
2409         int dest_i, src_i;
2410
2411         if (!*dest_block) {
2412                 CustomData_bmesh_alloc_block(dest, dest_block);
2413                 if (*dest_block)
2414                         memset(*dest_block, 0, dest->totsize);
2415         }
2416         
2417         /* copies a layer at a time */
2418         dest_i = 0;
2419         for (src_i = 0; src_i < source->totlayer; ++src_i) {
2420
2421                 /* find the first dest layer with type >= the source type
2422                  * (this should work because layers are ordered by type)
2423                  */
2424                 while (dest_i < dest->totlayer && dest->layers[dest_i].type < source->layers[src_i].type) {
2425                         dest_i++;
2426                 }
2427
2428                 /* if there are no more dest layers, we're done */
2429                 if (dest_i >= dest->totlayer) return;
2430
2431                 /* if we found a matching layer, copy the data */
2432                 if (dest->layers[dest_i].type == source->layers[src_i].type &&
2433                     strcmp(dest->layers[dest_i].name, source->layers[src_i].name) == 0)
2434                 {
2435                         char *src_data = (char *)src_block + source->layers[src_i].offset;
2436                         char *dest_data = (char *)*dest_block + dest->layers[dest_i].offset;
2437
2438                         typeInfo = layerType_getInfo(source->layers[src_i].type);
2439
2440                         if (typeInfo->copy)
2441                                 typeInfo->copy(src_data, dest_data, 1);
2442                         else
2443                                 memcpy(dest_data, src_data, typeInfo->size);
2444
2445                         /* if there are multiple source & dest layers of the same type,
2446                          * we don't want to copy all source layers to the same dest, so
2447                          * increment dest_i
2448                          */
2449                         dest_i++;
2450                 }
2451         }
2452 }
2453
2454 /*Bmesh Custom Data Functions. Should replace editmesh ones with these as well, due to more effecient memory alloc*/
2455 void *CustomData_bmesh_get(const CustomData *data, void *block, int type)
2456 {
2457         int layer_index;
2458         
2459         /* get the layer index of the first layer of type */
2460         layer_index = CustomData_get_active_layer_index(data, type);
2461         if (layer_index < 0) return NULL;
2462
2463         return (char *)block + data->layers[layer_index].offset;
2464 }
2465
2466 void *CustomData_bmesh_get_n(const CustomData *data, void *block, int type, int n)
2467 {
2468         int layer_index;
2469         
2470         /* get the layer index of the first layer of type */
2471         layer_index = CustomData_get_layer_index(data, type);
2472         if (layer_index < 0) return NULL;
2473
2474         return (char *)block + data->layers[layer_index + n].offset;
2475 }
2476
2477 /*gets from the layer at physical index n, note: doesn't check type.*/
2478 void *CustomData_bmesh_get_layer_n(const CustomData *data, void *block, int n)
2479 {
2480         if (n < 0 || n >= data->totlayer) return NULL;
2481
2482         return (char *)block + data->layers[n].offset;
2483 }
2484
2485 int CustomData_layer_has_math(struct CustomData *data, int layer_n)
2486 {
2487         const LayerTypeInfo *typeInfo = layerType_getInfo(data->layers[layer_n].type);
2488         
2489         if (typeInfo->equal && typeInfo->add && typeInfo->multiply && 
2490             typeInfo->initminmax && typeInfo->dominmax)
2491         {
2492                 return 1;
2493         }
2494         
2495         return 0;
2496 }
2497
2498 /* copies the "value" (e.g. mloopuv uv or mloopcol colors) from one block to
2499  * another, while not overwriting anything else (e.g. flags)*/
2500 void CustomData_data_copy_value(int type, void *source, void *dest)
2501 {
2502         const LayerTypeInfo *typeInfo = layerType_getInfo(type);
2503
2504         if (!dest) return;
2505
2506         if (typeInfo->copyvalue)
2507                 typeInfo->copyvalue(source, dest);
2508         else
2509                 memcpy(dest, source, typeInfo->size);
2510 }
2511
2512 int CustomData_data_equals(int type, void *data1, void *data2)
2513 {
2514         const LayerTypeInfo *typeInfo = layerType_getInfo(type);
2515
2516         if (typeInfo->equal)
2517                 return typeInfo->equal(data1, data2);
2518         else return !memcmp(data1, data2, typeInfo->size);
2519 }
2520
2521 void CustomData_data_initminmax(int type, void *min, void *max)
2522 {
2523         const LayerTypeInfo *typeInfo = layerType_getInfo(type);
2524
2525         if (typeInfo->initminmax)
2526                 typeInfo->initminmax(min, max);
2527 }
2528
2529
2530 void CustomData_data_dominmax(int type, void *data, void *min, void *max)
2531 {
2532         const LayerTypeInfo *typeInfo = layerType_getInfo(type);
2533
2534         if (typeInfo->dominmax)
2535                 typeInfo->dominmax(data, min, max);
2536 }
2537
2538
2539 void CustomData_data_multiply(int type, void *data, float fac)
2540 {
2541         const LayerTypeInfo *typeInfo = layerType_getInfo(type);
2542
2543         if (typeInfo->multiply)
2544                 typeInfo->multiply(data, fac);
2545 }
2546
2547
2548 void CustomData_data_add(int type, void *data1, void *data2)
2549 {
2550         const LayerTypeInfo *typeInfo = layerType_getInfo(type);
2551
2552         if (typeInfo->add)
2553                 typeInfo->add(data1, data2);
2554 }
2555
2556 void CustomData_bmesh_set(const CustomData *data, void *block, int type, void *source)
2557 {
2558         void *dest = CustomData_bmesh_get(data, block, type);
2559         const LayerTypeInfo *typeInfo = layerType_getInfo(type);
2560
2561         if (!dest) return;
2562
2563         if (typeInfo->copy)
2564                 typeInfo->copy(source, dest, 1);
2565         else
2566                 memcpy(dest, source, typeInfo->size);
2567 }
2568
2569 void CustomData_bmesh_set_n(CustomData *data, void *block, int type, int n, void *source)
2570 {
2571         void *dest = CustomData_bmesh_get_n(data, block, type, n);
2572         const LayerTypeInfo *typeInfo = layerType_getInfo(type);
2573
2574         if (!dest) return;
2575
2576         if (typeInfo->copy)
2577                 typeInfo->copy(source, dest, 1);
2578         else
2579                 memcpy(dest, source, typeInfo->size);
2580 }
2581
2582 void CustomData_bmesh_set_layer_n(CustomData *data, void *block, int n, void *source)
2583 {
2584         void *dest = CustomData_bmesh_get_layer_n(data, block, n);
2585         const LayerTypeInfo *typeInfo = layerType_getInfo(data->layers[n].type);
2586
2587         if (!dest) return;
2588
2589         if (typeInfo->copy)
2590                 typeInfo->copy(source, dest, 1);
2591         else
2592                 memcpy(dest, source, typeInfo->size);
2593 }
2594
2595 void CustomData_bmesh_interp(CustomData *data, void **src_blocks, float *weights,
2596                              float *sub_weights, int count, void *dest_block)
2597 {
2598         int i, j;
2599         void *source_buf[SOURCE_BUF_SIZE];
2600         void **sources = source_buf;
2601
2602 #ifdef USE_INTERP_OVERLAP_FIX
2603         /* incase there is overlap with the source */
2604         void *dest_block_copy = NULL;
2605 #endif
2606
2607         /* slow fallback in case we're interpolating a ridiculous number of
2608          * elements
2609          */
2610         if (count > SOURCE_BUF_SIZE)
2611                 sources = MEM_callocN(sizeof(*sources) * count,
2612                                       "CustomData_interp sources");
2613
2614         /* interpolates a layer at a time */
2615         for (i = 0; i < data->totlayer; ++i) {
2616                 CustomDataLayer *layer = &data->layers[i];
2617                 const LayerTypeInfo *typeInfo = layerType_getInfo(layer->type);
2618                 if (typeInfo->interp) {
2619                         for (j = 0; j < count; ++j) {
2620 #ifdef USE_INTERP_OVERLAP_FIX
2621                                 void *src_block;
2622                                 if (UNLIKELY(src_blocks[j] == dest_block)) {
2623                                         if (dest_block_copy == NULL) {
2624                                                 CustomData_bmesh_copy_data(data, data, dest_block, &dest_block_copy);
2625                                         }
2626                                         src_block = dest_block_copy;
2627                                 }
2628                                 else {
2629                                         src_block = src_blocks[j];
2630                                 }
2631                                 sources[j] = (char *)src_block + layer->offset;
2632 #else
2633                                 sources[j] = (char *)src_blocks[j] + layer->offset;
2634 #endif
2635                         }
2636
2637                         typeInfo->interp(sources, weights, sub_weights, count,
2638                                          (char *)dest_block + layer->offset);
2639                 }
2640         }
2641
2642 #ifdef USE_INTERP_OVERLAP_FIX
2643         if (dest_block_copy) {
2644                 CustomData_bmesh_free_block(data, &dest_block_copy);
2645         }
2646 #endif
2647
2648         if (count > SOURCE_BUF_SIZE) MEM_freeN(sources);
2649 }
2650
2651 void CustomData_bmesh_set_default(CustomData *data, void **block)
2652 {
2653         const LayerTypeInfo *typeInfo;
2654         int i;
2655
2656         if (!*block)
2657                 CustomData_bmesh_alloc_block(data, block);
2658
2659         for (i = 0; i < data->totlayer; ++i) {
2660                 int offset = data->layers[i].offset;
2661
2662                 typeInfo = layerType_getInfo(data->layers[i].type);
2663
2664                 if (typeInfo->set_default)
2665                         typeInfo->set_default((char *)*block + offset, 1);
2666                 else memset((char *)*block + offset, 0, typeInfo->size);
2667         }
2668 }
2669
2670 void CustomData_to_bmesh_block(const CustomData *source, CustomData *dest,
2671                                int src_index, void **dest_block)
2672 {
2673         const LayerTypeInfo *typeInfo;
2674         int dest_i, src_i, src_offset;
2675
2676         if (!*dest_block)
2677                 CustomData_bmesh_alloc_block(dest, dest_block);
2678         
2679         /* copies a layer at a time */
2680         dest_i = 0;
2681         for (src_i = 0; src_i < source->totlayer; ++src_i) {
2682
2683                 /* find the first dest layer with type >= the source type
2684                  * (this should work because layers are ordered by type)
2685                  */
2686                 while (dest_i < dest->totlayer && dest->layers[dest_i].type < source->layers[src_i].type) {
2687                         dest_i++;
2688                 }
2689
2690                 /* if there are no more dest layers, we're done */
2691                 if (dest_i >= dest->totlayer) return;
2692
2693                 /* if we found a matching layer, copy the data */
2694                 if (dest->layers[dest_i].type == source->layers[src_i].type) {
2695                         int offset = dest->layers[dest_i].offset;
2696                         char *src_data = source->layers[src_i].data;
2697                         char *dest_data = (char *)*dest_block + offset;
2698
2699                         typeInfo = layerType_getInfo(dest->layers[dest_i].type);
2700                         src_offset = src_index * typeInfo->size;
2701
2702                         if (typeInfo->copy)
2703                                 typeInfo->copy(src_data + src_offset, dest_data, 1);
2704                         else
2705                                 memcpy(dest_data, src_data + src_offset, typeInfo->size);
2706
2707                         /* if there are multiple source & dest layers of the same type,
2708                          * we don't want to copy all source layers to the same dest, so
2709                          * increment dest_i
2710                          */
2711                         dest_i++;
2712                 }
2713         }
2714 }
2715
2716 void CustomData_from_bmesh_block(const CustomData *source, CustomData *dest,
2717                                  void *src_block, int dest_index)
2718 {
2719         const LayerTypeInfo *typeInfo;
2720         int dest_i, src_i, dest_offset;
2721
2722         /* copies a layer at a time */
2723         dest_i = 0;
2724         for (src_i = 0; src_i < source->totlayer; ++src_i) {
2725
2726                 /* find the first dest layer with type >= the source type
2727                  * (this should work because layers are ordered by type)
2728                  */
2729                 while (dest_i < dest->totlayer && dest->layers[dest_i].type < source->layers[src_i].type) {
2730                         dest_i++;
2731                 }
2732
2733                 /* if there are no more dest layers, we're done */
2734                 if (dest_i >= dest->totlayer) return;
2735
2736                 /* if we found a matching layer, copy the data */
2737                 if (dest->layers[dest_i].type == source->layers[src_i].type) {
2738                         int offset = source->layers[src_i].offset;
2739                         char *src_data = (char *)src_block + offset;
2740                         char *dest_data = dest->layers[dest_i].data;
2741
2742                         typeInfo = layerType_getInfo(dest->layers[dest_i].type);
2743                         dest_offset = dest_index * typeInfo->size;
2744
2745                         if (typeInfo->copy)
2746                                 typeInfo->copy(src_data, dest_data + dest_offset, 1);
2747                         else
2748                                 memcpy(dest_data + dest_offset, src_data, typeInfo->size);
2749
2750                         /* if there are multiple source & dest layers of the same type,
2751                          * we don't want to copy all source layers to the same dest, so
2752                          * increment dest_i
2753                          */
2754                         dest_i++;
2755                 }
2756         }
2757
2758 }
2759
2760 void CustomData_file_write_info(int type, const char **structname, int *structnum)
2761 {
2762         const LayerTypeInfo *typeInfo = layerType_getInfo(type);
2763
2764         *structname = typeInfo->structname;
2765         *structnum = typeInfo->structnum;
2766 }
2767
2768 int CustomData_sizeof(int type)
2769 {
2770         const LayerTypeInfo *typeInfo = layerType_getInfo(type);
2771
2772         return typeInfo->size;
2773 }
2774
2775 const char *CustomData_layertype_name(int type)
2776 {
2777         return layerType_getName(type);
2778 }
2779
2780
2781 /**
2782  * Can only ever be one of these.
2783  */
2784 int CustomData_layertype_is_singleton(int type)
2785 {
2786         const LayerTypeInfo *typeInfo = layerType_getInfo(type);
2787         return typeInfo->defaultname == NULL;
2788 }
2789
2790 static int  CustomData_is_property_layer(int type)
2791 {
2792         if ((type == CD_PROP_FLT) || (type == CD_PROP_INT) || (type == CD_PROP_STR))
2793                 return 1;
2794         return 0;
2795 }
2796
2797 static int cd_layer_find_dupe(CustomData *data, const char *name, int type, int index)
2798 {
2799         int i;
2800         /* see if there is a duplicate */
2801         for (i = 0; i < data->totlayer; i++) {
2802                 if (i != index) {
2803                         CustomDataLayer *layer = &data->layers[i];
2804                         
2805                         if (CustomData_is_property_layer(type)) {
2806                                 if (CustomData_is_property_layer(layer->type) && strcmp(layer->name, name) == 0) {
2807                                         return 1;
2808                                 }
2809                         }
2810                         else {
2811                                 if (i != index && layer->type == type && strcmp(layer->name, name) == 0) {
2812                                         return 1;
2813                                 }
2814                         }
2815                 }
2816         }
2817         
2818         return 0;
2819 }
2820
2821 static int customdata_unique_check(void *arg, const char *name)
2822 {
2823         struct {CustomData *data; int type; int index; } *data_arg = arg;
2824         return cd_layer_find_dupe(data_arg->data, name, data_arg->type, data_arg->index);
2825 }
2826
2827 void CustomData_set_layer_unique_name(CustomData *data, int index)
2828 {       
2829         CustomDataLayer *nlayer = &data->layers[index];
2830         const LayerTypeInfo *typeInfo = layerType_getInfo(nlayer->type);
2831
2832         struct {CustomData *data; int type; int index; } data_arg;
2833         data_arg.data = data;
2834         data_arg.type = nlayer->type;
2835         data_arg.index = index;
2836
2837         if (!typeInfo->defaultname)
2838                 return;
2839         
2840         BLI_uniquename_cb(customdata_unique_check, &data_arg, typeInfo->defaultname, '.', nlayer->name, sizeof(nlayer->name));
2841 }
2842
2843 void CustomData_validate_layer_name(const CustomData *data, int type, const char *name, char *outname)
2844 {
2845         int index = -1;
2846
2847         /* if a layer name was given, try to find that layer */
2848         if (name[0])
2849                 index = CustomData_get_named_layer_index(data, type, name);
2850
2851         if (index < 0) {
2852                 /* either no layer was specified, or the layer we want has been
2853                  * deleted, so assign the active layer to name
2854                  */
2855                 index = CustomData_get_active_layer_index(data, type);
2856                 strcpy(outname, data->layers[index].name);
2857         }
2858         else
2859                 strcpy(outname, name);
2860 }
2861
2862 int CustomData_verify_versions(struct CustomData *data, int index)
2863 {
2864         const LayerTypeInfo *typeInfo;
2865         CustomDataLayer *layer = &data->layers[index];
2866         int i, keeplayer = 1;
2867
2868         if (layer->type >= CD_NUMTYPES) {
2869                 keeplayer = 0; /* unknown layer type from future version */
2870         }
2871         else {
2872                 typeInfo = layerType_getInfo(layer->type);
2873
2874                 if (!typeInfo->defaultname && (index > 0) &&
2875                     data->layers[index - 1].type == layer->type)
2876                 {
2877                         keeplayer = 0; /* multiple layers of which we only support one */
2878                 }
2879         }
2880
2881         if (!keeplayer) {
2882                 for (i = index + 1; i < data->totlayer; ++i)
2883                         data->layers[i - 1] = data->layers[i];
2884                 data->totlayer--;
2885         }
2886
2887         return keeplayer;
2888 }
2889
2890 /****************************** External Files *******************************/
2891
2892 static void customdata_external_filename(char filename[FILE_MAX], ID *id, CustomDataExternal *external)
2893 {
2894         BLI_strncpy(filename, external->filename, FILE_MAX);
2895         BLI_path_abs(filename, ID_BLEND_PATH(G.main, id));
2896 }
2897
2898 void CustomData_external_reload(CustomData *data, ID *UNUSED(id), CustomDataMask mask, int totelem)
2899 {
2900         CustomDataLayer *layer;
2901         const LayerTypeInfo *typeInfo;
2902         int i;
2903
2904         for (i = 0; i < data->totlayer; i++) {
2905                 layer = &data->layers[i];
2906                 typeInfo = layerType_getInfo(layer->type);
2907
2908                 if (!(mask & CD_TYPE_AS_MASK(layer->type))) ;
2909                 else if ((layer->flag & CD_FLAG_EXTERNAL) && (layer->flag & CD_FLAG_IN_MEMORY)) {
2910                         if (typeInfo->free)
2911                                 typeInfo->free(layer->data, totelem, typeInfo->size);
2912                         layer->flag &= ~CD_FLAG_IN_MEMORY;
2913                 }
2914         }
2915 }
2916
2917 void CustomData_external_read(CustomData *data, ID *id, CustomDataMask mask, int totelem)
2918 {
2919         CustomDataExternal *external = data->external;
2920         CustomDataLayer *layer;
2921         CDataFile *cdf;
2922         CDataFileLayer *blay;
2923         char filename[FILE_MAX];
2924         const LayerTypeInfo *typeInfo;
2925         int i, update = 0;
2926
2927         if (!external)
2928                 return;
2929         
2930         for (i = 0; i < data->totlayer; i++) {
2931                 layer = &data->layers[i];
2932                 typeInfo = layerType_getInfo(layer->type);
2933
2934                 if (!(mask & CD_TYPE_AS_MASK(layer->type))) ;
2935                 else if (layer->flag & CD_FLAG_IN_MEMORY) ;
2936                 else if ((layer->flag & CD_FLAG_EXTERNAL) && typeInfo->read)
2937                         update = 1;
2938         }
2939
2940         if (!update)
2941                 return;
2942
2943         customdata_external_filename(filename, id, external);
2944
2945         cdf = cdf_create(CDF_TYPE_MESH);
2946         if (!cdf_read_open(cdf, filename)) {
2947                 fprintf(stderr, "Failed to read %s layer from %s.\n", layerType_getName(layer->type), filename);
2948                 return;
2949         }
2950
2951         for (i = 0; i < data->totlayer; i++) {
2952                 layer = &data->layers[i];
2953                 typeInfo = layerType_getInfo(layer->type);
2954
2955                 if (!(mask & CD_TYPE_AS_MASK(layer->type))) ;
2956                 else if (layer->flag & CD_FLAG_IN_MEMORY) ;
2957                 else if ((layer->flag & CD_FLAG_EXTERNAL) && typeInfo->read) {
2958                         blay = cdf_layer_find(cdf, layer->type, layer->name);
2959
2960                         if (blay) {
2961                                 if (cdf_read_layer(cdf, blay)) {
2962                                         if (typeInfo->read(cdf, layer->data, totelem)) ;
2963                                         else break;
2964                                         layer->flag |= CD_FLAG_IN_MEMORY;
2965                                 }
2966                                 else
2967                                         break;
2968                         }
2969                 }
2970         }
2971
2972         cdf_read_close(cdf);
2973         cdf_free(cdf);
2974 }
2975
2976 void CustomData_external_write(CustomData *data, ID *id, CustomDataMask mask, int totelem, int free)
2977 {
2978         CustomDataExternal *external = data->external;
2979         CustomDataLayer *layer;
2980         CDataFile *cdf;
2981         CDataFileLayer *blay;
2982         const LayerTypeInfo *typeInfo;
2983         int i, update = 0;
2984         char filename[FILE_MAX];
2985
2986         if (!external)
2987                 return;
2988
2989         /* test if there is anything to write */
2990         for (i = 0; i < data->totlayer; i++) {
2991                 layer = &data->layers[i];
2992                 typeInfo = layerType_getInfo(layer->type);
2993
2994                 if (!(mask & CD_TYPE_AS_MASK(layer->type))) ;
2995                 else if ((layer->flag & CD_FLAG_EXTERNAL) && typeInfo->write)
2996                         update = 1;
2997         }
2998
2999         if (!update)
3000                 return;
3001
3002         /* make sure data is read before we try to write */
3003         CustomData_external_read(data, id, mask, totelem);
3004         customdata_external_filename(filename, id, external);
3005
3006         cdf = cdf_create(CDF_TYPE_MESH);
3007
3008         for (i = 0; i < data->totlayer; i++) {
3009                 layer = &data->layers[i];
3010                 typeInfo = layerType_getInfo(layer->type);
3011
3012                 if ((layer->flag & CD_FLAG_EXTERNAL) && typeInfo->filesize) {
3013                         if (layer->flag & CD_FLAG_IN_MEMORY) {
3014                                 cdf_layer_add(cdf, layer->type, layer->name,
3015                                               typeInfo->filesize(cdf, layer->data, totelem));
3016                         }
3017                         else {
3018                                 cdf_free(cdf);
3019                                 return; /* read failed for a layer! */
3020                         }
3021                 }
3022         }
3023
3024         if (!cdf_write_open(cdf, filename)) {
3025                 fprintf(stderr, "Failed to open %s for writing.\n", filename);
3026                 return;
3027         }
3028
3029         for (i = 0; i < data->totlayer; i++) {
3030                 layer = &data->layers[i];
3031                 typeInfo = layerType_getInfo(layer->type);
3032
3033                 if ((layer->flag & CD_FLAG_EXTERNAL) && typeInfo->write) {
3034                         blay = cdf_layer_find(cdf, layer->type, layer->name);
3035
3036                         if (cdf_write_layer(cdf, blay)) {
3037                                 if (typeInfo->write(cdf, layer->data, totelem)) ;
3038                                 else break;
3039                         }
3040                         else
3041                                 break;
3042                 }
3043         }
3044
3045         if (i != data->totlayer) {
3046                 fprintf(stderr, "Failed to write data to %s.\n", filename);
3047                 cdf_free(cdf);
3048                 return;
3049         }
3050
3051         for (i = 0; i < data->totlayer; i++) {
3052                 layer = &data->layers[i];
3053                 typeInfo = layerType_getInfo(layer->type);
3054
3055                 if ((layer->flag & CD_FLAG_EXTERNAL) && typeInfo->write) {
3056                         if (free) {
3057                                 if (typeInfo->free)
3058                                         typeInfo->free(layer->data, totelem, typeInfo->size);
3059                                 layer->flag &= ~CD_FLAG_IN_MEMORY;
3060                         }
3061                 }
3062         }
3063
3064         cdf_write_close(cdf);
3065         cdf_free(cdf);
3066 }
3067
3068 void CustomData_external_add(CustomData *data, ID *UNUSED(id), int type, int UNUSED(totelem), const char *filename)
3069 {
3070         CustomDataExternal *external = data->external;
3071         CustomDataLayer *layer;
3072         int layer_index;
3073
3074         layer_index = CustomData_get_active_layer_index(data, type);
3075         if (layer_index < 0) return;
3076
3077         layer = &data->layers[layer_index];
3078
3079         if (layer->flag & CD_FLAG_EXTERNAL)
3080                 return;
3081
3082         if (!external) {
3083                 external = MEM_callocN(sizeof(CustomDataExternal), "CustomDataExternal");
3084                 data->external = external;
3085         }
3086         BLI_strncpy(external->filename, filename, sizeof(external->filename));
3087
3088         layer->flag |= CD_FLAG_EXTERNAL | CD_FLAG_IN_MEMORY;
3089 }
3090
3091 void CustomData_external_remove(CustomData *data, ID *id, int type, int totelem)
3092 {
3093         CustomDataExternal *external = data->external;
3094         CustomDataLayer *layer;
3095         //char filename[FILE_MAX];
3096         int layer_index; // i, remove_file;
3097
3098         layer_index = CustomData_get_active_layer_index(data, type);
3099         if (layer_index < 0) return;
3100
3101         layer = &data->layers[layer_index];
3102
3103         if (!external)
3104                 return;
3105
3106         if (layer->flag & CD_FLAG_EXTERNAL) {
3107                 if (!(layer->flag & CD_FLAG_IN_MEMORY))
3108                         CustomData_external_read(data, id, CD_TYPE_AS_MASK(layer->type), totelem);
3109
3110                 layer->flag &= ~CD_FLAG_EXTERNAL;
3111
3112 #if 0
3113                 remove_file = 1;
3114                 for (i = 0; i < data->totlayer; i++)
3115                         if (data->layers[i].flag & CD_FLAG_EXTERNAL)
3116                                 remove_file = 0;
3117
3118                 if (remove_file) {
3119                         customdata_external_filename(filename, id, external);
3120                         cdf_remove(filename);
3121                         CustomData_external_free(data);
3122                 }
3123 #endif
3124         }
3125 }
3126
3127 int CustomData_external_test(CustomData *data, int type)
3128 {
3129         CustomDataLayer *layer;
3130         int layer_index;
3131
3132         layer_index = CustomData_get_active_layer_index(data, type);
3133         if (layer_index < 0) return 0;
3134
3135         layer = &data->layers[layer_index];
3136         return (layer->flag & CD_FLAG_EXTERNAL);
3137 }
3138
3139 #if 0
3140 void CustomData_external_remove_object(CustomData *data, ID *id)
3141 {
3142         CustomDataExternal *external = data->external;
3143         char filename[FILE_MAX];
3144
3145         if (!external)
3146                 return;
3147
3148         customdata_external_filename(filename, id, external);
3149         cdf_remove(filename);
3150         CustomData_external_free(data);
3151 }
3152 #endif
3153