source/blender/blenkernel/intern/modifier.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) 2005 by the Blender Foundation.
  19  * All rights reserved.
  20  *
  21  * Contributor(s): Daniel Dunbar
  22  *                 Ton Roosendaal,
  23  *                 Ben Batt,
  24  *                 Brecht Van Lommel,
  25  *                 Campbell Barton
  26  *
  27  * ***** END GPL LICENSE BLOCK *****
  28  *
  29  * Modifier stack implementation.
  30  *
  31  * BKE_modifier.h contains the function prototypes for this file.
  32  *
  33  */
  34
  35 /** \file blender/blenkernel/intern/modifier.c
  36  *  \ingroup bke
  37  */
  38
  39 #include <stdlib.h>
  40 #include <stddef.h>
  41 #include <string.h>
  42 #include <stdarg.h>
  43 #include <math.h>
  44 #include <float.h>
  45
  46 #include "MEM_guardedalloc.h"
  47
  48 #include "DNA_armature_types.h"
  49 #include "DNA_mesh_types.h"
  50 #include "DNA_object_types.h"
  51
  52 #include "BLI_utildefines.h"
  53 #include "BLI_listbase.h"
  54 #include "BLI_linklist.h"
  55 #include "BLI_path_util.h"
  56 #include "BLI_string.h"
  57 #include "BLI_string_utils.h"
  58
  59 #include "BLT_translation.h"
  60
  61 #include "BKE_appdir.h"
  62 #include "BKE_cdderivedmesh.h"
  63 #include "BKE_idcode.h"
  64 #include "BKE_key.h"
  65 #include "BKE_library.h"
  66 #include "BKE_library_query.h"
  67 #include "BKE_mesh.h"
  68 #include "BKE_multires.h"
  69 #include "BKE_DerivedMesh.h"
  70
  71 /* may move these, only for modifier_path_relbase */
  72 #include "BKE_global.h" /* ugh, G.main->name only */
  73 #include "BKE_main.h"
  74 /* end */
  75
  76 #include "DEG_depsgraph.h"
  77
  78 #include "MOD_modifiertypes.h"
  79
  80 static ModifierTypeInfo *modifier_types[NUM_MODIFIER_TYPES] = {NULL};
  81 static VirtualModifierData virtualModifierCommonData;
  82
  83 void BKE_modifier_init(void)
  84 {
  85         ModifierData *md;
  86
  87         /* Initialize modifier types */
  88         modifier_type_init(modifier_types); /* MOD_utils.c */
  89
  90         /* Initialize global cmmon storage used for virtual modifier list */
  91         md = modifier_new(eModifierType_Armature);
  92         virtualModifierCommonData.amd = *((ArmatureModifierData *) md);
  93         modifier_free(md);
  94
  95         md = modifier_new(eModifierType_Curve);
  96         virtualModifierCommonData.cmd = *((CurveModifierData *) md);
  97         modifier_free(md);
  98
  99         md = modifier_new(eModifierType_Lattice);
 100         virtualModifierCommonData.lmd = *((LatticeModifierData *) md);
 101         modifier_free(md);
 102
 103         md = modifier_new(eModifierType_ShapeKey);
 104         virtualModifierCommonData.smd = *((ShapeKeyModifierData *) md);
 105         modifier_free(md);
 106
 107         virtualModifierCommonData.amd.modifier.mode |= eModifierMode_Virtual;
 108         virtualModifierCommonData.cmd.modifier.mode |= eModifierMode_Virtual;
 109         virtualModifierCommonData.lmd.modifier.mode |= eModifierMode_Virtual;
 110         virtualModifierCommonData.smd.modifier.mode |= eModifierMode_Virtual;
 111 }
 112
 113 const ModifierTypeInfo *modifierType_getInfo(ModifierType type)
 114 {
 115         /* type unsigned, no need to check < 0 */
 116         if (type < NUM_MODIFIER_TYPES && modifier_types[type]->name[0] != '\0') {
 117                 return modifier_types[type];
 118         }
 119         else {
 120                 return NULL;
 121         }
 122 }
 123
 124 /***/
 125
 126 ModifierData *modifier_new(int type)
 127 {
 128         const ModifierTypeInfo *mti = modifierType_getInfo(type);
 129         ModifierData *md = MEM_callocN(mti->structSize, mti->structName);
 130
 131         /* note, this name must be made unique later */
 132         BLI_strncpy(md->name, DATA_(mti->name), sizeof(md->name));
 133
 134         md->type = type;
 135         md->mode = eModifierMode_Realtime | eModifierMode_Render | eModifierMode_Expanded;
 136         md->flag = eModifierFlag_StaticOverride_Local;
 137
 138         if (mti->flags & eModifierTypeFlag_EnableInEditmode)
 139                 md->mode |= eModifierMode_Editmode;
 140
 141         if (mti->initData) mti->initData(md);
 142
 143         return md;
 144 }
 145
 146 static void modifier_free_data_id_us_cb(void *UNUSED(userData), Object *UNUSED(ob), ID **idpoin, int cb_flag)
 147 {
 148         ID *id = *idpoin;
 149         if (id != NULL && (cb_flag & IDWALK_CB_USER) != 0) {
 150                 id_us_min(id);
 151         }
 152 }
 153
 154 void modifier_free_ex(ModifierData *md, const int flag)
 155 {
 156         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
 157
 158         if ((flag & LIB_ID_CREATE_NO_USER_REFCOUNT) == 0) {
 159                 if (mti->foreachIDLink) {
 160                         mti->foreachIDLink(md, NULL, modifier_free_data_id_us_cb, NULL);
 161                 }
 162                 else if (mti->foreachObjectLink) {
 163                         mti->foreachObjectLink(md, NULL, (ObjectWalkFunc)modifier_free_data_id_us_cb, NULL);
 164                 }
 165         }
 166
 167         if (mti->freeData) mti->freeData(md);
 168         if (md->error) MEM_freeN(md->error);
 169
 170         MEM_freeN(md);
 171 }
 172
 173 void modifier_free(ModifierData *md)
 174 {
 175         modifier_free_ex(md, 0);
 176 }
 177
 178 bool modifier_unique_name(ListBase *modifiers, ModifierData *md)
 179 {
 180         if (modifiers && md) {
 181                 const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
 182
 183                 return BLI_uniquename(modifiers, md, DATA_(mti->name), '.', offsetof(ModifierData, name), sizeof(md->name));
 184         }
 185         return false;
 186 }
 187
 188 bool modifier_dependsOnTime(ModifierData *md)
 189 {
 190         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
 191
 192         return mti->dependsOnTime && mti->dependsOnTime(md);
 193 }
 194
 195 bool modifier_supportsMapping(ModifierData *md)
 196 {
 197         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
 198
 199         return (mti->type == eModifierTypeType_OnlyDeform ||
 200                 (mti->flags & eModifierTypeFlag_SupportsMapping));
 201 }
 202
 203 bool modifier_isPreview(ModifierData *md)
 204 {
 205         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
 206
 207         /* Constructive modifiers are highly likely to also modify data like vgroups or vcol! */
 208         if (!((mti->flags & eModifierTypeFlag_UsesPreview) || (mti->type == eModifierTypeType_Constructive))) {
 209                 return false;
 210         }
 211
 212         if (md->mode & eModifierMode_Realtime) {
 213                 return true;
 214         }
 215
 216         return false;
 217 }
 218
 219 ModifierData *modifiers_findByType(Object *ob, ModifierType type)
 220 {
 221         ModifierData *md = ob->modifiers.first;
 222
 223         for (; md; md = md->next)
 224                 if (md->type == type)
 225                         break;
 226
 227         return md;
 228 }
 229
 230 ModifierData *modifiers_findByName(Object *ob, const char *name)
 231 {
 232         return BLI_findstring(&(ob->modifiers), name, offsetof(ModifierData, name));
 233 }
 234
 235 void modifiers_clearErrors(Object *ob)
 236 {
 237         ModifierData *md = ob->modifiers.first;
 238         /* int qRedraw = 0; */
 239
 240         for (; md; md = md->next) {
 241                 if (md->error) {
 242                         MEM_freeN(md->error);
 243                         md->error = NULL;
 244
 245                         /* qRedraw = 1; */
 246                 }
 247         }
 248 }
 249
 250 void modifiers_foreachObjectLink(Object *ob, ObjectWalkFunc walk, void *userData)
 251 {
 252         ModifierData *md = ob->modifiers.first;
 253
 254         for (; md; md = md->next) {
 255                 const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
 256
 257                 if (mti->foreachObjectLink)
 258                         mti->foreachObjectLink(md, ob, walk, userData);
 259         }
 260 }
 261
 262 void modifiers_foreachIDLink(Object *ob, IDWalkFunc walk, void *userData)
 263 {
 264         ModifierData *md = ob->modifiers.first;
 265
 266         for (; md; md = md->next) {
 267                 const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
 268
 269                 if (mti->foreachIDLink) mti->foreachIDLink(md, ob, walk, userData);
 270                 else if (mti->foreachObjectLink) {
 271                         /* each Object can masquerade as an ID, so this should be OK */
 272                         ObjectWalkFunc fp = (ObjectWalkFunc)walk;
 273                         mti->foreachObjectLink(md, ob, fp, userData);
 274                 }
 275         }
 276 }
 277
 278 void modifiers_foreachTexLink(Object *ob, TexWalkFunc walk, void *userData)
 279 {
 280         ModifierData *md = ob->modifiers.first;
 281
 282         for (; md; md = md->next) {
 283                 const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
 284
 285                 if (mti->foreachTexLink)
 286                         mti->foreachTexLink(md, ob, walk, userData);
 287         }
 288 }
 289
 290 /* callback's can use this
 291  * to avoid copying every member.
 292  */
 293 void modifier_copyData_generic(const ModifierData *md_src, ModifierData *md_dst)
 294 {
 295         const ModifierTypeInfo *mti = modifierType_getInfo(md_src->type);
 296         const size_t data_size = sizeof(ModifierData);
 297         const char *md_src_data = ((const char *)md_src) + data_size;
 298         char       *md_dst_data =       ((char *)md_dst) + data_size;
 299         BLI_assert(data_size <= (size_t)mti->structSize);
 300         memcpy(md_dst_data, md_src_data, (size_t)mti->structSize - data_size);
 301 }
 302
 303 static void modifier_copy_data_id_us_cb(void *UNUSED(userData), Object *UNUSED(ob), ID **idpoin, int cb_flag)
 304 {
 305         ID *id = *idpoin;
 306         if (id != NULL && (cb_flag & IDWALK_CB_USER) != 0) {
 307                 id_us_plus(id);
 308         }
 309 }
 310
 311 void modifier_copyData_ex(ModifierData *md, ModifierData *target, const int flag)
 312 {
 313         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
 314
 315         target->mode = md->mode;
 316         target->flag = md->flag;
 317
 318         if (mti->copyData) {
 319                 mti->copyData(md, target);
 320         }
 321
 322         if ((flag & LIB_ID_CREATE_NO_USER_REFCOUNT) == 0) {
 323                 if (mti->foreachIDLink) {
 324                         mti->foreachIDLink(target, NULL, modifier_copy_data_id_us_cb, NULL);
 325                 }
 326                 else if (mti->foreachObjectLink) {
 327                         mti->foreachObjectLink(target, NULL, (ObjectWalkFunc)modifier_copy_data_id_us_cb, NULL);
 328                 }
 329         }
 330 }
 331
 332 void modifier_copyData(ModifierData *md, ModifierData *target)
 333 {
 334         modifier_copyData_ex(md, target, 0);
 335 }
 336
 337
 338 bool modifier_supportsCage(struct Scene *scene, ModifierData *md)
 339 {
 340         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
 341
 342         md->scene = scene;
 343
 344         return ((!mti->isDisabled || !mti->isDisabled(md, 0)) &&
 345                 (mti->flags & eModifierTypeFlag_SupportsEditmode) &&
 346                 modifier_supportsMapping(md));
 347 }
 348
 349 bool modifier_couldBeCage(struct Scene *scene, ModifierData *md)
 350 {
 351         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
 352
 353         md->scene = scene;
 354
 355         return ((md->mode & eModifierMode_Realtime) &&
 356                 (md->mode & eModifierMode_Editmode) &&
 357                 (!mti->isDisabled || !mti->isDisabled(md, 0)) &&
 358                 modifier_supportsMapping(md));
 359 }
 360
 361 bool modifier_isSameTopology(ModifierData *md)
 362 {
 363         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
 364         return ELEM(mti->type, eModifierTypeType_OnlyDeform, eModifierTypeType_NonGeometrical);
 365 }
 366
 367 bool modifier_isNonGeometrical(ModifierData *md)
 368 {
 369         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
 370         return (mti->type == eModifierTypeType_NonGeometrical);
 371 }
 372
 373 void modifier_setError(ModifierData *md, const char *_format, ...)
 374 {
 375         char buffer[512];
 376         va_list ap;
 377         const char *format = TIP_(_format);
 378
 379         va_start(ap, _format);
 380         vsnprintf(buffer, sizeof(buffer), format, ap);
 381         va_end(ap);
 382         buffer[sizeof(buffer) - 1] = '\0';
 383
 384         if (md->error)
 385                 MEM_freeN(md->error);
 386
 387         md->error = BLI_strdup(buffer);
 388
 389 }
 390
 391 /* used for buttons, to find out if the 'draw deformed in editmode' option is
 392  * there
 393  *
 394  * also used in transform_conversion.c, to detect CrazySpace [tm] (2nd arg
 395  * then is NULL)
 396  * also used for some mesh tools to give warnings
 397  */
 398 int modifiers_getCageIndex(struct Scene *scene, Object *ob, int *r_lastPossibleCageIndex, bool is_virtual)
 399 {
 400         VirtualModifierData virtualModifierData;
 401         ModifierData *md = (is_virtual) ? modifiers_getVirtualModifierList(ob, &virtualModifierData) : ob->modifiers.first;
 402         int i, cageIndex = -1;
 403
 404         if (r_lastPossibleCageIndex) {
 405                 /* ensure the value is initialized */
 406                 *r_lastPossibleCageIndex = -1;
 407         }
 408
 409         /* Find the last modifier acting on the cage. */
 410         for (i = 0; md; i++, md = md->next) {
 411                 const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
 412                 bool supports_mapping;
 413
 414                 md->scene = scene;
 415
 416                 if (mti->isDisabled && mti->isDisabled(md, 0)) continue;
 417                 if (!(mti->flags & eModifierTypeFlag_SupportsEditmode)) continue;
 418                 if (md->mode & eModifierMode_DisableTemporary) continue;
 419
 420                 supports_mapping = modifier_supportsMapping(md);
 421                 if (r_lastPossibleCageIndex && supports_mapping) {
 422                         *r_lastPossibleCageIndex = i;
 423                 }
 424
 425                 if (!(md->mode & eModifierMode_Realtime)) continue;
 426                 if (!(md->mode & eModifierMode_Editmode)) continue;
 427
 428                 if (!supports_mapping)
 429                         break;
 430
 431                 if (md->mode & eModifierMode_OnCage)
 432                         cageIndex = i;
 433         }
 434
 435         return cageIndex;
 436 }
 437
 438
 439 bool modifiers_isSoftbodyEnabled(Object *ob)
 440 {
 441         ModifierData *md = modifiers_findByType(ob, eModifierType_Softbody);
 442
 443         return (md && md->mode & (eModifierMode_Realtime | eModifierMode_Render));
 444 }
 445
 446 bool modifiers_isClothEnabled(Object *ob)
 447 {
 448         ModifierData *md = modifiers_findByType(ob, eModifierType_Cloth);
 449
 450         return (md && md->mode & (eModifierMode_Realtime | eModifierMode_Render));
 451 }
 452
 453 bool modifiers_isModifierEnabled(Object *ob, int modifierType)
 454 {
 455         ModifierData *md = modifiers_findByType(ob, modifierType);
 456
 457         return (md && md->mode & (eModifierMode_Realtime | eModifierMode_Render));
 458 }
 459
 460 bool modifiers_isParticleEnabled(Object *ob)
 461 {
 462         ModifierData *md = modifiers_findByType(ob, eModifierType_ParticleSystem);
 463
 464         return (md && md->mode & (eModifierMode_Realtime | eModifierMode_Render));
 465 }
 466
 467 /**
 468  * Check whether is enabled.
 469  *
 470  * \param scene Current scene, may be NULL, in which case isDisabled callback of the modifier is never called.
 471  */
 472 bool modifier_isEnabled(struct Scene *scene, ModifierData *md, int required_mode)
 473 {
 474         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
 475
 476         md->scene = scene;
 477
 478         if ((md->mode & required_mode) != required_mode) return false;
 479         if (scene != NULL && mti->isDisabled && mti->isDisabled(md, required_mode == eModifierMode_Render)) return false;
 480         if (md->mode & eModifierMode_DisableTemporary) return false;
 481         if ((required_mode & eModifierMode_Editmode) && !(mti->flags & eModifierTypeFlag_SupportsEditmode)) return false;
 482
 483         return true;
 484 }
 485
 486 CDMaskLink *modifiers_calcDataMasks(struct Scene *scene, Object *ob, ModifierData *md,
 487                                     CustomDataMask dataMask, int required_mode,
 488                                     ModifierData *previewmd, CustomDataMask previewmask)
 489 {
 490         CDMaskLink *dataMasks = NULL;
 491         CDMaskLink *curr, *prev;
 492
 493         /* build a list of modifier data requirements in reverse order */
 494         for (; md; md = md->next) {
 495                 const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
 496
 497                 curr = MEM_callocN(sizeof(CDMaskLink), "CDMaskLink");
 498
 499                 if (modifier_isEnabled(scene, md, required_mode)) {
 500                         if (mti->requiredDataMask)
 501                                 curr->mask = mti->requiredDataMask(ob, md);
 502
 503                         if (previewmd == md) {
 504                                 curr->mask |= previewmask;
 505                         }
 506                 }
 507
 508                 /* prepend new datamask */
 509                 curr->next = dataMasks;
 510                 dataMasks = curr;
 511         }
 512
 513         /* build the list of required data masks - each mask in the list must
 514          * include all elements of the masks that follow it
 515          *
 516          * note the list is currently in reverse order, so "masks that follow it"
 517          * actually means "masks that precede it" at the moment
 518          */
 519         for (curr = dataMasks, prev = NULL; curr; prev = curr, curr = curr->next) {
 520                 if (prev) {
 521                         CustomDataMask prev_mask = prev->mask;
 522                         CustomDataMask curr_mask = curr->mask;
 523
 524                         curr->mask = curr_mask | prev_mask;
 525                 }
 526                 else {
 527                         CustomDataMask curr_mask = curr->mask;
 528
 529                         curr->mask = curr_mask | dataMask;
 530                 }
 531         }
 532
 533         /* reverse the list so it's in the correct order */
 534         BLI_linklist_reverse((LinkNode **)&dataMasks);
 535
 536         return dataMasks;
 537 }
 538
 539 ModifierData *modifiers_getLastPreview(struct Scene *scene, ModifierData *md, int required_mode)
 540 {
 541         ModifierData *tmp_md = NULL;
 542
 543         if ((required_mode & ~eModifierMode_Editmode) != eModifierMode_Realtime)
 544                 return tmp_md;
 545
 546         /* Find the latest modifier in stack generating preview. */
 547         for (; md; md = md->next) {
 548                 if (modifier_isEnabled(scene, md, required_mode) && modifier_isPreview(md))
 549                         tmp_md = md;
 550         }
 551         return tmp_md;
 552 }
 553
 554 /* NOTE: This is to support old files from before Blender supported modifiers,
 555  * in some cases versioning code updates these so for new files this will
 556  * return an empty list. */
 557 ModifierData *modifiers_getVirtualModifierList(Object *ob, VirtualModifierData *virtualModifierData)
 558 {
 559         ModifierData *md;
 560
 561         md = ob->modifiers.first;
 562
 563         *virtualModifierData = virtualModifierCommonData;
 564
 565         if (ob->parent) {
 566                 if (ob->parent->type == OB_ARMATURE && ob->partype == PARSKEL) {
 567                         virtualModifierData->amd.object = ob->parent;
 568                         virtualModifierData->amd.modifier.next = md;
 569                         virtualModifierData->amd.deformflag = ((bArmature *)(ob->parent->data))->deformflag;
 570                         md = &virtualModifierData->amd.modifier;
 571                 }
 572                 else if (ob->parent->type == OB_CURVE && ob->partype == PARSKEL) {
 573                         virtualModifierData->cmd.object = ob->parent;
 574                         virtualModifierData->cmd.defaxis = ob->trackflag + 1;
 575                         virtualModifierData->cmd.modifier.next = md;
 576                         md = &virtualModifierData->cmd.modifier;
 577                 }
 578                 else if (ob->parent->type == OB_LATTICE && ob->partype == PARSKEL) {
 579                         virtualModifierData->lmd.object = ob->parent;
 580                         virtualModifierData->lmd.modifier.next = md;
 581                         md = &virtualModifierData->lmd.modifier;
 582                 }
 583         }
 584
 585         /* shape key modifier, not yet for curves */
 586         if (ELEM(ob->type, OB_MESH, OB_LATTICE) && BKE_key_from_object(ob)) {
 587                 if (ob->type == OB_MESH && (ob->shapeflag & OB_SHAPE_EDIT_MODE))
 588                         virtualModifierData->smd.modifier.mode |= eModifierMode_Editmode | eModifierMode_OnCage;
 589                 else
 590                         virtualModifierData->smd.modifier.mode &= ~eModifierMode_Editmode | eModifierMode_OnCage;
 591
 592                 virtualModifierData->smd.modifier.next = md;
 593                 md = &virtualModifierData->smd.modifier;
 594         }
 595
 596         return md;
 597 }
 598
 599 /* Takes an object and returns its first selected armature, else just its armature
 600  * This should work for multiple armatures per object
 601  */
 602 Object *modifiers_isDeformedByArmature(Object *ob)
 603 {
 604         VirtualModifierData virtualModifierData;
 605         ModifierData *md = modifiers_getVirtualModifierList(ob, &virtualModifierData);
 606         ArmatureModifierData *amd = NULL;
 607
 608         /* return the first selected armature, this lets us use multiple armatures */
 609         for (; md; md = md->next) {
 610                 if (md->type == eModifierType_Armature) {
 611                         amd = (ArmatureModifierData *) md;
 612                         if (amd->object && (amd->object->flag & SELECT))
 613                                 return amd->object;
 614                 }
 615         }
 616
 617         if (amd) /* if were still here then return the last armature */
 618                 return amd->object;
 619
 620         return NULL;
 621 }
 622
 623 /* Takes an object and returns its first selected lattice, else just its lattice
 624  * This should work for multiple lattices per object
 625  */
 626 Object *modifiers_isDeformedByLattice(Object *ob)
 627 {
 628         VirtualModifierData virtualModifierData;
 629         ModifierData *md = modifiers_getVirtualModifierList(ob, &virtualModifierData);
 630         LatticeModifierData *lmd = NULL;
 631
 632         /* return the first selected lattice, this lets us use multiple lattices */
 633         for (; md; md = md->next) {
 634                 if (md->type == eModifierType_Lattice) {
 635                         lmd = (LatticeModifierData *) md;
 636                         if (lmd->object && (lmd->object->flag & SELECT))
 637                                 return lmd->object;
 638                 }
 639         }
 640
 641         if (lmd) /* if were still here then return the last lattice */
 642                 return lmd->object;
 643
 644         return NULL;
 645 }
 646
 647 /* Takes an object and returns its first selected curve, else just its curve
 648  * This should work for multiple curves per object
 649  */
 650 Object *modifiers_isDeformedByCurve(Object *ob)
 651 {
 652         VirtualModifierData virtualModifierData;
 653         ModifierData *md = modifiers_getVirtualModifierList(ob, &virtualModifierData);
 654         CurveModifierData *cmd = NULL;
 655
 656         /* return the first selected curve, this lets us use multiple curves */
 657         for (; md; md = md->next) {
 658                 if (md->type == eModifierType_Curve) {
 659                         cmd = (CurveModifierData *) md;
 660                         if (cmd->object && (cmd->object->flag & SELECT))
 661                                 return cmd->object;
 662                 }
 663         }
 664
 665         if (cmd) /* if were still here then return the last curve */
 666                 return cmd->object;
 667
 668         return NULL;
 669 }
 670
 671 bool modifiers_usesArmature(Object *ob, bArmature *arm)
 672 {
 673         VirtualModifierData virtualModifierData;
 674         ModifierData *md = modifiers_getVirtualModifierList(ob, &virtualModifierData);
 675
 676         for (; md; md = md->next) {
 677                 if (md->type == eModifierType_Armature) {
 678                         ArmatureModifierData *amd = (ArmatureModifierData *) md;
 679                         if (amd->object && amd->object->data == arm)
 680                                 return true;
 681                 }
 682         }
 683
 684         return false;
 685 }
 686
 687 bool modifier_isCorrectableDeformed(ModifierData *md)
 688 {
 689         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
 690         return (mti->deformMatricesEM != NULL) || (mti->deformMatricesEM_DM != NULL);
 691 }
 692
 693 bool modifiers_isCorrectableDeformed(struct Scene *scene, Object *ob)
 694 {
 695         VirtualModifierData virtualModifierData;
 696         ModifierData *md = modifiers_getVirtualModifierList(ob, &virtualModifierData);
 697         int required_mode = eModifierMode_Realtime;
 698
 699         if (ob->mode == OB_MODE_EDIT) {
 700                 required_mode |= eModifierMode_Editmode;
 701         }
 702         for (; md; md = md->next) {
 703                 if (!modifier_isEnabled(scene, md, required_mode)) {
 704                         /* pass */
 705                 }
 706                 else if (modifier_isCorrectableDeformed(md)) {
 707                         return true;
 708                 }
 709         }
 710         return false;
 711 }
 712
 713 /* Check whether the given object has a modifier in its stack that uses WEIGHT_MCOL CD layer
 714  * to preview something... Used by DynamicPaint and WeightVG currently. */
 715 bool modifiers_isPreview(Object *ob)
 716 {
 717         ModifierData *md = ob->modifiers.first;
 718
 719         for (; md; md = md->next) {
 720                 if (modifier_isPreview(md))
 721                         return true;
 722         }
 723
 724         return false;
 725 }
 726
 727 void modifier_freeTemporaryData(ModifierData *md)
 728 {
 729         if (md->type == eModifierType_Armature) {
 730                 ArmatureModifierData *amd = (ArmatureModifierData *)md;
 731
 732                 if (amd->prevCos) {
 733                         MEM_freeN(amd->prevCos);
 734                         amd->prevCos = NULL;
 735                 }
 736         }
 737 }
 738
 739 /* ensure modifier correctness when changing ob->data */
 740 void test_object_modifiers(Object *ob)
 741 {
 742         ModifierData *md;
 743
 744         /* just multires checked for now, since only multires
 745          * modifies mesh data */
 746
 747         if (ob->type != OB_MESH) return;
 748
 749         for (md = ob->modifiers.first; md; md = md->next) {
 750                 if (md->type == eModifierType_Multires) {
 751                         MultiresModifierData *mmd = (MultiresModifierData *)md;
 752
 753                         multiresModifier_set_levels_from_disps(mmd, ob);
 754                 }
 755         }
 756 }
 757
 758 /* where should this go?, it doesnt fit well anywhere :S - campbell */
 759
 760 /* elubie: changed this to default to the same dir as the render output
 761  * to prevent saving to C:\ on Windows */
 762
 763 /* campbell: logic behind this...
 764  *
 765  * - if the ID is from a library, return library path
 766  * - else if the file has been saved return the blend file path.
 767  * - else if the file isn't saved and the ID isn't from a library, return the temp dir.
 768  */
 769 const char *modifier_path_relbase(Object *ob)
 770 {
 771         if (G.relbase_valid || ID_IS_LINKED(ob)) {
 772                 return ID_BLEND_PATH(G.main, &ob->id);
 773         }
 774         else {
 775                 /* last resort, better then using "" which resolves to the current
 776                  * working directory */
 777                 return BKE_tempdir_session();
 778         }
 779 }
 780
 781 /* initializes the path with either */
 782 void modifier_path_init(char *path, int path_maxlen, const char *name)
 783 {
 784         /* elubie: changed this to default to the same dir as the render output
 785          * to prevent saving to C:\ on Windows */
 786         BLI_join_dirfile(path, path_maxlen,
 787                          G.relbase_valid ? "//" : BKE_tempdir_session(),
 788                          name);
 789 }
 790
 791
 792 /* wrapper around ModifierTypeInfo.applyModifier that ensures valid normals */
 793
 794 struct DerivedMesh *modwrap_applyModifier(
 795         ModifierData *md, const ModifierEvalContext *ctx,
 796         struct DerivedMesh *dm)
 797 {
 798         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
 799         BLI_assert(CustomData_has_layer(&dm->polyData, CD_NORMAL) == false);
 800
 801         if (mti->dependsOnNormals && mti->dependsOnNormals(md)) {
 802                 DM_ensure_normals(dm);
 803         }
 804         return modifier_applyModifier_DM_deprecated(md, ctx, dm);
 805 }
 806
 807 struct DerivedMesh *modwrap_applyModifierEM(
 808         ModifierData *md, const ModifierEvalContext *ctx,
 809         struct BMEditMesh *em, DerivedMesh *dm)
 810 {
 811         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
 812         BLI_assert(CustomData_has_layer(&dm->polyData, CD_NORMAL) == false);
 813
 814         if (mti->dependsOnNormals && mti->dependsOnNormals(md)) {
 815                 DM_ensure_normals(dm);
 816         }
 817         return modifier_applyModifierEM_DM_deprecated(md, ctx, em, dm);
 818 }
 819
 820 void modwrap_deformVerts(
 821         ModifierData *md, const ModifierEvalContext *ctx,
 822         DerivedMesh *dm, float (*vertexCos)[3], int numVerts)
 823 {
 824         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
 825         BLI_assert(!dm || CustomData_has_layer(&dm->polyData, CD_NORMAL) == false);
 826
 827         if (dm && mti->dependsOnNormals && mti->dependsOnNormals(md)) {
 828                 DM_ensure_normals(dm);
 829         }
 830         modifier_deformVerts_DM_deprecated(md, ctx, dm, vertexCos, numVerts);
 831 }
 832
 833 void modwrap_deformVertsEM(
 834         ModifierData *md, const ModifierEvalContext *ctx,
 835         struct BMEditMesh *em, DerivedMesh *dm,
 836         float (*vertexCos)[3], int numVerts)
 837 {
 838         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
 839         BLI_assert(!dm || CustomData_has_layer(&dm->polyData, CD_NORMAL) == false);
 840
 841         if (dm && mti->dependsOnNormals && mti->dependsOnNormals(md)) {
 842                 DM_ensure_normals(dm);
 843         }
 844         modifier_deformVertsEM_DM_deprecated(md, ctx, em, dm, vertexCos, numVerts);
 845 }
 846 /* end modifier callback wrappers */
 847
 848
 849 /* wrappers for modifier callbacks that accept Mesh and select the proper implementation
 850  * depending on if the modifier has been ported to Mesh or is still using DerivedMesh
 851  */
 852
 853 void modifier_deformVerts(struct ModifierData *md, const ModifierEvalContext *ctx,
 854         struct Mesh *mesh,
 855         float (*vertexCos)[3], int numVerts)
 856 {
 857         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
 858
 859         if (mti->deformVerts) {
 860                 mti->deformVerts(md, ctx, mesh, vertexCos, numVerts);
 861         }
 862         else {
 863                 DerivedMesh *dm = NULL;
 864                 if (mesh) {
 865                         dm = CDDM_from_mesh(mesh);
 866                 }
 867
 868                 mti->deformVerts_DM(md, ctx, dm, vertexCos, numVerts);
 869
 870                 if (dm) {
 871                         dm->release(dm);
 872                 }
 873         }
 874 }
 875
 876 void modifier_deformMatrices(struct ModifierData *md, const ModifierEvalContext *ctx,
 877         struct Mesh *mesh,
 878         float (*vertexCos)[3], float (*defMats)[3][3], int numVerts)
 879 {
 880         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
 881
 882         if (mti->deformMatrices) {
 883                 mti->deformMatrices(md, ctx, mesh, vertexCos, defMats, numVerts);
 884         }
 885         else {
 886                 DerivedMesh *dm = NULL;
 887                 if (mesh) {
 888                         dm = CDDM_from_mesh(mesh);
 889                 }
 890
 891                 mti->deformMatrices_DM(md, ctx, dm, vertexCos, defMats, numVerts);
 892
 893                 if (dm) {
 894                         dm->release(dm);
 895                 }
 896         }
 897 }
 898
 899 void modifier_deformVertsEM(struct ModifierData *md, const ModifierEvalContext *ctx,
 900         struct BMEditMesh *editData, struct Mesh *mesh,
 901         float (*vertexCos)[3], int numVerts)
 902 {
 903         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
 904
 905         if (mti->deformVertsEM) {
 906                 mti->deformVertsEM(md, ctx, editData, mesh, vertexCos, numVerts);
 907         }
 908         else {
 909                 DerivedMesh *dm = NULL;
 910                 if (mesh) {
 911                         dm = CDDM_from_mesh(mesh);
 912                 }
 913
 914                 mti->deformVertsEM_DM(md, ctx, editData, dm, vertexCos, numVerts);
 915
 916                 if (dm) {
 917                         dm->release(dm);
 918                 }
 919         }
 920 }
 921
 922 void modifier_deformMatricesEM(struct ModifierData *md, const ModifierEvalContext *ctx,
 923         struct BMEditMesh *editData, struct Mesh *mesh,
 924         float (*vertexCos)[3], float (*defMats)[3][3], int numVerts)
 925 {
 926         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
 927
 928         if (mti->deformMatricesEM) {
 929                 mti->deformMatricesEM(md, ctx, editData, mesh, vertexCos, defMats, numVerts);
 930         }
 931         else {
 932                 DerivedMesh *dm = NULL;
 933                 if (mesh) {
 934                         dm = CDDM_from_mesh(mesh);
 935                 }
 936
 937                 mti->deformMatricesEM_DM(md, ctx, editData, dm, vertexCos, defMats, numVerts);
 938
 939                 if (dm) {
 940                         dm->release(dm);
 941                 }
 942         }
 943 }
 944
 945 struct Mesh *modifier_applyModifier(struct ModifierData *md, const ModifierEvalContext *ctx,
 946         struct Mesh *mesh)
 947 {
 948         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
 949
 950         if (mti->applyModifier) {
 951                 return mti->applyModifier(md, ctx, mesh);
 952         }
 953         else {
 954                 DerivedMesh *dm = CDDM_from_mesh(mesh);
 955
 956                 DerivedMesh *ndm = mti->applyModifier_DM(md, ctx, dm);
 957
 958                 if(ndm != dm) {
 959                         dm->release(dm);
 960                 }
 961
 962                 DM_to_mesh(ndm, mesh, ctx->object, CD_MASK_EVERYTHING, true);
 963
 964                 return mesh;
 965         }
 966 }
 967
 968 struct Mesh *modifier_applyModifierEM(struct ModifierData *md, const ModifierEvalContext *ctx,
 969         struct BMEditMesh *editData,
 970         struct Mesh *mesh)
 971 {
 972         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
 973
 974         if (mti->applyModifierEM) {
 975                 return mti->applyModifierEM(md, ctx, editData, mesh);
 976         }
 977         else {
 978                 DerivedMesh *dm = CDDM_from_mesh(mesh);
 979
 980                 DerivedMesh *ndm = mti->applyModifierEM_DM(md, ctx, editData, dm);
 981
 982                 if(ndm != dm) {
 983                         dm->release(dm);
 984                 }
 985
 986                 DM_to_mesh(ndm, mesh, ctx->object, CD_MASK_EVERYTHING, true);
 987
 988                 return mesh;
 989         }
 990 }
 991
 992 /* depricated variants of above that accept DerivedMesh */
 993
 994 void modifier_deformVerts_DM_deprecated(struct ModifierData *md, const ModifierEvalContext *ctx,
 995         struct DerivedMesh *dm,
 996         float (*vertexCos)[3], int numVerts)
 997 {
 998         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
 999
1000         if (mti->deformVerts_DM) {
1001                 mti->deformVerts_DM(md, ctx, dm, vertexCos, numVerts);
1002         }
1003         else {
1004                 /* TODO(sybren): deduplicate all the copies of this code in this file. */
1005                 Mesh *mesh = NULL;
1006                 if (dm != NULL) {
1007                         mesh = BKE_id_new_nomain(ID_ME, NULL);
1008                         DM_to_mesh(dm, mesh, ctx->object, CD_MASK_EVERYTHING, false);
1009                 }
1010
1011                 mti->deformVerts(md, ctx, mesh, vertexCos, numVerts);
1012
1013                 if (mesh != NULL) {
1014                         BKE_id_free(NULL, mesh);
1015                 }
1016         }
1017 }
1018
1019 void modifier_deformMatrices_DM_deprecated(struct ModifierData *md, const ModifierEvalContext *ctx,
1020         struct DerivedMesh *dm,
1021         float (*vertexCos)[3], float (*defMats)[3][3], int numVerts)
1022 {
1023
1024         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
1025
1026         if (mti->deformMatrices_DM) {
1027                 mti->deformMatrices_DM(md, ctx, dm, vertexCos, defMats, numVerts);
1028         }
1029         else {
1030                 /* TODO(sybren): deduplicate all the copies of this code in this file. */
1031                 Mesh *mesh = NULL;
1032                 if (dm != NULL) {
1033                         mesh = BKE_id_new_nomain(ID_ME, NULL);
1034                         DM_to_mesh(dm, mesh, ctx->object, CD_MASK_EVERYTHING, false);
1035                 }
1036
1037                 mti->deformMatrices(md, ctx, mesh, vertexCos, defMats, numVerts);
1038
1039                 if (mesh != NULL) {
1040                         BKE_id_free(NULL, mesh);
1041                 }
1042         }
1043 }
1044
1045 void modifier_deformVertsEM_DM_deprecated(struct ModifierData *md, const ModifierEvalContext *ctx,
1046         struct BMEditMesh *editData, struct DerivedMesh *dm,
1047         float (*vertexCos)[3], int numVerts)
1048 {
1049         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
1050
1051         if (mti->deformVertsEM_DM) {
1052                 mti->deformVertsEM_DM(md, ctx, editData, dm, vertexCos, numVerts);
1053         }
1054         else {
1055                 /* TODO(sybren): deduplicate all the copies of this code in this file. */
1056                 Mesh *mesh = NULL;
1057                 if (dm != NULL) {
1058                         mesh = BKE_id_new_nomain(ID_ME, NULL);
1059                         DM_to_mesh(dm, mesh, ctx->object, CD_MASK_EVERYTHING, false);
1060                 }
1061
1062                 mti->deformVertsEM(md, ctx, editData, mesh, vertexCos, numVerts);
1063
1064                 if (mesh != NULL) {
1065                         BKE_id_free(NULL, mesh);
1066                 }
1067         }
1068 }
1069
1070 void modifier_deformMatricesEM_DM_deprecated(struct ModifierData *md, const ModifierEvalContext *ctx,
1071         struct BMEditMesh *editData, struct DerivedMesh *dm,
1072         float (*vertexCos)[3], float (*defMats)[3][3], int numVerts)
1073 {
1074         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
1075
1076         if (mti->deformMatricesEM_DM) {
1077                 mti->deformMatricesEM_DM(md, ctx, editData, dm, vertexCos, defMats, numVerts);
1078         }
1079         else {
1080                 /* TODO(sybren): deduplicate all the copies of this code in this file. */
1081                 Mesh *mesh = NULL;
1082                 if (dm != NULL) {
1083                         mesh = BKE_id_new_nomain(ID_ME, NULL);
1084                         DM_to_mesh(dm, mesh, ctx->object, CD_MASK_EVERYTHING, false);
1085                 }
1086
1087                 mti->deformMatricesEM(md, ctx, editData, mesh, vertexCos, defMats, numVerts);
1088
1089                 if (mesh != NULL) {
1090                         BKE_id_free(NULL, mesh);
1091                 }
1092         }
1093 }
1094
1095 struct DerivedMesh *modifier_applyModifier_DM_deprecated(struct ModifierData *md, const ModifierEvalContext *ctx,
1096         struct DerivedMesh *dm)
1097 {
1098         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
1099
1100         if (mti->applyModifier_DM) {
1101                 return mti->applyModifier_DM(md, ctx, dm);
1102         }
1103         else {
1104                 /* TODO(sybren): deduplicate all the copies of this code in this file. */
1105                 Mesh *mesh = NULL;
1106                 if (dm != NULL) {
1107                         mesh = BKE_id_new_nomain(ID_ME, NULL);
1108                         DM_to_mesh(dm, mesh, ctx->object, CD_MASK_EVERYTHING, false);
1109                 }
1110
1111                 struct Mesh *new_mesh = mti->applyModifier(md, ctx, mesh);
1112
1113                 /* Make a DM that doesn't reference new_mesh so we can free the latter. */
1114                 DerivedMesh *ndm = CDDM_from_mesh_ex(new_mesh, CD_DUPLICATE);
1115
1116                 if(new_mesh != mesh) {
1117                         BKE_id_free(NULL, new_mesh);
1118                 }
1119                 if (mesh != NULL) {
1120                         BKE_id_free(NULL, mesh);
1121                 }
1122
1123                 return ndm;
1124         }
1125 }
1126
1127 struct DerivedMesh *modifier_applyModifierEM_DM_deprecated(struct ModifierData *md, const ModifierEvalContext *ctx,
1128         struct BMEditMesh *editData,
1129         struct DerivedMesh *dm)
1130 {
1131         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
1132
1133         if (mti->applyModifierEM_DM) {
1134                 return mti->applyModifierEM_DM(md, ctx, editData, dm);
1135         }
1136         else {
1137                 /* TODO(sybren): deduplicate all the copies of this code in this file. */
1138                 Mesh *mesh = NULL;
1139                 if (dm != NULL) {
1140                         mesh = BKE_id_new_nomain(ID_ME, NULL);
1141                         DM_to_mesh(dm, mesh, ctx->object, CD_MASK_EVERYTHING, false);
1142                 }
1143
1144                 struct Mesh *new_mesh = mti->applyModifierEM(md, ctx, editData, mesh);
1145
1146                 /* Make a DM that doesn't reference new_mesh so we can free the latter. */
1147                 DerivedMesh *ndm = CDDM_from_mesh_ex(new_mesh, CD_DUPLICATE);
1148
1149                 if(new_mesh != mesh) {
1150                         BKE_id_free(NULL, new_mesh);
1151                 }
1152                 if (mesh != NULL) {
1153                         BKE_id_free(NULL, mesh);
1154                 }
1155
1156                 return ndm;
1157         }
1158 }
1159