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