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