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