I made multitude of fixes based on the comments provided online:
[blender.git] / source / blender / blenkernel / intern / modifier.c
1 /*
2 * $Id$
3 *
4 * ***** BEGIN GPL LICENSE BLOCK *****
5 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version 2
9 * of the License, or (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software  Foundation,
18 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
19 *
20 * The Original Code is Copyright (C) 2005 by the Blender Foundation.
21 * All rights reserved.
22 *
23 * Contributor(s): Daniel Dunbar
24 *                 Ton Roosendaal,
25 *                 Ben Batt,
26 *                 Brecht Van Lommel,
27 *                 Campbell Barton
28 *
29 * ***** END GPL LICENSE BLOCK *****
30 *
31 * Modifier stack implementation.
32 *
33 * BKE_modifier.h contains the function prototypes for this file.
34 *
35 */
36
37 /** \file blender/blenkernel/intern/modifier.c
38  *  \ingroup bke
39  */
40
41
42 #include <stddef.h>
43 #include <string.h>
44 #include <stdarg.h>
45 #include <math.h>
46 #include <float.h>
47
48 #include "MEM_guardedalloc.h"
49
50 #include "DNA_armature_types.h"
51 #include "DNA_object_types.h"
52 #include "DNA_meshdata_types.h"
53
54 #include "BLI_utildefines.h"
55
56 #include "BKE_bmesh.h"
57 #include "BKE_cloth.h"
58 #include "BKE_key.h"
59 #include "BKE_multires.h"
60
61 #include "MOD_modifiertypes.h"
62
63 ModifierTypeInfo *modifierType_getInfo(ModifierType type)
64 {
65         static ModifierTypeInfo *types[NUM_MODIFIER_TYPES]= {NULL};
66         static int types_init = 1;
67
68         if (types_init) {
69                 modifier_type_init(types); /* MOD_utils.c */
70                 types_init= 0;
71         }
72
73         /* type unsigned, no need to chech < 0 */
74         if(type < NUM_MODIFIER_TYPES && types[type]->name[0] != '\0') {
75                 return types[type];
76         }
77         else {
78                 return NULL;
79         }
80 }
81
82 /***/
83
84 ModifierData *modifier_new(int type)
85 {
86         ModifierTypeInfo *mti = modifierType_getInfo(type);
87         ModifierData *md = MEM_callocN(mti->structSize, mti->structName);
88         
89         // FIXME: we need to make the name always be unique somehow...
90         strcpy(md->name, mti->name);
91
92         md->type = type;
93         md->mode = eModifierMode_Realtime
94                         | eModifierMode_Render | eModifierMode_Expanded;
95
96         if (mti->flags & eModifierTypeFlag_EnableInEditmode)
97                 md->mode |= eModifierMode_Editmode;
98
99         if (mti->initData) mti->initData(md);
100
101         return md;
102 }
103
104 void modifier_free(ModifierData *md) 
105 {
106         ModifierTypeInfo *mti = modifierType_getInfo(md->type);
107
108         if (mti->freeData) mti->freeData(md);
109         if (md->error) MEM_freeN(md->error);
110
111         MEM_freeN(md);
112 }
113
114 void modifier_unique_name(ListBase *modifiers, ModifierData *md)
115 {
116         if (modifiers && md) {
117                 ModifierTypeInfo *mti = modifierType_getInfo(md->type);
118                 
119                 BLI_uniquename(modifiers, md, mti->name, '.', offsetof(ModifierData, name), sizeof(md->name));
120         }
121 }
122
123 int modifier_dependsOnTime(ModifierData *md) 
124 {
125         ModifierTypeInfo *mti = modifierType_getInfo(md->type);
126
127         return mti->dependsOnTime && mti->dependsOnTime(md);
128 }
129
130 int modifier_supportsMapping(ModifierData *md)
131 {
132         ModifierTypeInfo *mti = modifierType_getInfo(md->type);
133
134         return (mti->type==eModifierTypeType_OnlyDeform ||
135                         (mti->flags & eModifierTypeFlag_SupportsMapping));
136 }
137
138 ModifierData *modifiers_findByType(Object *ob, ModifierType type)
139 {
140         ModifierData *md = ob->modifiers.first;
141
142         for (; md; md=md->next)
143                 if (md->type==type)
144                         break;
145
146         return md;
147 }
148
149 ModifierData *modifiers_findByName(Object *ob, const char *name)
150 {
151         return BLI_findstring(&(ob->modifiers), name, offsetof(ModifierData, name));
152 }
153
154 void modifiers_clearErrors(Object *ob)
155 {
156         ModifierData *md = ob->modifiers.first;
157         /* int qRedraw = 0; */
158
159         for (; md; md=md->next) {
160                 if (md->error) {
161                         MEM_freeN(md->error);
162                         md->error = NULL;
163
164                         /* qRedraw = 1; */
165                 }
166         }
167 }
168
169 void modifiers_foreachObjectLink(Object *ob, ObjectWalkFunc walk,
170                                  void *userData)
171 {
172         ModifierData *md = ob->modifiers.first;
173
174         for (; md; md=md->next) {
175                 ModifierTypeInfo *mti = modifierType_getInfo(md->type);
176
177                 if (mti->foreachObjectLink)
178                         mti->foreachObjectLink(md, ob, walk, userData);
179         }
180 }
181
182 void modifiers_foreachIDLink(Object *ob, IDWalkFunc walk, void *userData)
183 {
184         ModifierData *md = ob->modifiers.first;
185
186         for (; md; md=md->next) {
187                 ModifierTypeInfo *mti = modifierType_getInfo(md->type);
188
189                 if(mti->foreachIDLink) mti->foreachIDLink(md, ob, walk, userData);
190                 else if(mti->foreachObjectLink) {
191                         /* each Object can masquerade as an ID, so this should be OK */
192                         ObjectWalkFunc fp = (ObjectWalkFunc)walk;
193                         mti->foreachObjectLink(md, ob, fp, userData);
194                 }
195         }
196 }
197
198 void modifiers_foreachTexLink(Object *ob, TexWalkFunc walk, void *userData)
199 {
200         ModifierData *md = ob->modifiers.first;
201
202         for (; md; md=md->next) {
203                 ModifierTypeInfo *mti = modifierType_getInfo(md->type);
204
205                 if(mti->foreachTexLink)
206                         mti->foreachTexLink(md, ob, walk, userData);
207         }
208 }
209
210 void modifier_copyData(ModifierData *md, ModifierData *target)
211 {
212         ModifierTypeInfo *mti = modifierType_getInfo(md->type);
213
214         target->mode = md->mode;
215
216         if (mti->copyData)
217                 mti->copyData(md, target);
218 }
219
220 int modifier_couldBeCage(struct Scene *scene, ModifierData *md)
221 {
222         ModifierTypeInfo *mti = modifierType_getInfo(md->type);
223
224         md->scene= scene;
225
226         return (        (md->mode & eModifierMode_Realtime) &&
227                         (md->mode & eModifierMode_Editmode) &&
228                         (!mti->isDisabled || !mti->isDisabled(md, 0)) &&
229                         modifier_supportsMapping(md));  
230 }
231
232 int modifier_sameTopology(ModifierData *md)
233 {
234         ModifierTypeInfo *mti = modifierType_getInfo(md->type);
235         return ( mti->type == eModifierTypeType_OnlyDeform || mti->type == eModifierTypeType_Nonconstructive);
236 }
237
238 void modifier_setError(ModifierData *md, const char *format, ...)
239 {
240         char buffer[512];
241         va_list ap;
242
243         va_start(ap, format);
244         vsnprintf(buffer, sizeof(buffer), format, ap);
245         va_end(ap);
246         buffer[sizeof(buffer) - 1]= '\0';
247
248         if (md->error)
249                 MEM_freeN(md->error);
250
251         md->error = BLI_strdup(buffer);
252
253 }
254
255 /* used for buttons, to find out if the 'draw deformed in editmode' option is
256  * there
257  * 
258  * also used in transform_conversion.c, to detect CrazySpace [tm] (2nd arg
259  * then is NULL) 
260  * also used for some mesh tools to give warnings
261  */
262 int modifiers_getCageIndex(struct Scene *scene, Object *ob, int *lastPossibleCageIndex_r, int virtual_)
263 {
264         ModifierData *md = (virtual_)? modifiers_getVirtualModifierList(ob): ob->modifiers.first;
265         int i, cageIndex = -1;
266
267         if(lastPossibleCageIndex_r) {
268                 /* ensure the value is initialized */
269                 *lastPossibleCageIndex_r= -1;
270         }
271
272         /* Find the last modifier acting on the cage. */
273         for (i=0; md; i++,md=md->next) {
274                 ModifierTypeInfo *mti = modifierType_getInfo(md->type);
275
276                 md->scene= scene;
277
278                 if (!(md->mode & eModifierMode_Realtime)) continue;
279                 if (!(md->mode & eModifierMode_Editmode)) continue;
280                 if (mti->isDisabled && mti->isDisabled(md, 0)) continue;
281                 if (!(mti->flags & eModifierTypeFlag_SupportsEditmode)) continue;
282                 if (md->mode & eModifierMode_DisableTemporary) continue;
283
284                 if (!modifier_supportsMapping(md))
285                         break;
286
287                 if (lastPossibleCageIndex_r) *lastPossibleCageIndex_r = i;
288                 if (md->mode & eModifierMode_OnCage)
289                         cageIndex = i;
290         }
291
292         return cageIndex;
293 }
294
295
296 int modifiers_isSoftbodyEnabled(Object *ob)
297 {
298         ModifierData *md = modifiers_findByType(ob, eModifierType_Softbody);
299
300         return (md && md->mode & (eModifierMode_Realtime | eModifierMode_Render));
301 }
302
303 int modifiers_isClothEnabled(Object *ob)
304 {
305         ModifierData *md = modifiers_findByType(ob, eModifierType_Cloth);
306
307         return (md && md->mode & (eModifierMode_Realtime | eModifierMode_Render));
308 }
309
310 int modifiers_isParticleEnabled(Object *ob)
311 {
312         ModifierData *md = modifiers_findByType(ob, eModifierType_ParticleSystem);
313
314         return (md && md->mode & (eModifierMode_Realtime | eModifierMode_Render));
315 }
316
317 int modifier_isEnabled(struct Scene *scene, ModifierData *md, int required_mode)
318 {
319         ModifierTypeInfo *mti = modifierType_getInfo(md->type);
320
321         md->scene= scene;
322
323         if((md->mode & required_mode) != required_mode) return 0;
324         if(mti->isDisabled && mti->isDisabled(md, required_mode == eModifierMode_Render)) return 0;
325         if(md->mode & eModifierMode_DisableTemporary) return 0;
326         if(required_mode & eModifierMode_Editmode)
327                 if(!(mti->flags & eModifierTypeFlag_SupportsEditmode)) return 0;
328         
329         return 1;
330 }
331
332 LinkNode *modifiers_calcDataMasks(struct Scene *scene, Object *ob, ModifierData *md, CustomDataMask dataMask, int required_mode)
333 {
334         LinkNode *dataMasks = NULL;
335         LinkNode *curr, *prev;
336
337         /* build a list of modifier data requirements in reverse order */
338         for(; md; md = md->next) {
339                 ModifierTypeInfo *mti = modifierType_getInfo(md->type);
340                 CustomDataMask mask = 0;
341
342                 if(modifier_isEnabled(scene, md, required_mode))
343                         if(mti->requiredDataMask)
344                                 mask = mti->requiredDataMask(ob, md);
345
346                 BLI_linklist_prepend(&dataMasks, SET_INT_IN_POINTER(mask));
347         }
348
349         /* build the list of required data masks - each mask in the list must
350         * include all elements of the masks that follow it
351         *
352         * note the list is currently in reverse order, so "masks that follow it"
353         * actually means "masks that precede it" at the moment
354         */
355         for(curr = dataMasks, prev = NULL; curr; prev = curr, curr = curr->next) {
356                 if(prev) {
357                         CustomDataMask prev_mask = (CustomDataMask)GET_INT_FROM_POINTER(prev->link);
358                         CustomDataMask curr_mask = (CustomDataMask)GET_INT_FROM_POINTER(curr->link);
359
360                         curr->link = SET_INT_IN_POINTER(curr_mask | prev_mask);
361                 } else {
362                         CustomDataMask curr_mask = (CustomDataMask)GET_INT_FROM_POINTER(curr->link);
363
364                         curr->link = SET_INT_IN_POINTER(curr_mask | dataMask);
365                 }
366         }
367
368         /* reverse the list so it's in the correct order */
369         BLI_linklist_reverse(&dataMasks);
370
371         return dataMasks;
372 }
373
374 ModifierData *modifiers_getVirtualModifierList(Object *ob)
375 {
376                 /* Kinda hacky, but should be fine since we are never
377         * reentrant and avoid free hassles.
378                 */
379         static ArmatureModifierData amd;
380         static CurveModifierData cmd;
381         static LatticeModifierData lmd;
382         static ShapeKeyModifierData smd;
383         static int init = 1;
384         ModifierData *md;
385
386         if (init) {
387                 md = modifier_new(eModifierType_Armature);
388                 amd = *((ArmatureModifierData*) md);
389                 modifier_free(md);
390
391                 md = modifier_new(eModifierType_Curve);
392                 cmd = *((CurveModifierData*) md);
393                 modifier_free(md);
394
395                 md = modifier_new(eModifierType_Lattice);
396                 lmd = *((LatticeModifierData*) md);
397                 modifier_free(md);
398
399                 md = modifier_new(eModifierType_ShapeKey);
400                 smd = *((ShapeKeyModifierData*) md);
401                 modifier_free(md);
402
403                 amd.modifier.mode |= eModifierMode_Virtual;
404                 cmd.modifier.mode |= eModifierMode_Virtual;
405                 lmd.modifier.mode |= eModifierMode_Virtual;
406                 smd.modifier.mode |= eModifierMode_Virtual;
407
408                 init = 0;
409         }
410
411         md = ob->modifiers.first;
412
413         if(ob->parent) {
414                 if(ob->parent->type==OB_ARMATURE && ob->partype==PARSKEL) {
415                         amd.object = ob->parent;
416                         amd.modifier.next = md;
417                         amd.deformflag= ((bArmature *)(ob->parent->data))->deformflag;
418                         md = &amd.modifier;
419                 } else if(ob->parent->type==OB_CURVE && ob->partype==PARSKEL) {
420                         cmd.object = ob->parent;
421                         cmd.defaxis = ob->trackflag + 1;
422                         cmd.modifier.next = md;
423                         md = &cmd.modifier;
424                 } else if(ob->parent->type==OB_LATTICE && ob->partype==PARSKEL) {
425                         lmd.object = ob->parent;
426                         lmd.modifier.next = md;
427                         md = &lmd.modifier;
428                 }
429         }
430
431         /* shape key modifier, not yet for curves */
432         if(ELEM(ob->type, OB_MESH, OB_LATTICE) && ob_get_key(ob)) {
433                 if(ob->type == OB_MESH && (ob->shapeflag & OB_SHAPE_EDIT_MODE))
434                         smd.modifier.mode |= eModifierMode_Editmode|eModifierMode_OnCage;
435                 else
436                         smd.modifier.mode &= ~eModifierMode_Editmode|eModifierMode_OnCage;
437
438                 smd.modifier.next = md;
439                 md = &smd.modifier;
440         }
441
442         return md;
443 }
444 /* Takes an object and returns its first selected armature, else just its
445  * armature
446  * This should work for multiple armatures per object
447  */
448 Object *modifiers_isDeformedByArmature(Object *ob)
449 {
450         ModifierData *md = modifiers_getVirtualModifierList(ob);
451         ArmatureModifierData *amd= NULL;
452         
453         /* return the first selected armature, this lets us use multiple armatures
454         */
455         for (; md; md=md->next) {
456                 if (md->type==eModifierType_Armature) {
457                         amd = (ArmatureModifierData*) md;
458                         if (amd->object && (amd->object->flag & SELECT))
459                                 return amd->object;
460                 }
461         }
462         
463         if (amd) /* if were still here then return the last armature */
464                 return amd->object;
465         
466         return NULL;
467 }
468
469 /* Takes an object and returns its first selected lattice, else just its
470 * lattice
471 * This should work for multiple lattics per object
472 */
473 Object *modifiers_isDeformedByLattice(Object *ob)
474 {
475         ModifierData *md = modifiers_getVirtualModifierList(ob);
476         LatticeModifierData *lmd= NULL;
477         
478         /* return the first selected lattice, this lets us use multiple lattices
479         */
480         for (; md; md=md->next) {
481                 if (md->type==eModifierType_Lattice) {
482                         lmd = (LatticeModifierData*) md;
483                         if (lmd->object && (lmd->object->flag & SELECT))
484                                 return lmd->object;
485                 }
486         }
487         
488         if (lmd) /* if were still here then return the last lattice */
489                 return lmd->object;
490         
491         return NULL;
492 }
493
494
495
496 int modifiers_usesArmature(Object *ob, bArmature *arm)
497 {
498         ModifierData *md = modifiers_getVirtualModifierList(ob);
499
500         for (; md; md=md->next) {
501                 if (md->type==eModifierType_Armature) {
502                         ArmatureModifierData *amd = (ArmatureModifierData*) md;
503                         if (amd->object && amd->object->data==arm) 
504                                 return 1;
505                 }
506         }
507
508         return 0;
509 }
510
511 int modifier_isCorrectableDeformed(ModifierData *md)
512 {
513         if (md->type==eModifierType_Armature)
514                 return 1;
515         if (md->type==eModifierType_ShapeKey)
516                 return 1;
517         
518         return 0;
519 }
520
521 int modifiers_isCorrectableDeformed(Object *ob)
522 {
523         ModifierData *md = modifiers_getVirtualModifierList(ob);
524         
525         for (; md; md=md->next) {
526                 if(ob->mode==OB_MODE_EDIT && (md->mode & eModifierMode_Editmode)==0);
527                 else 
528                         if(modifier_isCorrectableDeformed(md))
529                                 return 1;
530         }
531         return 0;
532 }
533
534 int modifiers_indexInObject(Object *ob, ModifierData *md_seek)
535 {
536         int i= 0;
537         ModifierData *md;
538         
539         for (md=ob->modifiers.first; (md && md_seek!=md); md=md->next, i++);
540         if (!md) return -1; /* modifier isnt in the object */
541         return i;
542 }
543
544 void modifier_freeTemporaryData(ModifierData *md)
545 {
546         if(md->type == eModifierType_Armature) {
547                 ArmatureModifierData *amd= (ArmatureModifierData*)md;
548
549                 if(amd->prevCos) {
550                         MEM_freeN(amd->prevCos);
551                         amd->prevCos= NULL;
552                 }
553         }
554 }
555
556 /* ensure modifier correctness when changing ob->data */
557 void test_object_modifiers(Object *ob)
558 {
559         ModifierData *md;
560
561         /* just multires checked for now, since only multires
562            modifies mesh data */
563
564         if(ob->type != OB_MESH) return;
565
566         for(md = ob->modifiers.first; md; md = md->next) {
567                 if(md->type == eModifierType_Multires) {
568                         MultiresModifierData *mmd = (MultiresModifierData*)md;
569
570                         multiresModifier_set_levels_from_disps(mmd, ob);
571                 }
572         }
573 }