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