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_object_types.h"
  50
  51 #include "BLI_utildefines.h"
  52 #include "BLI_listbase.h"
  53 #include "BLI_linklist.h"
  54 #include "BLI_path_util.h"
  55 #include "BLI_string.h"
  56 #include "BLI_string_utils.h"
  57
  58 #include "BLT_translation.h"
  59
  60 #include "BKE_appdir.h"
  61 #include "BKE_key.h"
  62 #include "BKE_library.h"
  63 #include "BKE_library_query.h"
  64 #include "BKE_multires.h"
  65 #include "BKE_DerivedMesh.h"
  66
  67 /* may move these, only for modifier_path_relbase */
  68 #include "BKE_global.h" /* ugh, G.main->name only */
  69 #include "BKE_main.h"
  70 /* end */
  71
  72 #include "MOD_modifiertypes.h"
  73
  74 static ModifierTypeInfo *modifier_types[NUM_MODIFIER_TYPES] = {NULL};
  75 static VirtualModifierData virtualModifierCommonData;
  76
  77 void BKE_modifier_init(void)
  78 {
  79         ModifierData *md;
  80
  81         /* Initialize modifier types */
  82         modifier_type_init(modifier_types); /* MOD_utils.c */
  83
  84         /* Initialize global cmmon storage used for virtual modifier list */
  85         md = modifier_new(eModifierType_Armature);
  86         virtualModifierCommonData.amd = *((ArmatureModifierData *) md);
  87         modifier_free(md);
  88
  89         md = modifier_new(eModifierType_Curve);
  90         virtualModifierCommonData.cmd = *((CurveModifierData *) md);
  91         modifier_free(md);
  92
  93         md = modifier_new(eModifierType_Lattice);
  94         virtualModifierCommonData.lmd = *((LatticeModifierData *) md);
  95         modifier_free(md);
  96
  97         md = modifier_new(eModifierType_ShapeKey);
  98         virtualModifierCommonData.smd = *((ShapeKeyModifierData *) md);
  99         modifier_free(md);
 100
 101         virtualModifierCommonData.amd.modifier.mode |= eModifierMode_Virtual;
 102         virtualModifierCommonData.cmd.modifier.mode |= eModifierMode_Virtual;
 103         virtualModifierCommonData.lmd.modifier.mode |= eModifierMode_Virtual;
 104         virtualModifierCommonData.smd.modifier.mode |= eModifierMode_Virtual;
 105 }
 106
 107 const ModifierTypeInfo *modifierType_getInfo(ModifierType type)
 108 {
 109         /* type unsigned, no need to check < 0 */
 110         if (type < NUM_MODIFIER_TYPES && modifier_types[type]->name[0] != '\0') {
 111                 return modifier_types[type];
 112         }
 113         else {
 114                 return NULL;
 115         }
 116 }
 117
 118 /***/
 119
 120 ModifierData *modifier_new(int type)
 121 {
 122         const ModifierTypeInfo *mti = modifierType_getInfo(type);
 123         ModifierData *md = MEM_callocN(mti->structSize, mti->structName);
 124
 125         /* note, this name must be made unique later */
 126         BLI_strncpy(md->name, DATA_(mti->name), sizeof(md->name));
 127
 128         md->type = type;
 129         md->mode = eModifierMode_Realtime | eModifierMode_Render | eModifierMode_Expanded;
 130
 131         if (mti->flags & eModifierTypeFlag_EnableInEditmode)
 132                 md->mode |= eModifierMode_Editmode;
 133
 134         if (mti->initData) mti->initData(md);
 135
 136         return md;
 137 }
 138
 139 static void modifier_free_data_id_us_cb(void *UNUSED(userData), Object *UNUSED(ob), ID **idpoin, int cb_flag)
 140 {
 141         ID *id = *idpoin;
 142         if (id != NULL && (cb_flag & IDWALK_CB_USER) != 0) {
 143                 id_us_min(id);
 144         }
 145 }
 146
 147 void modifier_free_ex(ModifierData *md, const int flag)
 148 {
 149         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
 150
 151         if ((flag & LIB_ID_CREATE_NO_USER_REFCOUNT) == 0) {
 152                 if (mti->foreachIDLink) {
 153                         mti->foreachIDLink(md, NULL, modifier_free_data_id_us_cb, NULL);
 154                 }
 155                 else if (mti->foreachObjectLink) {
 156                         mti->foreachObjectLink(md, NULL, (ObjectWalkFunc)modifier_free_data_id_us_cb, NULL);
 157                 }
 158         }
 159
 160         if (mti->freeData) mti->freeData(md);
 161         if (md->error) MEM_freeN(md->error);
 162
 163         MEM_freeN(md);
 164 }
 165
 166 void modifier_free(ModifierData *md)
 167 {
 168         modifier_free_ex(md, 0);
 169 }
 170
 171 bool modifier_unique_name(ListBase *modifiers, ModifierData *md)
 172 {
 173         if (modifiers && md) {
 174                 const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
 175
 176                 return BLI_uniquename(modifiers, md, DATA_(mti->name), '.', offsetof(ModifierData, name), sizeof(md->name));
 177         }
 178         return false;
 179 }
 180
 181 bool modifier_dependsOnTime(ModifierData *md)
 182 {
 183         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
 184
 185         return mti->dependsOnTime && mti->dependsOnTime(md);
 186 }
 187
 188 bool modifier_supportsMapping(ModifierData *md)
 189 {
 190         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
 191
 192         return (mti->type == eModifierTypeType_OnlyDeform ||
 193                 (mti->flags & eModifierTypeFlag_SupportsMapping));
 194 }
 195
 196 bool modifier_isPreview(ModifierData *md)
 197 {
 198         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
 199
 200         /* Constructive modifiers are highly likely to also modify data like vgroups or vcol! */
 201         if (!((mti->flags & eModifierTypeFlag_UsesPreview) || (mti->type == eModifierTypeType_Constructive))) {
 202                 return false;
 203         }
 204
 205         if (md->mode & eModifierMode_Realtime) {
 206                 return true;
 207         }
 208
 209         return false;
 210 }
 211
 212 ModifierData *modifiers_findByType(Object *ob, ModifierType type)
 213 {
 214         ModifierData *md = ob->modifiers.first;
 215
 216         for (; md; md = md->next)
 217                 if (md->type == type)
 218                         break;
 219
 220         return md;
 221 }
 222
 223 ModifierData *modifiers_findByName(Object *ob, const char *name)
 224 {
 225         return BLI_findstring(&(ob->modifiers), name, offsetof(ModifierData, name));
 226 }
 227
 228 void modifiers_clearErrors(Object *ob)
 229 {
 230         ModifierData *md = ob->modifiers.first;
 231         /* int qRedraw = 0; */
 232
 233         for (; md; md = md->next) {
 234                 if (md->error) {
 235                         MEM_freeN(md->error);
 236                         md->error = NULL;
 237
 238                         /* qRedraw = 1; */
 239                 }
 240         }
 241 }
 242
 243 void modifiers_foreachObjectLink(Object *ob, ObjectWalkFunc walk, void *userData)
 244 {
 245         ModifierData *md = ob->modifiers.first;
 246
 247         for (; md; md = md->next) {
 248                 const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
 249
 250                 if (mti->foreachObjectLink)
 251                         mti->foreachObjectLink(md, ob, walk, userData);
 252         }
 253 }
 254
 255 void modifiers_foreachIDLink(Object *ob, IDWalkFunc walk, void *userData)
 256 {
 257         ModifierData *md = ob->modifiers.first;
 258
 259         for (; md; md = md->next) {
 260                 const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
 261
 262                 if (mti->foreachIDLink) mti->foreachIDLink(md, ob, walk, userData);
 263                 else if (mti->foreachObjectLink) {
 264                         /* each Object can masquerade as an ID, so this should be OK */
 265                         ObjectWalkFunc fp = (ObjectWalkFunc)walk;
 266                         mti->foreachObjectLink(md, ob, fp, userData);
 267                 }
 268         }
 269 }
 270
 271 void modifiers_foreachTexLink(Object *ob, TexWalkFunc walk, void *userData)
 272 {
 273         ModifierData *md = ob->modifiers.first;
 274
 275         for (; md; md = md->next) {
 276                 const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
 277
 278                 if (mti->foreachTexLink)
 279                         mti->foreachTexLink(md, ob, walk, userData);
 280         }
 281 }
 282
 283 /* callback's can use this
 284  * to avoid copying every member.
 285  */
 286 void modifier_copyData_generic(const ModifierData *md_src, ModifierData *md_dst)
 287 {
 288         const ModifierTypeInfo *mti = modifierType_getInfo(md_src->type);
 289
 290         /* md_dst may have alredy be fully initialized with some extra allocated data,
 291          * we need to free it now to avoid memleak. */
 292         if (mti->freeData) {
 293                 mti->freeData(md_dst);
 294         }
 295
 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
 317         if (mti->copyData) {
 318                 mti->copyData(md, target);
 319         }
 320
 321         if ((flag & LIB_ID_CREATE_NO_USER_REFCOUNT) == 0) {
 322                 if (mti->foreachIDLink) {
 323                         mti->foreachIDLink(target, NULL, modifier_copy_data_id_us_cb, NULL);
 324                 }
 325                 else if (mti->foreachObjectLink) {
 326                         mti->foreachObjectLink(target, NULL, (ObjectWalkFunc)modifier_copy_data_id_us_cb, NULL);
 327                 }
 328         }
 329 }
 330
 331 void modifier_copyData(ModifierData *md, ModifierData *target)
 332 {
 333         modifier_copyData_ex(md, target, 0);
 334 }
 335
 336
 337 bool modifier_supportsCage(struct Scene *scene, ModifierData *md)
 338 {
 339         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
 340
 341         md->scene = scene;
 342
 343         return ((!mti->isDisabled || !mti->isDisabled(md, 0)) &&
 344                 (mti->flags & eModifierTypeFlag_SupportsEditmode) &&
 345                 modifier_supportsMapping(md));
 346 }
 347
 348 bool modifier_couldBeCage(struct Scene *scene, ModifierData *md)
 349 {
 350         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
 351
 352         md->scene = scene;
 353
 354         return ((md->mode & eModifierMode_Realtime) &&
 355                 (md->mode & eModifierMode_Editmode) &&
 356                 (!mti->isDisabled || !mti->isDisabled(md, 0)) &&
 357                 modifier_supportsMapping(md));
 358 }
 359
 360 bool modifier_isSameTopology(ModifierData *md)
 361 {
 362         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
 363         return ELEM(mti->type, eModifierTypeType_OnlyDeform, eModifierTypeType_NonGeometrical);
 364 }
 365
 366 bool modifier_isNonGeometrical(ModifierData *md)
 367 {
 368         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
 369         return (mti->type == eModifierTypeType_NonGeometrical);
 370 }
 371
 372 void modifier_setError(ModifierData *md, const char *_format, ...)
 373 {
 374         char buffer[512];
 375         va_list ap;
 376         const char *format = TIP_(_format);
 377
 378         va_start(ap, _format);
 379         vsnprintf(buffer, sizeof(buffer), format, ap);
 380         va_end(ap);
 381         buffer[sizeof(buffer) - 1] = '\0';
 382
 383         if (md->error)
 384                 MEM_freeN(md->error);
 385
 386         md->error = BLI_strdup(buffer);
 387
 388 }
 389
 390 /* used for buttons, to find out if the 'draw deformed in editmode' option is
 391  * there
 392  *
 393  * also used in transform_conversion.c, to detect CrazySpace [tm] (2nd arg
 394  * then is NULL)
 395  * also used for some mesh tools to give warnings
 396  */
 397 int modifiers_getCageIndex(struct Scene *scene, Object *ob, int *r_lastPossibleCageIndex, bool is_virtual)
 398 {
 399         VirtualModifierData virtualModifierData;
 400         ModifierData *md = (is_virtual) ? modifiers_getVirtualModifierList(ob, &virtualModifierData) : ob->modifiers.first;
 401         int i, cageIndex = -1;
 402
 403         if (r_lastPossibleCageIndex) {
 404                 /* ensure the value is initialized */
 405                 *r_lastPossibleCageIndex = -1;
 406         }
 407
 408         /* Find the last modifier acting on the cage. */
 409         for (i = 0; md; i++, md = md->next) {
 410                 const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
 411                 bool supports_mapping;
 412
 413                 md->scene = scene;
 414
 415                 if (mti->isDisabled && mti->isDisabled(md, 0)) continue;
 416                 if (!(mti->flags & eModifierTypeFlag_SupportsEditmode)) continue;
 417                 if (md->mode & eModifierMode_DisableTemporary) continue;
 418
 419                 supports_mapping = modifier_supportsMapping(md);
 420                 if (r_lastPossibleCageIndex && supports_mapping) {
 421                         *r_lastPossibleCageIndex = i;
 422                 }
 423
 424                 if (!(md->mode & eModifierMode_Realtime)) continue;
 425                 if (!(md->mode & eModifierMode_Editmode)) continue;
 426
 427                 if (!supports_mapping)
 428                         break;
 429
 430                 if (md->mode & eModifierMode_OnCage)
 431                         cageIndex = i;
 432         }
 433
 434         return cageIndex;
 435 }
 436
 437
 438 bool modifiers_isSoftbodyEnabled(Object *ob)
 439 {
 440         ModifierData *md = modifiers_findByType(ob, eModifierType_Softbody);
 441
 442         return (md && md->mode & (eModifierMode_Realtime | eModifierMode_Render));
 443 }
 444
 445 bool modifiers_isClothEnabled(Object *ob)
 446 {
 447         ModifierData *md = modifiers_findByType(ob, eModifierType_Cloth);
 448
 449         return (md && md->mode & (eModifierMode_Realtime | eModifierMode_Render));
 450 }
 451
 452 bool modifiers_isModifierEnabled(Object *ob, int modifierType)
 453 {
 454         ModifierData *md = modifiers_findByType(ob, modifierType);
 455
 456         return (md && md->mode & (eModifierMode_Realtime | eModifierMode_Render));
 457 }
 458
 459 bool modifiers_isParticleEnabled(Object *ob)
 460 {
 461         ModifierData *md = modifiers_findByType(ob, eModifierType_ParticleSystem);
 462
 463         return (md && md->mode & (eModifierMode_Realtime | eModifierMode_Render));
 464 }
 465
 466 /**
 467  * Check whether is enabled.
 468  *
 469  * \param scene Current scene, may be NULL, in which case isDisabled callback of the modifier is never called.
 470  */
 471 bool modifier_isEnabled(struct Scene *scene, ModifierData *md, int required_mode)
 472 {
 473         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
 474
 475         md->scene = scene;
 476
 477         if ((md->mode & required_mode) != required_mode) return false;
 478         if (scene != NULL && mti->isDisabled && mti->isDisabled(md, required_mode == eModifierMode_Render)) return false;
 479         if (md->mode & eModifierMode_DisableTemporary) return false;
 480         if ((required_mode & eModifierMode_Editmode) && !(mti->flags & eModifierTypeFlag_SupportsEditmode)) return false;
 481
 482         return true;
 483 }
 484
 485 CDMaskLink *modifiers_calcDataMasks(struct Scene *scene, Object *ob, ModifierData *md,
 486                                     CustomDataMask dataMask, int required_mode,
 487                                     ModifierData *previewmd, CustomDataMask previewmask)
 488 {
 489         CDMaskLink *dataMasks = NULL;
 490         CDMaskLink *curr, *prev;
 491
 492         /* build a list of modifier data requirements in reverse order */
 493         for (; md; md = md->next) {
 494                 const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
 495
 496                 curr = MEM_callocN(sizeof(CDMaskLink), "CDMaskLink");
 497
 498                 if (modifier_isEnabled(scene, md, required_mode)) {
 499                         if (mti->requiredDataMask)
 500                                 curr->mask = mti->requiredDataMask(ob, md);
 501
 502                         if (previewmd == md) {
 503                                 curr->mask |= previewmask;
 504                         }
 505                 }
 506
 507                 /* prepend new datamask */
 508                 curr->next = dataMasks;
 509                 dataMasks = curr;
 510         }
 511
 512         /* build the list of required data masks - each mask in the list must
 513          * include all elements of the masks that follow it
 514          *
 515          * note the list is currently in reverse order, so "masks that follow it"
 516          * actually means "masks that precede it" at the moment
 517          */
 518         for (curr = dataMasks, prev = NULL; curr; prev = curr, curr = curr->next) {
 519                 if (prev) {
 520                         CustomDataMask prev_mask = prev->mask;
 521                         CustomDataMask curr_mask = curr->mask;
 522
 523                         curr->mask = curr_mask | prev_mask;
 524                 }
 525                 else {
 526                         CustomDataMask curr_mask = curr->mask;
 527
 528                         curr->mask = curr_mask | dataMask;
 529                 }
 530         }
 531
 532         /* reverse the list so it's in the correct order */
 533         BLI_linklist_reverse((LinkNode **)&dataMasks);
 534
 535         return dataMasks;
 536 }
 537
 538 ModifierData *modifiers_getLastPreview(struct Scene *scene, ModifierData *md, int required_mode)
 539 {
 540         ModifierData *tmp_md = NULL;
 541
 542         if ((required_mode & ~eModifierMode_Editmode) != eModifierMode_Realtime)
 543                 return tmp_md;
 544
 545         /* Find the latest modifier in stack generating preview. */
 546         for (; md; md = md->next) {
 547                 if (modifier_isEnabled(scene, md, required_mode) && modifier_isPreview(md))
 548                         tmp_md = md;
 549         }
 550         return tmp_md;
 551 }
 552
 553 /* NOTE: This is to support old files from before Blender supported modifiers,
 554  * in some cases versioning code updates these so for new files this will
 555  * return an empty list. */
 556 ModifierData *modifiers_getVirtualModifierList(Object *ob, VirtualModifierData *virtualModifierData)
 557 {
 558         ModifierData *md;
 559
 560         md = ob->modifiers.first;
 561
 562         *virtualModifierData = virtualModifierCommonData;
 563
 564         if (ob->parent) {
 565                 if (ob->parent->type == OB_ARMATURE && ob->partype == PARSKEL) {
 566                         virtualModifierData->amd.object = ob->parent;
 567                         virtualModifierData->amd.modifier.next = md;
 568                         virtualModifierData->amd.deformflag = ((bArmature *)(ob->parent->data))->deformflag;
 569                         md = &virtualModifierData->amd.modifier;
 570                 }
 571                 else if (ob->parent->type == OB_CURVE && ob->partype == PARSKEL) {
 572                         virtualModifierData->cmd.object = ob->parent;
 573                         virtualModifierData->cmd.defaxis = ob->trackflag + 1;
 574                         virtualModifierData->cmd.modifier.next = md;
 575                         md = &virtualModifierData->cmd.modifier;
 576                 }
 577                 else if (ob->parent->type == OB_LATTICE && ob->partype == PARSKEL) {
 578                         virtualModifierData->lmd.object = ob->parent;
 579                         virtualModifierData->lmd.modifier.next = md;
 580                         md = &virtualModifierData->lmd.modifier;
 581                 }
 582         }
 583
 584         /* shape key modifier, not yet for curves */
 585         if (ELEM(ob->type, OB_MESH, OB_LATTICE) && BKE_key_from_object(ob)) {
 586                 if (ob->type == OB_MESH && (ob->shapeflag & OB_SHAPE_EDIT_MODE))
 587                         virtualModifierData->smd.modifier.mode |= eModifierMode_Editmode | eModifierMode_OnCage;
 588                 else
 589                         virtualModifierData->smd.modifier.mode &= ~eModifierMode_Editmode | eModifierMode_OnCage;
 590
 591                 virtualModifierData->smd.modifier.next = md;
 592                 md = &virtualModifierData->smd.modifier;
 593         }
 594
 595         return md;
 596 }
 597
 598 /* Takes an object and returns its first selected armature, else just its armature
 599  * This should work for multiple armatures per object
 600  */
 601 Object *modifiers_isDeformedByArmature(Object *ob)
 602 {
 603         VirtualModifierData virtualModifierData;
 604         ModifierData *md = modifiers_getVirtualModifierList(ob, &virtualModifierData);
 605         ArmatureModifierData *amd = NULL;
 606
 607         /* return the first selected armature, this lets us use multiple armatures */
 608         for (; md; md = md->next) {
 609                 if (md->type == eModifierType_Armature) {
 610                         amd = (ArmatureModifierData *) md;
 611                         if (amd->object && (amd->object->flag & SELECT))
 612                                 return amd->object;
 613                 }
 614         }
 615
 616         if (amd) /* if were still here then return the last armature */
 617                 return amd->object;
 618
 619         return NULL;
 620 }
 621
 622 /* Takes an object and returns its first selected lattice, else just its lattice
 623  * This should work for multiple lattices per object
 624  */
 625 Object *modifiers_isDeformedByLattice(Object *ob)
 626 {
 627         VirtualModifierData virtualModifierData;
 628         ModifierData *md = modifiers_getVirtualModifierList(ob, &virtualModifierData);
 629         LatticeModifierData *lmd = NULL;
 630
 631         /* return the first selected lattice, this lets us use multiple lattices */
 632         for (; md; md = md->next) {
 633                 if (md->type == eModifierType_Lattice) {
 634                         lmd = (LatticeModifierData *) md;
 635                         if (lmd->object && (lmd->object->flag & SELECT))
 636                                 return lmd->object;
 637                 }
 638         }
 639
 640         if (lmd) /* if were still here then return the last lattice */
 641                 return lmd->object;
 642
 643         return NULL;
 644 }
 645
 646 /* Takes an object and returns its first selected curve, else just its curve
 647  * This should work for multiple curves per object
 648  */
 649 Object *modifiers_isDeformedByCurve(Object *ob)
 650 {
 651         VirtualModifierData virtualModifierData;
 652         ModifierData *md = modifiers_getVirtualModifierList(ob, &virtualModifierData);
 653         CurveModifierData *cmd = NULL;
 654
 655         /* return the first selected curve, this lets us use multiple curves */
 656         for (; md; md = md->next) {
 657                 if (md->type == eModifierType_Curve) {
 658                         cmd = (CurveModifierData *) md;
 659                         if (cmd->object && (cmd->object->flag & SELECT))
 660                                 return cmd->object;
 661                 }
 662         }
 663
 664         if (cmd) /* if were still here then return the last curve */
 665                 return cmd->object;
 666
 667         return NULL;
 668 }
 669
 670 bool modifiers_usesArmature(Object *ob, bArmature *arm)
 671 {
 672         VirtualModifierData virtualModifierData;
 673         ModifierData *md = modifiers_getVirtualModifierList(ob, &virtualModifierData);
 674
 675         for (; md; md = md->next) {
 676                 if (md->type == eModifierType_Armature) {
 677                         ArmatureModifierData *amd = (ArmatureModifierData *) md;
 678                         if (amd->object && amd->object->data == arm)
 679                                 return true;
 680                 }
 681         }
 682
 683         return false;
 684 }
 685
 686 bool modifier_isCorrectableDeformed(ModifierData *md)
 687 {
 688         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
 689         return (mti->deformMatricesEM != NULL);
 690 }
 691
 692 bool modifiers_isCorrectableDeformed(struct Scene *scene, Object *ob)
 693 {
 694         VirtualModifierData virtualModifierData;
 695         ModifierData *md = modifiers_getVirtualModifierList(ob, &virtualModifierData);
 696         int required_mode = eModifierMode_Realtime;
 697
 698         if (ob->mode == OB_MODE_EDIT)
 699                 required_mode |= eModifierMode_Editmode;
 700
 701         for (; md; md = md->next) {
 702                 if (!modifier_isEnabled(scene, md, required_mode)) {
 703                         /* pass */
 704                 }
 705                 else if (modifier_isCorrectableDeformed(md)) {
 706                         return true;
 707                 }
 708         }
 709         return false;
 710 }
 711
 712 /* Check whether the given object has a modifier in its stack that uses WEIGHT_MCOL CD layer
 713  * to preview something... Used by DynamicPaint and WeightVG currently. */
 714 bool modifiers_isPreview(Object *ob)
 715 {
 716         ModifierData *md = ob->modifiers.first;
 717
 718         for (; md; md = md->next) {
 719                 if (modifier_isPreview(md))
 720                         return true;
 721         }
 722
 723         return false;
 724 }
 725
 726 void modifier_freeTemporaryData(ModifierData *md)
 727 {
 728         if (md->type == eModifierType_Armature) {
 729                 ArmatureModifierData *amd = (ArmatureModifierData *)md;
 730
 731                 if (amd->prevCos) {
 732                         MEM_freeN(amd->prevCos);
 733                         amd->prevCos = NULL;
 734                 }
 735         }
 736 }
 737
 738 /* ensure modifier correctness when changing ob->data */
 739 void test_object_modifiers(Object *ob)
 740 {
 741         ModifierData *md;
 742
 743         /* just multires checked for now, since only multires
 744          * modifies mesh data */
 745
 746         if (ob->type != OB_MESH) return;
 747
 748         for (md = ob->modifiers.first; md; md = md->next) {
 749                 if (md->type == eModifierType_Multires) {
 750                         MultiresModifierData *mmd = (MultiresModifierData *)md;
 751
 752                         multiresModifier_set_levels_from_disps(mmd, ob);
 753                 }
 754         }
 755 }
 756
 757 /* where should this go?, it doesnt fit well anywhere :S - campbell */
 758
 759 /* elubie: changed this to default to the same dir as the render output
 760  * to prevent saving to C:\ on Windows */
 761
 762 /* campbell: logic behind this...
 763  *
 764  * - if the ID is from a library, return library path
 765  * - else if the file has been saved return the blend file path.
 766  * - else if the file isn't saved and the ID isn't from a library, return the temp dir.
 767  */
 768 const char *modifier_path_relbase(Object *ob)
 769 {
 770         if (G.relbase_valid || ID_IS_LINKED(ob)) {
 771                 return ID_BLEND_PATH(G.main, &ob->id);
 772         }
 773         else {
 774                 /* last resort, better then using "" which resolves to the current
 775                  * working directory */
 776                 return BKE_tempdir_session();
 777         }
 778 }
 779
 780 /* initializes the path with either */
 781 void modifier_path_init(char *path, int path_maxlen, const char *name)
 782 {
 783         /* elubie: changed this to default to the same dir as the render output
 784          * to prevent saving to C:\ on Windows */
 785         BLI_join_dirfile(path, path_maxlen,
 786                          G.relbase_valid ? "//" : BKE_tempdir_session(),
 787                          name);
 788 }
 789
 790
 791 /* wrapper around ModifierTypeInfo.applyModifier that ensures valid normals */
 792
 793 struct DerivedMesh *modwrap_applyModifier(
 794         ModifierData *md, Object *ob,
 795         struct DerivedMesh *dm,
 796         ModifierApplyFlag flag)
 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 mti->applyModifier(md, ob, dm, flag);
 805 }
 806
 807 struct DerivedMesh *modwrap_applyModifierEM(
 808         ModifierData *md, Object *ob,
 809         struct BMEditMesh *em,
 810         DerivedMesh *dm,
 811         ModifierApplyFlag flag)
 812 {
 813         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
 814         BLI_assert(CustomData_has_layer(&dm->polyData, CD_NORMAL) == false);
 815
 816         if (mti->dependsOnNormals && mti->dependsOnNormals(md)) {
 817                 DM_ensure_normals(dm);
 818         }
 819         return mti->applyModifierEM(md, ob, em, dm, flag);
 820 }
 821
 822 void modwrap_deformVerts(
 823         ModifierData *md, Object *ob,
 824         DerivedMesh *dm,
 825         float (*vertexCos)[3], int numVerts,
 826         ModifierApplyFlag flag)
 827 {
 828         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
 829         BLI_assert(!dm || CustomData_has_layer(&dm->polyData, CD_NORMAL) == false);
 830
 831         if (dm && mti->dependsOnNormals && mti->dependsOnNormals(md)) {
 832                 DM_ensure_normals(dm);
 833         }
 834         mti->deformVerts(md, ob, dm, vertexCos, numVerts, flag);
 835 }
 836
 837 void modwrap_deformVertsEM(
 838         ModifierData *md, Object *ob,
 839         struct BMEditMesh *em, DerivedMesh *dm,
 840         float (*vertexCos)[3], int numVerts)
 841 {
 842         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
 843         BLI_assert(!dm || CustomData_has_layer(&dm->polyData, CD_NORMAL) == false);
 844
 845         if (dm && mti->dependsOnNormals && mti->dependsOnNormals(md)) {
 846                 DM_ensure_normals(dm);
 847         }
 848         mti->deformVertsEM(md, ob, em, dm, vertexCos, numVerts);
 849 }
 850 /* end modifier callback wrappers */