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