c17830639e4cc7ed182bf3adaa49f715f3856e9f
[blender-staging.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
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 #include "DNA_meshdata_types.h"
51
52 #include "BLI_utildefines.h"
53 #include "BLI_path_util.h"
54 #include "BLI_listbase.h"
55 #include "BLI_linklist.h"
56 #include "BLI_string.h"
57
58 #include "BLF_translation.h"
59
60 #include "BKE_cloth.h"
61 #include "BKE_key.h"
62 #include "BKE_multires.h"
63
64 /* may move these, only for modifier_path_relbase */
65 #include "BKE_global.h" /* ugh, G.main->name only */
66 #include "BKE_main.h"
67 /* end */
68
69 #include "MOD_modifiertypes.h"
70
71 ModifierTypeInfo *modifierType_getInfo(ModifierType type)
72 {
73         static ModifierTypeInfo *types[NUM_MODIFIER_TYPES] = {NULL};
74         static int types_init = 1;
75
76         if (types_init) {
77                 modifier_type_init(types); /* MOD_utils.c */
78                 types_init = 0;
79         }
80
81         /* type unsigned, no need to check < 0 */
82         if (type < NUM_MODIFIER_TYPES && types[type]->name[0] != '\0') {
83                 return types[type];
84         }
85         else {
86                 return NULL;
87         }
88 }
89
90 /***/
91
92 ModifierData *modifier_new(int type)
93 {
94         ModifierTypeInfo *mti = modifierType_getInfo(type);
95         ModifierData *md = MEM_callocN(mti->structSize, mti->structName);
96         
97         /* note, this name must be made unique later */
98         BLI_strncpy(md->name, DATA_(mti->name), sizeof(md->name));
99
100         md->type = type;
101         md->mode = eModifierMode_Realtime | eModifierMode_Render | eModifierMode_Expanded;
102
103         if (mti->flags & eModifierTypeFlag_EnableInEditmode)
104                 md->mode |= eModifierMode_Editmode;
105
106         if (mti->initData) mti->initData(md);
107
108         return md;
109 }
110
111 void modifier_free(ModifierData *md) 
112 {
113         ModifierTypeInfo *mti = modifierType_getInfo(md->type);
114
115         if (mti->freeData) mti->freeData(md);
116         if (md->error) MEM_freeN(md->error);
117
118         MEM_freeN(md);
119 }
120
121 void modifier_unique_name(ListBase *modifiers, ModifierData *md)
122 {
123         if (modifiers && md) {
124                 ModifierTypeInfo *mti = modifierType_getInfo(md->type);
125
126                 BLI_uniquename(modifiers, md, DATA_(mti->name), '.', offsetof(ModifierData, name), sizeof(md->name));
127         }
128 }
129
130 bool modifier_dependsOnTime(ModifierData *md)
131 {
132         ModifierTypeInfo *mti = modifierType_getInfo(md->type);
133
134         return mti->dependsOnTime && mti->dependsOnTime(md);
135 }
136
137 bool modifier_supportsMapping(ModifierData *md)
138 {
139         ModifierTypeInfo *mti = modifierType_getInfo(md->type);
140
141         return (mti->type == eModifierTypeType_OnlyDeform ||
142                 (mti->flags & eModifierTypeFlag_SupportsMapping));
143 }
144
145 bool modifier_isPreview(ModifierData *md)
146 {
147         ModifierTypeInfo *mti = modifierType_getInfo(md->type);
148
149         if (!(mti->flags & eModifierTypeFlag_UsesPreview))
150                 return FALSE;
151
152         if (md->mode & eModifierMode_Realtime)
153                 return TRUE;
154
155         return FALSE;
156 }
157
158 ModifierData *modifiers_findByType(Object *ob, ModifierType type)
159 {
160         ModifierData *md = ob->modifiers.first;
161
162         for (; md; md = md->next)
163                 if (md->type == type)
164                         break;
165
166         return md;
167 }
168
169 ModifierData *modifiers_findByName(Object *ob, const char *name)
170 {
171         return BLI_findstring(&(ob->modifiers), name, offsetof(ModifierData, name));
172 }
173
174 void modifiers_clearErrors(Object *ob)
175 {
176         ModifierData *md = ob->modifiers.first;
177         /* int qRedraw = 0; */
178
179         for (; md; md = md->next) {
180                 if (md->error) {
181                         MEM_freeN(md->error);
182                         md->error = NULL;
183
184                         /* qRedraw = 1; */
185                 }
186         }
187 }
188
189 void modifiers_foreachObjectLink(Object *ob, ObjectWalkFunc walk,
190                                  void *userData)
191 {
192         ModifierData *md = ob->modifiers.first;
193
194         for (; md; md = md->next) {
195                 ModifierTypeInfo *mti = modifierType_getInfo(md->type);
196
197                 if (mti->foreachObjectLink)
198                         mti->foreachObjectLink(md, ob, walk, userData);
199         }
200 }
201
202 void modifiers_foreachIDLink(Object *ob, IDWalkFunc walk, void *userData)
203 {
204         ModifierData *md = ob->modifiers.first;
205
206         for (; md; md = md->next) {
207                 ModifierTypeInfo *mti = modifierType_getInfo(md->type);
208
209                 if (mti->foreachIDLink) mti->foreachIDLink(md, ob, walk, userData);
210                 else if (mti->foreachObjectLink) {
211                         /* each Object can masquerade as an ID, so this should be OK */
212                         ObjectWalkFunc fp = (ObjectWalkFunc)walk;
213                         mti->foreachObjectLink(md, ob, fp, userData);
214                 }
215         }
216 }
217
218 void modifiers_foreachTexLink(Object *ob, TexWalkFunc walk, void *userData)
219 {
220         ModifierData *md = ob->modifiers.first;
221
222         for (; md; md = md->next) {
223                 ModifierTypeInfo *mti = modifierType_getInfo(md->type);
224
225                 if (mti->foreachTexLink)
226                         mti->foreachTexLink(md, ob, walk, userData);
227         }
228 }
229
230 void modifier_copyData(ModifierData *md, ModifierData *target)
231 {
232         ModifierTypeInfo *mti = modifierType_getInfo(md->type);
233
234         target->mode = md->mode;
235
236         if (mti->copyData)
237                 mti->copyData(md, target);
238 }
239
240 bool modifier_couldBeCage(struct Scene *scene, ModifierData *md)
241 {
242         ModifierTypeInfo *mti = modifierType_getInfo(md->type);
243
244         md->scene = scene;
245
246         return ((md->mode & eModifierMode_Realtime) &&
247                 (md->mode & eModifierMode_Editmode) &&
248                 (!mti->isDisabled || !mti->isDisabled(md, 0)) &&
249                 modifier_supportsMapping(md));
250 }
251
252 bool modifier_isSameTopology(ModifierData *md)
253 {
254         ModifierTypeInfo *mti = modifierType_getInfo(md->type);
255         return ELEM(mti->type, eModifierTypeType_OnlyDeform, eModifierTypeType_NonGeometrical);
256 }
257
258 bool modifier_isNonGeometrical(ModifierData *md)
259 {
260         ModifierTypeInfo *mti = modifierType_getInfo(md->type);
261         return (mti->type == eModifierTypeType_NonGeometrical);
262 }
263
264 void modifier_setError(ModifierData *md, const char *_format, ...)
265 {
266         char buffer[512];
267         va_list ap;
268         const char *format = TIP_(_format);
269
270         va_start(ap, _format);
271         vsnprintf(buffer, sizeof(buffer), format, ap);
272         va_end(ap);
273         buffer[sizeof(buffer) - 1] = '\0';
274
275         if (md->error)
276                 MEM_freeN(md->error);
277
278         md->error = BLI_strdup(buffer);
279
280 }
281
282 /* used for buttons, to find out if the 'draw deformed in editmode' option is
283  * there
284  * 
285  * also used in transform_conversion.c, to detect CrazySpace [tm] (2nd arg
286  * then is NULL) 
287  * also used for some mesh tools to give warnings
288  */
289 int modifiers_getCageIndex(struct Scene *scene, Object *ob, int *lastPossibleCageIndex_r, int virtual_)
290 {
291         ModifierData *md = (virtual_) ? modifiers_getVirtualModifierList(ob) : ob->modifiers.first;
292         int i, cageIndex = -1;
293
294         if (lastPossibleCageIndex_r) {
295                 /* ensure the value is initialized */
296                 *lastPossibleCageIndex_r = -1;
297         }
298
299         /* Find the last modifier acting on the cage. */
300         for (i = 0; md; i++, md = md->next) {
301                 ModifierTypeInfo *mti = modifierType_getInfo(md->type);
302
303                 md->scene = scene;
304
305                 if (!(md->mode & eModifierMode_Realtime)) continue;
306                 if (!(md->mode & eModifierMode_Editmode)) continue;
307                 if (mti->isDisabled && mti->isDisabled(md, 0)) continue;
308                 if (!(mti->flags & eModifierTypeFlag_SupportsEditmode)) continue;
309                 if (md->mode & eModifierMode_DisableTemporary) continue;
310
311                 if (!modifier_supportsMapping(md))
312                         break;
313
314                 if (lastPossibleCageIndex_r) *lastPossibleCageIndex_r = i;
315                 if (md->mode & eModifierMode_OnCage)
316                         cageIndex = i;
317         }
318
319         return cageIndex;
320 }
321
322
323 bool modifiers_isSoftbodyEnabled(Object *ob)
324 {
325         ModifierData *md = modifiers_findByType(ob, eModifierType_Softbody);
326
327         return (md && md->mode & (eModifierMode_Realtime | eModifierMode_Render));
328 }
329
330 bool modifiers_isClothEnabled(Object *ob)
331 {
332         ModifierData *md = modifiers_findByType(ob, eModifierType_Cloth);
333
334         return (md && md->mode & (eModifierMode_Realtime | eModifierMode_Render));
335 }
336
337 bool modifiers_isModifierEnabled(Object *ob, int modifierType)
338 {
339         ModifierData *md = modifiers_findByType(ob, modifierType);
340
341         return (md && md->mode & (eModifierMode_Realtime | eModifierMode_Render));
342 }
343
344 bool modifiers_isParticleEnabled(Object *ob)
345 {
346         ModifierData *md = modifiers_findByType(ob, eModifierType_ParticleSystem);
347
348         return (md && md->mode & (eModifierMode_Realtime | eModifierMode_Render));
349 }
350
351 bool modifier_isEnabled(struct Scene *scene, ModifierData *md, int required_mode)
352 {
353         ModifierTypeInfo *mti = modifierType_getInfo(md->type);
354
355         md->scene = scene;
356
357         if ((md->mode & required_mode) != required_mode) return 0;
358         if (mti->isDisabled && mti->isDisabled(md, required_mode == eModifierMode_Render)) return 0;
359         if (md->mode & eModifierMode_DisableTemporary) return 0;
360         if (required_mode & eModifierMode_Editmode)
361                 if (!(mti->flags & eModifierTypeFlag_SupportsEditmode)) return 0;
362         
363         return 1;
364 }
365
366 CDMaskLink *modifiers_calcDataMasks(struct Scene *scene, Object *ob, ModifierData *md,
367                                     CustomDataMask dataMask, int required_mode,
368                                     ModifierData *previewmd, CustomDataMask previewmask)
369 {
370         CDMaskLink *dataMasks = NULL;
371         CDMaskLink *curr, *prev;
372
373         /* build a list of modifier data requirements in reverse order */
374         for (; md; md = md->next) {
375                 ModifierTypeInfo *mti = modifierType_getInfo(md->type);
376
377                 curr = MEM_callocN(sizeof(CDMaskLink), "CDMaskLink");
378                 
379                 if (modifier_isEnabled(scene, md, required_mode)) {
380                         if (mti->requiredDataMask)
381                                 curr->mask = mti->requiredDataMask(ob, md);
382
383                         if (previewmd == md) {
384                                 curr->mask |= previewmask;
385                         }
386                 }
387
388                 /* prepend new datamask */
389                 curr->next = dataMasks;
390                 dataMasks = curr;
391         }
392
393         /* build the list of required data masks - each mask in the list must
394          * include all elements of the masks that follow it
395          *
396          * note the list is currently in reverse order, so "masks that follow it"
397          * actually means "masks that precede it" at the moment
398          */
399         for (curr = dataMasks, prev = NULL; curr; prev = curr, curr = curr->next) {
400                 if (prev) {
401                         CustomDataMask prev_mask = prev->mask;
402                         CustomDataMask curr_mask = curr->mask;
403
404                         curr->mask = curr_mask | prev_mask;
405                 }
406                 else {
407                         CustomDataMask curr_mask = curr->mask;
408
409                         curr->mask = curr_mask | dataMask;
410                 }
411         }
412
413         /* reverse the list so it's in the correct order */
414         BLI_linklist_reverse((LinkNode **)&dataMasks);
415
416         return dataMasks;
417 }
418
419 ModifierData *modifiers_getLastPreview(struct Scene *scene, ModifierData *md, int required_mode)
420 {
421         ModifierData *tmp_md = NULL;
422
423         if (required_mode != eModifierMode_Realtime)
424                 return tmp_md;
425
426         /* Find the latest modifier in stack generating preview. */
427         for (; md; md = md->next) {
428                 if (modifier_isEnabled(scene, md, required_mode) && modifier_isPreview(md))
429                         tmp_md = md;
430         }
431         return tmp_md;
432 }
433
434 /* NOTE: This is to support old files from before Blender supported modifiers,
435  * in some cases versioning code updates these so for new files this will
436  * return an empty list. */
437 ModifierData *modifiers_getVirtualModifierList(Object *ob)
438 {
439         /* Kinda hacky, but should be fine since we are never
440          * re-entrant and avoid free hassles.
441          */
442         static ArmatureModifierData amd;
443         static CurveModifierData cmd;
444         static LatticeModifierData lmd;
445         static ShapeKeyModifierData smd;
446         static int init = 1;
447         ModifierData *md;
448
449         if (init) {
450                 md = modifier_new(eModifierType_Armature);
451                 amd = *((ArmatureModifierData *) md);
452                 modifier_free(md);
453
454                 md = modifier_new(eModifierType_Curve);
455                 cmd = *((CurveModifierData *) md);
456                 modifier_free(md);
457
458                 md = modifier_new(eModifierType_Lattice);
459                 lmd = *((LatticeModifierData *) md);
460                 modifier_free(md);
461
462                 md = modifier_new(eModifierType_ShapeKey);
463                 smd = *((ShapeKeyModifierData *) md);
464                 modifier_free(md);
465
466                 amd.modifier.mode |= eModifierMode_Virtual;
467                 cmd.modifier.mode |= eModifierMode_Virtual;
468                 lmd.modifier.mode |= eModifierMode_Virtual;
469                 smd.modifier.mode |= eModifierMode_Virtual;
470
471                 init = 0;
472         }
473
474         md = ob->modifiers.first;
475
476         if (ob->parent) {
477                 if (ob->parent->type == OB_ARMATURE && ob->partype == PARSKEL) {
478                         amd.object = ob->parent;
479                         amd.modifier.next = md;
480                         amd.deformflag = ((bArmature *)(ob->parent->data))->deformflag;
481                         md = &amd.modifier;
482                 }
483                 else if (ob->parent->type == OB_CURVE && ob->partype == PARSKEL) {
484                         cmd.object = ob->parent;
485                         cmd.defaxis = ob->trackflag + 1;
486                         cmd.modifier.next = md;
487                         md = &cmd.modifier;
488                 }
489                 else if (ob->parent->type == OB_LATTICE && ob->partype == PARSKEL) {
490                         lmd.object = ob->parent;
491                         lmd.modifier.next = md;
492                         md = &lmd.modifier;
493                 }
494         }
495
496         /* shape key modifier, not yet for curves */
497         if (ELEM(ob->type, OB_MESH, OB_LATTICE) && BKE_key_from_object(ob)) {
498                 if (ob->type == OB_MESH && (ob->shapeflag & OB_SHAPE_EDIT_MODE))
499                         smd.modifier.mode |= eModifierMode_Editmode | eModifierMode_OnCage;
500                 else
501                         smd.modifier.mode &= ~eModifierMode_Editmode | eModifierMode_OnCage;
502
503                 smd.modifier.next = md;
504                 md = &smd.modifier;
505         }
506
507         return md;
508 }
509
510 /* Takes an object and returns its first selected armature, else just its armature
511  * This should work for multiple armatures per object
512  */
513 Object *modifiers_isDeformedByArmature(Object *ob)
514 {
515         ModifierData *md = modifiers_getVirtualModifierList(ob);
516         ArmatureModifierData *amd = NULL;
517         
518         /* return the first selected armature, this lets us use multiple armatures */
519         for (; md; md = md->next) {
520                 if (md->type == eModifierType_Armature) {
521                         amd = (ArmatureModifierData *) md;
522                         if (amd->object && (amd->object->flag & SELECT))
523                                 return amd->object;
524                 }
525         }
526         
527         if (amd) /* if were still here then return the last armature */
528                 return amd->object;
529         
530         return NULL;
531 }
532
533 /* Takes an object and returns its first selected lattice, else just its lattice
534  * This should work for multiple lattices per object
535  */
536 Object *modifiers_isDeformedByLattice(Object *ob)
537 {
538         ModifierData *md = modifiers_getVirtualModifierList(ob);
539         LatticeModifierData *lmd = NULL;
540         
541         /* return the first selected lattice, this lets us use multiple lattices */
542         for (; md; md = md->next) {
543                 if (md->type == eModifierType_Lattice) {
544                         lmd = (LatticeModifierData *) md;
545                         if (lmd->object && (lmd->object->flag & SELECT))
546                                 return lmd->object;
547                 }
548         }
549         
550         if (lmd) /* if were still here then return the last lattice */
551                 return lmd->object;
552         
553         return NULL;
554 }
555
556 /* Takes an object and returns its first selected curve, else just its curve
557  * This should work for multiple curves per object
558  */
559 Object *modifiers_isDeformedByCurve(Object *ob)
560 {
561         ModifierData *md = modifiers_getVirtualModifierList(ob);
562         CurveModifierData *cmd = NULL;
563         
564         /* return the first selected curve, this lets us use multiple curves */
565         for (; md; md = md->next) {
566                 if (md->type == eModifierType_Curve) {
567                         cmd = (CurveModifierData *) md;
568                         if (cmd->object && (cmd->object->flag & SELECT))
569                                 return cmd->object;
570                 }
571         }
572         
573         if (cmd) /* if were still here then return the last curve */
574                 return cmd->object;
575         
576         return NULL;
577 }
578
579 bool modifiers_usesArmature(Object *ob, bArmature *arm)
580 {
581         ModifierData *md = modifiers_getVirtualModifierList(ob);
582
583         for (; md; md = md->next) {
584                 if (md->type == eModifierType_Armature) {
585                         ArmatureModifierData *amd = (ArmatureModifierData *) md;
586                         if (amd->object && amd->object->data == arm)
587                                 return true;
588                 }
589         }
590
591         return false;
592 }
593
594 bool modifier_isCorrectableDeformed(ModifierData *md)
595 {
596         if (md->type == eModifierType_Armature)
597                 return true;
598         if (md->type == eModifierType_ShapeKey)
599                 return true;
600         
601         return false;
602 }
603
604 bool modifiers_isCorrectableDeformed(Object *ob)
605 {
606         ModifierData *md = modifiers_getVirtualModifierList(ob);
607         
608         for (; md; md = md->next) {
609                 if (ob->mode == OB_MODE_EDIT && (md->mode & eModifierMode_Editmode) == 0) {
610                         /* pass */
611                 }
612                 else if (modifier_isCorrectableDeformed(md)) {
613                         return true;
614                 }
615         }
616         return false;
617 }
618
619 /* Check whether the given object has a modifier in its stack that uses WEIGHT_MCOL CD layer
620  * to preview something... Used by DynamicPaint and WeightVG currently. */
621 bool modifiers_isPreview(Object *ob)
622 {
623         ModifierData *md = ob->modifiers.first;
624
625         for (; md; md = md->next) {
626                 if (modifier_isPreview(md))
627                         return true;
628         }
629
630         return false;
631 }
632
633 void modifier_freeTemporaryData(ModifierData *md)
634 {
635         if (md->type == eModifierType_Armature) {
636                 ArmatureModifierData *amd = (ArmatureModifierData *)md;
637
638                 if (amd->prevCos) {
639                         MEM_freeN(amd->prevCos);
640                         amd->prevCos = NULL;
641                 }
642         }
643 }
644
645 /* ensure modifier correctness when changing ob->data */
646 void test_object_modifiers(Object *ob)
647 {
648         ModifierData *md;
649
650         /* just multires checked for now, since only multires
651          * modifies mesh data */
652
653         if (ob->type != OB_MESH) return;
654
655         for (md = ob->modifiers.first; md; md = md->next) {
656                 if (md->type == eModifierType_Multires) {
657                         MultiresModifierData *mmd = (MultiresModifierData *)md;
658
659                         multiresModifier_set_levels_from_disps(mmd, ob);
660                 }
661         }
662 }
663
664 /* where should this go?, it doesnt fit well anywhere :S - campbell */
665
666 /* elubie: changed this to default to the same dir as the render output
667  * to prevent saving to C:\ on Windows */
668
669 /* campbell: logic behind this...
670  *
671  * - if the ID is from a library, return library path
672  * - else if the file has been saved return the blend file path.
673  * - else if the file isn't saved and the ID isn't from a library, return the temp dir.
674  */
675 const char *modifier_path_relbase(Object *ob)
676 {
677         if (G.relbase_valid || ob->id.lib) {
678                 return ID_BLEND_PATH(G.main, &ob->id);
679         }
680         else {
681                 /* last resort, better then using "" which resolves to the current
682                  * working directory */
683                 return BLI_temporary_dir();
684         }
685 }
686
687 /* initializes the path with either */
688 void modifier_path_init(char *path, int path_maxlen, const char *name)
689 {
690         /* elubie: changed this to default to the same dir as the render output
691          * to prevent saving to C:\ on Windows */
692         BLI_join_dirfile(path, path_maxlen,
693                          G.relbase_valid ? "//" : BLI_temporary_dir(),
694                          name);
695 }