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