9c7cbc42bdd20ffca957a0046f8d4359ecc9ef36
[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
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, 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, mti->name, '.', offsetof(ModifierData, name), sizeof(md->name));
127         }
128 }
129
130 int modifier_dependsOnTime(ModifierData *md) 
131 {
132         ModifierTypeInfo *mti = modifierType_getInfo(md->type);
133
134         return mti->dependsOnTime && mti->dependsOnTime(md);
135 }
136
137 int 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 int 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 int 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 int modifier_sameTopology(ModifierData *md)
253 {
254         ModifierTypeInfo *mti = modifierType_getInfo(md->type);
255         return ELEM(mti->type, eModifierTypeType_OnlyDeform, eModifierTypeType_NonGeometrical);
256 }
257
258 int modifier_nonGeometrical(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 int 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 int 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 int 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 int 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 int 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, CustomDataMask dataMask, int required_mode)
367 {
368         CDMaskLink *dataMasks = NULL;
369         CDMaskLink *curr, *prev;
370
371         /* build a list of modifier data requirements in reverse order */
372         for (; md; md = md->next) {
373                 ModifierTypeInfo *mti = modifierType_getInfo(md->type);
374
375                 curr = MEM_callocN(sizeof(CDMaskLink), "CDMaskLink");
376                 
377                 if (modifier_isEnabled(scene, md, required_mode))
378                         if (mti->requiredDataMask)
379                                 curr->mask = mti->requiredDataMask(ob, md);
380
381                 /* prepend new datamask */
382                 curr->next = dataMasks;
383                 dataMasks = curr;
384         }
385
386         /* build the list of required data masks - each mask in the list must
387          * include all elements of the masks that follow it
388          *
389          * note the list is currently in reverse order, so "masks that follow it"
390          * actually means "masks that precede it" at the moment
391          */
392         for (curr = dataMasks, prev = NULL; curr; prev = curr, curr = curr->next) {
393                 if (prev) {
394                         CustomDataMask prev_mask = prev->mask;
395                         CustomDataMask curr_mask = curr->mask;
396
397                         curr->mask = curr_mask | prev_mask;
398                 }
399                 else {
400                         CustomDataMask curr_mask = curr->mask;
401
402                         curr->mask = curr_mask | dataMask;
403                 }
404         }
405
406         /* reverse the list so it's in the correct order */
407         BLI_linklist_reverse((LinkNode **)&dataMasks);
408
409         return dataMasks;
410 }
411
412 ModifierData *modifiers_getLastPreview(struct Scene *scene, ModifierData *md, int required_mode)
413 {
414         ModifierData *tmp_md = NULL;
415
416         if (required_mode != eModifierMode_Realtime)
417                 return tmp_md;
418
419         /* Find the latest modifier in stack generating preview. */
420         for (; md; md = md->next) {
421                 if (modifier_isEnabled(scene, md, required_mode) && modifier_isPreview(md))
422                         tmp_md = md;
423         }
424         return tmp_md;
425 }
426
427 /* NOTE: these aren't used anymore */
428 ModifierData *modifiers_getVirtualModifierList(Object *ob)
429 {
430         /* Kinda hacky, but should be fine since we are never
431          * re-entrant and avoid free hassles.
432          */
433         static ArmatureModifierData amd;
434         static CurveModifierData cmd;
435         static LatticeModifierData lmd;
436         static ShapeKeyModifierData smd;
437         static int init = 1;
438         ModifierData *md;
439
440         if (init) {
441                 md = modifier_new(eModifierType_Armature);
442                 amd = *((ArmatureModifierData *) md);
443                 modifier_free(md);
444
445                 md = modifier_new(eModifierType_Curve);
446                 cmd = *((CurveModifierData *) md);
447                 modifier_free(md);
448
449                 md = modifier_new(eModifierType_Lattice);
450                 lmd = *((LatticeModifierData *) md);
451                 modifier_free(md);
452
453                 md = modifier_new(eModifierType_ShapeKey);
454                 smd = *((ShapeKeyModifierData *) md);
455                 modifier_free(md);
456
457                 amd.modifier.mode |= eModifierMode_Virtual;
458                 cmd.modifier.mode |= eModifierMode_Virtual;
459                 lmd.modifier.mode |= eModifierMode_Virtual;
460                 smd.modifier.mode |= eModifierMode_Virtual;
461
462                 init = 0;
463         }
464
465         md = ob->modifiers.first;
466
467         if (ob->parent) {
468                 if (ob->parent->type == OB_ARMATURE && ob->partype == PARSKEL) {
469                         amd.object = ob->parent;
470                         amd.modifier.next = md;
471                         amd.deformflag = ((bArmature *)(ob->parent->data))->deformflag;
472                         md = &amd.modifier;
473                 }
474                 else if (ob->parent->type == OB_CURVE && ob->partype == PARSKEL) {
475                         cmd.object = ob->parent;
476                         cmd.defaxis = ob->trackflag + 1;
477                         cmd.modifier.next = md;
478                         md = &cmd.modifier;
479                 }
480                 else if (ob->parent->type == OB_LATTICE && ob->partype == PARSKEL) {
481                         lmd.object = ob->parent;
482                         lmd.modifier.next = md;
483                         md = &lmd.modifier;
484                 }
485         }
486
487         /* shape key modifier, not yet for curves */
488         if (ELEM(ob->type, OB_MESH, OB_LATTICE) && BKE_key_from_object(ob)) {
489                 if (ob->type == OB_MESH && (ob->shapeflag & OB_SHAPE_EDIT_MODE))
490                         smd.modifier.mode |= eModifierMode_Editmode | eModifierMode_OnCage;
491                 else
492                         smd.modifier.mode &= ~eModifierMode_Editmode | eModifierMode_OnCage;
493
494                 smd.modifier.next = md;
495                 md = &smd.modifier;
496         }
497
498         return md;
499 }
500
501 /* Takes an object and returns its first selected armature, else just its armature
502  * This should work for multiple armatures per object
503  */
504 Object *modifiers_isDeformedByArmature(Object *ob)
505 {
506         ModifierData *md = modifiers_getVirtualModifierList(ob);
507         ArmatureModifierData *amd = NULL;
508         
509         /* return the first selected armature, this lets us use multiple armatures */
510         for (; md; md = md->next) {
511                 if (md->type == eModifierType_Armature) {
512                         amd = (ArmatureModifierData *) md;
513                         if (amd->object && (amd->object->flag & SELECT))
514                                 return amd->object;
515                 }
516         }
517         
518         if (amd) /* if were still here then return the last armature */
519                 return amd->object;
520         
521         return NULL;
522 }
523
524 /* Takes an object and returns its first selected lattice, else just its lattice
525  * This should work for multiple lattices per object
526  */
527 Object *modifiers_isDeformedByLattice(Object *ob)
528 {
529         ModifierData *md = modifiers_getVirtualModifierList(ob);
530         LatticeModifierData *lmd = NULL;
531         
532         /* return the first selected lattice, this lets us use multiple lattices */
533         for (; md; md = md->next) {
534                 if (md->type == eModifierType_Lattice) {
535                         lmd = (LatticeModifierData *) md;
536                         if (lmd->object && (lmd->object->flag & SELECT))
537                                 return lmd->object;
538                 }
539         }
540         
541         if (lmd) /* if were still here then return the last lattice */
542                 return lmd->object;
543         
544         return NULL;
545 }
546
547 /* Takes an object and returns its first selected curve, else just its curve
548  * This should work for multiple curves per object
549  */
550 Object *modifiers_isDeformedByCurve(Object *ob)
551 {
552         ModifierData *md = modifiers_getVirtualModifierList(ob);
553         CurveModifierData *cmd = NULL;
554         
555         /* return the first selected curve, this lets us use multiple curves */
556         for (; md; md = md->next) {
557                 if (md->type == eModifierType_Curve) {
558                         cmd = (CurveModifierData *) md;
559                         if (cmd->object && (cmd->object->flag & SELECT))
560                                 return cmd->object;
561                 }
562         }
563         
564         if (cmd) /* if were still here then return the last curve */
565                 return cmd->object;
566         
567         return NULL;
568 }
569
570 int modifiers_usesArmature(Object *ob, bArmature *arm)
571 {
572         ModifierData *md = modifiers_getVirtualModifierList(ob);
573
574         for (; md; md = md->next) {
575                 if (md->type == eModifierType_Armature) {
576                         ArmatureModifierData *amd = (ArmatureModifierData *) md;
577                         if (amd->object && amd->object->data == arm)
578                                 return 1;
579                 }
580         }
581
582         return 0;
583 }
584
585 int modifier_isCorrectableDeformed(ModifierData *md)
586 {
587         if (md->type == eModifierType_Armature)
588                 return 1;
589         if (md->type == eModifierType_ShapeKey)
590                 return 1;
591         
592         return 0;
593 }
594
595 int modifiers_isCorrectableDeformed(Object *ob)
596 {
597         ModifierData *md = modifiers_getVirtualModifierList(ob);
598         
599         for (; md; md = md->next) {
600                 if (ob->mode == OB_MODE_EDIT && (md->mode & eModifierMode_Editmode) == 0) {
601                         /* pass */
602                 }
603                 else if (modifier_isCorrectableDeformed(md)) {
604                         return 1;
605                 }
606         }
607         return 0;
608 }
609
610 /* Check whether the given object has a modifier in its stack that uses WEIGHT_MCOL CD layer
611  * to preview something... Used by DynamicPaint and WeightVG currently. */
612 int modifiers_isPreview(Object *ob)
613 {
614         ModifierData *md = ob->modifiers.first;
615
616         for (; md; md = md->next) {
617                 if (modifier_isPreview(md))
618                         return TRUE;
619         }
620
621         return FALSE;
622 }
623
624 int modifiers_indexInObject(Object *ob, ModifierData *md_seek)
625 {
626         int i = 0;
627         ModifierData *md;
628         
629         for (md = ob->modifiers.first; (md && md_seek != md); md = md->next, i++) ;
630         if (!md) return -1;  /* modifier isn't in the object */
631         return i;
632 }
633
634 void modifier_freeTemporaryData(ModifierData *md)
635 {
636         if (md->type == eModifierType_Armature) {
637                 ArmatureModifierData *amd = (ArmatureModifierData *)md;
638
639                 if (amd->prevCos) {
640                         MEM_freeN(amd->prevCos);
641                         amd->prevCos = NULL;
642                 }
643         }
644 }
645
646 /* ensure modifier correctness when changing ob->data */
647 void test_object_modifiers(Object *ob)
648 {
649         ModifierData *md;
650
651         /* just multires checked for now, since only multires
652          * modifies mesh data */
653
654         if (ob->type != OB_MESH) return;
655
656         for (md = ob->modifiers.first; md; md = md->next) {
657                 if (md->type == eModifierType_Multires) {
658                         MultiresModifierData *mmd = (MultiresModifierData *)md;
659
660                         multiresModifier_set_levels_from_disps(mmd, ob);
661                 }
662         }
663 }
664
665 /* where should this go?, it doesnt fit well anywhere :S - campbell */
666
667 /* elubie: changed this to default to the same dir as the render output
668  * to prevent saving to C:\ on Windows */
669
670 /* campbell: logic behind this...
671  *
672  * - if the ID is from a library, return library path
673  * - else if the file has been saved return the blend file path.
674  * - else if the file isn't saved and the ID isn't from a library, return the temp dir.
675  */
676 const char *modifier_path_relbase(Object *ob)
677 {
678         if (G.relbase_valid || ob->id.lib) {
679                 return ID_BLEND_PATH(G.main, &ob->id);
680         }
681         else {
682                 /* last resort, better then using "" which resolves to the current
683                  * working directory */
684                 return BLI_temporary_dir();
685         }
686 }
687
688 /* initializes the path with either */
689 void modifier_path_init(char *path, int path_maxlen, const char *name)
690 {
691         /* elubie: changed this to default to the same dir as the render output
692          * to prevent saving to C:\ on Windows */
693         BLI_join_dirfile(path, path_maxlen,
694                          G.relbase_valid ? "//" : BLI_temporary_dir(),
695                          name);
696 }