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