source/blender/blenkernel/intern/customdata.c

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