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