Patch #34204: [Render Animation] Fails with "Error: Specified sample_fmt is not suppo...
[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 "BLF_translation.h"
59
60 #include "BKE_cloth.h"
61 #include "BKE_key.h"
62 #include "BKE_multires.h"
63
64 /* may move these, only for modifier_path_relbase */
65 #include "BKE_global.h" /* ugh, G.main->name only */
66 #include "BKE_main.h"
67 /* end */
68
69 #include "MOD_modifiertypes.h"
70
71 ModifierTypeInfo *modifierType_getInfo(ModifierType type)
72 {
73         static ModifierTypeInfo *types[NUM_MODIFIER_TYPES] = {NULL};
74         static int types_init = 1;
75
76         if (types_init) {
77                 modifier_type_init(types); /* MOD_utils.c */
78                 types_init = 0;
79         }
80
81         /* type unsigned, no need to check < 0 */
82         if (type < NUM_MODIFIER_TYPES && types[type]->name[0] != '\0') {
83                 return types[type];
84         }
85         else {
86                 return NULL;
87         }
88 }
89
90 /***/
91
92 ModifierData *modifier_new(int type)
93 {
94         ModifierTypeInfo *mti = modifierType_getInfo(type);
95         ModifierData *md = MEM_callocN(mti->structSize, mti->structName);
96         
97         /* note, this name must be made unique later */
98         BLI_strncpy(md->name, mti->name, sizeof(md->name));
99
100         md->type = type;
101         md->mode = eModifierMode_Realtime | eModifierMode_Render | eModifierMode_Expanded;
102
103         if (mti->flags & eModifierTypeFlag_EnableInEditmode)
104                 md->mode |= eModifierMode_Editmode;
105
106         if (mti->initData) mti->initData(md);
107
108         return md;
109 }
110
111 void modifier_free(ModifierData *md) 
112 {
113         ModifierTypeInfo *mti = modifierType_getInfo(md->type);
114
115         if (mti->freeData) mti->freeData(md);
116         if (md->error) MEM_freeN(md->error);
117
118         MEM_freeN(md);
119 }
120
121 void modifier_unique_name(ListBase *modifiers, ModifierData *md)
122 {
123         if (modifiers && md) {
124                 ModifierTypeInfo *mti = modifierType_getInfo(md->type);
125                 
126                 BLI_uniquename(modifiers, md, mti->name, '.', offsetof(ModifierData, name), sizeof(md->name));
127         }
128 }
129
130 int modifier_dependsOnTime(ModifierData *md) 
131 {
132         ModifierTypeInfo *mti = modifierType_getInfo(md->type);
133
134         return mti->dependsOnTime && mti->dependsOnTime(md);
135 }
136
137 int modifier_supportsMapping(ModifierData *md)
138 {
139         ModifierTypeInfo *mti = modifierType_getInfo(md->type);
140
141         return (mti->type == eModifierTypeType_OnlyDeform ||
142                 (mti->flags & eModifierTypeFlag_SupportsMapping));
143 }
144
145 int modifier_isPreview(ModifierData *md)
146 {
147         ModifierTypeInfo *mti = modifierType_getInfo(md->type);
148
149         if (!(mti->flags & eModifierTypeFlag_UsesPreview))
150                 return FALSE;
151
152         if (md->mode & eModifierMode_Realtime)
153                 return TRUE;
154
155         return FALSE;
156 }
157
158 ModifierData *modifiers_findByType(Object *ob, ModifierType type)
159 {
160         ModifierData *md = ob->modifiers.first;
161
162         for (; md; md = md->next)
163                 if (md->type == type)
164                         break;
165
166         return md;
167 }
168
169 ModifierData *modifiers_findByName(Object *ob, const char *name)
170 {
171         return BLI_findstring(&(ob->modifiers), name, offsetof(ModifierData, name));
172 }
173
174 void modifiers_clearErrors(Object *ob)
175 {
176         ModifierData *md = ob->modifiers.first;
177         /* int qRedraw = 0; */
178
179         for (; md; md = md->next) {
180                 if (md->error) {
181                         MEM_freeN(md->error);
182                         md->error = NULL;
183
184                         /* qRedraw = 1; */
185                 }
186         }
187 }
188
189 void modifiers_foreachObjectLink(Object *ob, ObjectWalkFunc walk,
190                                  void *userData)
191 {
192         ModifierData *md = ob->modifiers.first;
193
194         for (; md; md = md->next) {
195                 ModifierTypeInfo *mti = modifierType_getInfo(md->type);
196
197                 if (mti->foreachObjectLink)
198                         mti->foreachObjectLink(md, ob, walk, userData);
199         }
200 }
201
202 void modifiers_foreachIDLink(Object *ob, IDWalkFunc walk, void *userData)
203 {
204         ModifierData *md = ob->modifiers.first;
205
206         for (; md; md = md->next) {
207                 ModifierTypeInfo *mti = modifierType_getInfo(md->type);
208
209                 if (mti->foreachIDLink) mti->foreachIDLink(md, ob, walk, userData);
210                 else if (mti->foreachObjectLink) {
211                         /* each Object can masquerade as an ID, so this should be OK */
212                         ObjectWalkFunc fp = (ObjectWalkFunc)walk;
213                         mti->foreachObjectLink(md, ob, fp, userData);
214                 }
215         }
216 }
217
218 void modifiers_foreachTexLink(Object *ob, TexWalkFunc walk, void *userData)
219 {
220         ModifierData *md = ob->modifiers.first;
221
222         for (; md; md = md->next) {
223                 ModifierTypeInfo *mti = modifierType_getInfo(md->type);
224
225                 if (mti->foreachTexLink)
226                         mti->foreachTexLink(md, ob, walk, userData);
227         }
228 }
229
230 void modifier_copyData(ModifierData *md, ModifierData *target)
231 {
232         ModifierTypeInfo *mti = modifierType_getInfo(md->type);
233
234         target->mode = md->mode;
235
236         if (mti->copyData)
237                 mti->copyData(md, target);
238 }
239
240 int modifier_couldBeCage(struct Scene *scene, ModifierData *md)
241 {
242         ModifierTypeInfo *mti = modifierType_getInfo(md->type);
243
244         md->scene = scene;
245
246         return ((md->mode & eModifierMode_Realtime) &&
247                 (md->mode & eModifierMode_Editmode) &&
248                 (!mti->isDisabled || !mti->isDisabled(md, 0)) &&
249                 modifier_supportsMapping(md));
250 }
251
252 int modifier_isSameTopology(ModifierData *md)
253 {
254         ModifierTypeInfo *mti = modifierType_getInfo(md->type);
255         return ELEM(mti->type, eModifierTypeType_OnlyDeform, eModifierTypeType_NonGeometrical);
256 }
257
258 int modifier_isNonGeometrical(ModifierData *md)
259 {
260         ModifierTypeInfo *mti = modifierType_getInfo(md->type);
261         return (mti->type == eModifierTypeType_NonGeometrical);
262 }
263
264 void modifier_setError(ModifierData *md, const char *_format, ...)
265 {
266         char buffer[512];
267         va_list ap;
268         const char *format = TIP_(_format);
269
270         va_start(ap, _format);
271         vsnprintf(buffer, sizeof(buffer), format, ap);
272         va_end(ap);
273         buffer[sizeof(buffer) - 1] = '\0';
274
275         if (md->error)
276                 MEM_freeN(md->error);
277
278         md->error = BLI_strdup(buffer);
279
280 }
281
282 /* used for buttons, to find out if the 'draw deformed in editmode' option is
283  * there
284  * 
285  * also used in transform_conversion.c, to detect CrazySpace [tm] (2nd arg
286  * then is NULL) 
287  * also used for some mesh tools to give warnings
288  */
289 int modifiers_getCageIndex(struct Scene *scene, Object *ob, int *lastPossibleCageIndex_r, int virtual_)
290 {
291         ModifierData *md = (virtual_) ? modifiers_getVirtualModifierList(ob) : ob->modifiers.first;
292         int i, cageIndex = -1;
293
294         if (lastPossibleCageIndex_r) {
295                 /* ensure the value is initialized */
296                 *lastPossibleCageIndex_r = -1;
297         }
298
299         /* Find the last modifier acting on the cage. */
300         for (i = 0; md; i++, md = md->next) {
301                 ModifierTypeInfo *mti = modifierType_getInfo(md->type);
302
303                 md->scene = scene;
304
305                 if (!(md->mode & eModifierMode_Realtime)) continue;
306                 if (!(md->mode & eModifierMode_Editmode)) continue;
307                 if (mti->isDisabled && mti->isDisabled(md, 0)) continue;
308                 if (!(mti->flags & eModifierTypeFlag_SupportsEditmode)) continue;
309                 if (md->mode & eModifierMode_DisableTemporary) continue;
310
311                 if (!modifier_supportsMapping(md))
312                         break;
313
314                 if (lastPossibleCageIndex_r) *lastPossibleCageIndex_r = i;
315                 if (md->mode & eModifierMode_OnCage)
316                         cageIndex = i;
317         }
318
319         return cageIndex;
320 }
321
322
323 int modifiers_isSoftbodyEnabled(Object *ob)
324 {
325         ModifierData *md = modifiers_findByType(ob, eModifierType_Softbody);
326
327         return (md && md->mode & (eModifierMode_Realtime | eModifierMode_Render));
328 }
329
330 int modifiers_isClothEnabled(Object *ob)
331 {
332         ModifierData *md = modifiers_findByType(ob, eModifierType_Cloth);
333
334         return (md && md->mode & (eModifierMode_Realtime | eModifierMode_Render));
335 }
336
337 int modifiers_isModifierEnabled(Object *ob, int modifierType)
338 {
339         ModifierData *md = modifiers_findByType(ob, modifierType);
340
341         return (md && md->mode & (eModifierMode_Realtime | eModifierMode_Render));
342 }
343
344 int modifiers_isParticleEnabled(Object *ob)
345 {
346         ModifierData *md = modifiers_findByType(ob, eModifierType_ParticleSystem);
347
348         return (md && md->mode & (eModifierMode_Realtime | eModifierMode_Render));
349 }
350
351 int modifier_isEnabled(struct Scene *scene, ModifierData *md, int required_mode)
352 {
353         ModifierTypeInfo *mti = modifierType_getInfo(md->type);
354
355         md->scene = scene;
356
357         if ((md->mode & required_mode) != required_mode) return 0;
358         if (mti->isDisabled && mti->isDisabled(md, required_mode == eModifierMode_Render)) return 0;
359         if (md->mode & eModifierMode_DisableTemporary) return 0;
360         if (required_mode & eModifierMode_Editmode)
361                 if (!(mti->flags & eModifierTypeFlag_SupportsEditmode)) return 0;
362         
363         return 1;
364 }
365
366 CDMaskLink *modifiers_calcDataMasks(struct Scene *scene, Object *ob, ModifierData *md, CustomDataMask dataMask, int required_mode)
367 {
368         CDMaskLink *dataMasks = NULL;
369         CDMaskLink *curr, *prev;
370
371         /* build a list of modifier data requirements in reverse order */
372         for (; md; md = md->next) {
373                 ModifierTypeInfo *mti = modifierType_getInfo(md->type);
374
375                 curr = MEM_callocN(sizeof(CDMaskLink), "CDMaskLink");
376                 
377                 if (modifier_isEnabled(scene, md, required_mode))
378                         if (mti->requiredDataMask)
379                                 curr->mask = mti->requiredDataMask(ob, md);
380
381                 /* prepend new datamask */
382                 curr->next = dataMasks;
383                 dataMasks = curr;
384         }
385
386         /* build the list of required data masks - each mask in the list must
387          * include all elements of the masks that follow it
388          *
389          * note the list is currently in reverse order, so "masks that follow it"
390          * actually means "masks that precede it" at the moment
391          */
392         for (curr = dataMasks, prev = NULL; curr; prev = curr, curr = curr->next) {
393                 if (prev) {
394                         CustomDataMask prev_mask = prev->mask;
395                         CustomDataMask curr_mask = curr->mask;
396
397                         curr->mask = curr_mask | prev_mask;
398                 }
399                 else {
400                         CustomDataMask curr_mask = curr->mask;
401
402                         curr->mask = curr_mask | dataMask;
403                 }
404         }
405
406         /* reverse the list so it's in the correct order */
407         BLI_linklist_reverse((LinkNode **)&dataMasks);
408
409         return dataMasks;
410 }
411
412 ModifierData *modifiers_getLastPreview(struct Scene *scene, ModifierData *md, int required_mode)
413 {
414         ModifierData *tmp_md = NULL;
415
416         if (required_mode != eModifierMode_Realtime)
417                 return tmp_md;
418
419         /* Find the latest modifier in stack generating preview. */
420         for (; md; md = md->next) {
421                 if (modifier_isEnabled(scene, md, required_mode) && modifier_isPreview(md))
422                         tmp_md = md;
423         }
424         return tmp_md;
425 }
426
427 /* NOTE: This is to support old files from before Blender supported modifiers,
428  * in some cases versioning code updates these so for new files this will
429  * return an empty list. */
430 ModifierData *modifiers_getVirtualModifierList(Object *ob)
431 {
432         /* Kinda hacky, but should be fine since we are never
433          * re-entrant and avoid free hassles.
434          */
435         static ArmatureModifierData amd;
436         static CurveModifierData cmd;
437         static LatticeModifierData lmd;
438         static ShapeKeyModifierData smd;
439         static int init = 1;
440         ModifierData *md;
441
442         if (init) {
443                 md = modifier_new(eModifierType_Armature);
444                 amd = *((ArmatureModifierData *) md);
445                 modifier_free(md);
446
447                 md = modifier_new(eModifierType_Curve);
448                 cmd = *((CurveModifierData *) md);
449                 modifier_free(md);
450
451                 md = modifier_new(eModifierType_Lattice);
452                 lmd = *((LatticeModifierData *) md);
453                 modifier_free(md);
454
455                 md = modifier_new(eModifierType_ShapeKey);
456                 smd = *((ShapeKeyModifierData *) md);
457                 modifier_free(md);
458
459                 amd.modifier.mode |= eModifierMode_Virtual;
460                 cmd.modifier.mode |= eModifierMode_Virtual;
461                 lmd.modifier.mode |= eModifierMode_Virtual;
462                 smd.modifier.mode |= eModifierMode_Virtual;
463
464                 init = 0;
465         }
466
467         md = ob->modifiers.first;
468
469         if (ob->parent) {
470                 if (ob->parent->type == OB_ARMATURE && ob->partype == PARSKEL) {
471                         amd.object = ob->parent;
472                         amd.modifier.next = md;
473                         amd.deformflag = ((bArmature *)(ob->parent->data))->deformflag;
474                         md = &amd.modifier;
475                 }
476                 else if (ob->parent->type == OB_CURVE && ob->partype == PARSKEL) {
477                         cmd.object = ob->parent;
478                         cmd.defaxis = ob->trackflag + 1;
479                         cmd.modifier.next = md;
480                         md = &cmd.modifier;
481                 }
482                 else if (ob->parent->type == OB_LATTICE && ob->partype == PARSKEL) {
483                         lmd.object = ob->parent;
484                         lmd.modifier.next = md;
485                         md = &lmd.modifier;
486                 }
487         }
488
489         /* shape key modifier, not yet for curves */
490         if (ELEM(ob->type, OB_MESH, OB_LATTICE) && BKE_key_from_object(ob)) {
491                 if (ob->type == OB_MESH && (ob->shapeflag & OB_SHAPE_EDIT_MODE))
492                         smd.modifier.mode |= eModifierMode_Editmode | eModifierMode_OnCage;
493                 else
494                         smd.modifier.mode &= ~eModifierMode_Editmode | eModifierMode_OnCage;
495
496                 smd.modifier.next = md;
497                 md = &smd.modifier;
498         }
499
500         return md;
501 }
502
503 /* Takes an object and returns its first selected armature, else just its armature
504  * This should work for multiple armatures per object
505  */
506 Object *modifiers_isDeformedByArmature(Object *ob)
507 {
508         ModifierData *md = modifiers_getVirtualModifierList(ob);
509         ArmatureModifierData *amd = NULL;
510         
511         /* return the first selected armature, this lets us use multiple armatures */
512         for (; md; md = md->next) {
513                 if (md->type == eModifierType_Armature) {
514                         amd = (ArmatureModifierData *) md;
515                         if (amd->object && (amd->object->flag & SELECT))
516                                 return amd->object;
517                 }
518         }
519         
520         if (amd) /* if were still here then return the last armature */
521                 return amd->object;
522         
523         return NULL;
524 }
525
526 /* Takes an object and returns its first selected lattice, else just its lattice
527  * This should work for multiple lattices per object
528  */
529 Object *modifiers_isDeformedByLattice(Object *ob)
530 {
531         ModifierData *md = modifiers_getVirtualModifierList(ob);
532         LatticeModifierData *lmd = NULL;
533         
534         /* return the first selected lattice, this lets us use multiple lattices */
535         for (; md; md = md->next) {
536                 if (md->type == eModifierType_Lattice) {
537                         lmd = (LatticeModifierData *) md;
538                         if (lmd->object && (lmd->object->flag & SELECT))
539                                 return lmd->object;
540                 }
541         }
542         
543         if (lmd) /* if were still here then return the last lattice */
544                 return lmd->object;
545         
546         return NULL;
547 }
548
549 /* Takes an object and returns its first selected curve, else just its curve
550  * This should work for multiple curves per object
551  */
552 Object *modifiers_isDeformedByCurve(Object *ob)
553 {
554         ModifierData *md = modifiers_getVirtualModifierList(ob);
555         CurveModifierData *cmd = NULL;
556         
557         /* return the first selected curve, this lets us use multiple curves */
558         for (; md; md = md->next) {
559                 if (md->type == eModifierType_Curve) {
560                         cmd = (CurveModifierData *) md;
561                         if (cmd->object && (cmd->object->flag & SELECT))
562                                 return cmd->object;
563                 }
564         }
565         
566         if (cmd) /* if were still here then return the last curve */
567                 return cmd->object;
568         
569         return NULL;
570 }
571
572 int modifiers_usesArmature(Object *ob, bArmature *arm)
573 {
574         ModifierData *md = modifiers_getVirtualModifierList(ob);
575
576         for (; md; md = md->next) {
577                 if (md->type == eModifierType_Armature) {
578                         ArmatureModifierData *amd = (ArmatureModifierData *) md;
579                         if (amd->object && amd->object->data == arm)
580                                 return 1;
581                 }
582         }
583
584         return 0;
585 }
586
587 int modifier_isCorrectableDeformed(ModifierData *md)
588 {
589         if (md->type == eModifierType_Armature)
590                 return 1;
591         if (md->type == eModifierType_ShapeKey)
592                 return 1;
593         
594         return 0;
595 }
596
597 int modifiers_isCorrectableDeformed(Object *ob)
598 {
599         ModifierData *md = modifiers_getVirtualModifierList(ob);
600         
601         for (; md; md = md->next) {
602                 if (ob->mode == OB_MODE_EDIT && (md->mode & eModifierMode_Editmode) == 0) {
603                         /* pass */
604                 }
605                 else if (modifier_isCorrectableDeformed(md)) {
606                         return 1;
607                 }
608         }
609         return 0;
610 }
611
612 /* Check whether the given object has a modifier in its stack that uses WEIGHT_MCOL CD layer
613  * to preview something... Used by DynamicPaint and WeightVG currently. */
614 int modifiers_isPreview(Object *ob)
615 {
616         ModifierData *md = ob->modifiers.first;
617
618         for (; md; md = md->next) {
619                 if (modifier_isPreview(md))
620                         return TRUE;
621         }
622
623         return FALSE;
624 }
625
626 void modifier_freeTemporaryData(ModifierData *md)
627 {
628         if (md->type == eModifierType_Armature) {
629                 ArmatureModifierData *amd = (ArmatureModifierData *)md;
630
631                 if (amd->prevCos) {
632                         MEM_freeN(amd->prevCos);
633                         amd->prevCos = NULL;
634                 }
635         }
636 }
637
638 /* ensure modifier correctness when changing ob->data */
639 void test_object_modifiers(Object *ob)
640 {
641         ModifierData *md;
642
643         /* just multires checked for now, since only multires
644          * modifies mesh data */
645
646         if (ob->type != OB_MESH) return;
647
648         for (md = ob->modifiers.first; md; md = md->next) {
649                 if (md->type == eModifierType_Multires) {
650                         MultiresModifierData *mmd = (MultiresModifierData *)md;
651
652                         multiresModifier_set_levels_from_disps(mmd, ob);
653                 }
654         }
655 }
656
657 /* where should this go?, it doesnt fit well anywhere :S - campbell */
658
659 /* elubie: changed this to default to the same dir as the render output
660  * to prevent saving to C:\ on Windows */
661
662 /* campbell: logic behind this...
663  *
664  * - if the ID is from a library, return library path
665  * - else if the file has been saved return the blend file path.
666  * - else if the file isn't saved and the ID isn't from a library, return the temp dir.
667  */
668 const char *modifier_path_relbase(Object *ob)
669 {
670         if (G.relbase_valid || ob->id.lib) {
671                 return ID_BLEND_PATH(G.main, &ob->id);
672         }
673         else {
674                 /* last resort, better then using "" which resolves to the current
675                  * working directory */
676                 return BLI_temporary_dir();
677         }
678 }
679
680 /* initializes the path with either */
681 void modifier_path_init(char *path, int path_maxlen, const char *name)
682 {
683         /* elubie: changed this to default to the same dir as the render output
684          * to prevent saving to C:\ on Windows */
685         BLI_join_dirfile(path, path_maxlen,
686                          G.relbase_valid ? "//" : BLI_temporary_dir(),
687                          name);
688 }