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