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_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