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