6b9392a416983dac267d60fce175fb835b6b8d05
[blender-staging.git] / source / blender / blenkernel / BKE_modifier.h
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) 2001-2002 by NaN Holding BV.
19  * All rights reserved.
20  *
21  * The Original Code is: all of this file.
22  *
23  * Contributor(s): none yet.
24  *
25  * ***** END GPL LICENSE BLOCK *****
26  */
27 #ifndef __BKE_MODIFIER_H__
28 #define __BKE_MODIFIER_H__
29
30 /** \file BKE_modifier.h
31  *  \ingroup bke
32  */
33
34 #include "DNA_modifier_types.h"     /* needed for all enum typdefs */
35 #include "BKE_customdata.h"
36
37 struct ID;
38 struct DerivedMesh;
39 struct DagForest;
40 struct DagNode;
41 struct Object;
42 struct Scene;
43 struct ListBase;
44 struct LinkNode;
45 struct bArmature;
46 struct ModifierData;
47 struct BMEditMesh;
48
49 typedef enum {
50         /* Should not be used, only for None modifier type */
51         eModifierTypeType_None,
52
53         /* Modifier only does deformation, implies that modifier
54          * type should have a valid deformVerts function. OnlyDeform
55          * style modifiers implicitly accept either mesh or CV
56          * input but should still declare flags appropriately.
57          */
58         eModifierTypeType_OnlyDeform,
59
60         eModifierTypeType_Constructive,
61         eModifierTypeType_Nonconstructive,
62
63         /* both deformVerts & applyModifier are valid calls
64          * used for particles modifier that doesn't actually modify the object
65          * unless it's a mesh and can be exploded -> curve can also emit particles
66          */
67         eModifierTypeType_DeformOrConstruct,
68
69         /* Like eModifierTypeType_Nonconstructive, but does not affect the geometry
70          * of the object, rather some of its CustomData layers.
71          * E.g. UVProject and WeightVG modifiers. */
72         eModifierTypeType_NonGeometrical,
73 } ModifierTypeType;
74
75 typedef enum {
76         eModifierTypeFlag_AcceptsMesh          = (1 << 0),
77         eModifierTypeFlag_AcceptsCVs           = (1 << 1),
78         eModifierTypeFlag_SupportsMapping      = (1 << 2),
79         eModifierTypeFlag_SupportsEditmode     = (1 << 3),
80
81         /* For modifiers that support editmode this determines if the
82          * modifier should be enabled by default in editmode. This should
83          * only be used by modifiers that are relatively speedy and
84          * also generally used in editmode, otherwise let the user enable
85          * it by hand.
86          */
87         eModifierTypeFlag_EnableInEditmode     = (1 << 4),
88
89         /* For modifiers that require original data and so cannot
90          * be placed after any non-deformative modifier.
91          */
92         eModifierTypeFlag_RequiresOriginalData = (1 << 5),
93
94         /* For modifiers that support pointcache, so we can check to see if it has files we need to deal with
95          */
96         eModifierTypeFlag_UsesPointCache = (1 << 6),
97
98         /* For physics modifiers, max one per type */
99         eModifierTypeFlag_Single = (1 << 7),
100
101         /* Some modifier can't be added manually by user */
102         eModifierTypeFlag_NoUserAdd = (1 << 8),
103
104         /* For modifiers that use CD_PREVIEW_MCOL for preview. */
105         eModifierTypeFlag_UsesPreview = (1 << 9)
106 } ModifierTypeFlag;
107
108 typedef void (*ObjectWalkFunc)(void *userData, struct Object *ob, struct Object **obpoin);
109 typedef void (*IDWalkFunc)(void *userData, struct Object *ob, struct ID **idpoin);
110 typedef void (*TexWalkFunc)(void *userData, struct Object *ob, struct ModifierData *md, const char *propname);
111
112 typedef enum ModifierApplyFlag {
113         MOD_APPLY_RENDER = 1 << 0,       /* Render time. */
114         MOD_APPLY_USECACHE = 1 << 1,     /* Result of evaluation will be cached, so modifier might
115                                           * want to cache data for quick updates (used by subsurf) */
116         MOD_APPLY_ORCO = 1 << 2          /* Modifier evaluated for undeformed texture coordinates */
117 } ModifierApplyFlag;
118
119
120 typedef struct ModifierTypeInfo {
121         /* The user visible name for this modifier */
122         char name[32];
123
124         /* The DNA struct name for the modifier data type, used to
125          * write the DNA data out.
126          */
127         char structName[32];
128
129         /* The size of the modifier data type, used by allocation. */
130         int structSize;
131
132         ModifierTypeType type;
133         ModifierTypeFlag flags;
134
135
136         /********************* Non-optional functions *********************/
137
138         /* Copy instance data for this modifier type. Should copy all user
139          * level settings to the target modifier.
140          */
141         void (*copyData)(struct ModifierData *md, struct ModifierData *target);
142
143         /********************* Deform modifier functions *********************/
144
145         /* Only for deform types, should apply the deformation
146          * to the given vertex array. If the deformer requires information from
147          * the object it can obtain it from the derivedData argument if non-NULL,
148          * and otherwise the ob argument.
149          */
150         void (*deformVerts)(struct ModifierData *md, struct Object *ob,
151                             struct DerivedMesh *derivedData,
152                             float (*vertexCos)[3], int numVerts,
153                             ModifierApplyFlag flag);
154
155         /* Like deformMatricesEM but called from object mode (for supporting modifiers in sculpt mode) */
156         void (*deformMatrices)(struct ModifierData *md, struct Object *ob,
157                                struct DerivedMesh *derivedData,
158                                float (*vertexCos)[3], float (*defMats)[3][3], int numVerts);
159
160         /* Like deformVerts but called during editmode (for supporting modifiers)
161          */
162         void (*deformVertsEM)(struct ModifierData *md, struct Object *ob,
163                               struct BMEditMesh *editData, struct DerivedMesh *derivedData,
164                               float (*vertexCos)[3], int numVerts);
165
166         /* Set deform matrix per vertex for crazyspace correction */
167         void (*deformMatricesEM)(struct ModifierData *md, struct Object *ob,
168                                  struct BMEditMesh *editData, struct DerivedMesh *derivedData,
169                                  float (*vertexCos)[3], float (*defMats)[3][3], int numVerts);
170
171         /********************* Non-deform modifier functions *********************/
172
173         /* For non-deform types: apply the modifier and return a derived
174          * data object (type is dependent on object type).
175          *
176          * The derivedData argument should always be non-NULL; the modifier
177          * should read the object data from the derived object instead of the
178          * actual object data. 
179          *
180          * The useRenderParams argument indicates if the modifier is being
181          * applied in the service of the renderer which may alter quality
182          * settings.
183          *
184          * The isFinalCalc parameter indicates if the modifier is being
185          * calculated for a final result or for something temporary
186          * (like orcos). This is a hack at the moment, it is meant so subsurf
187          * can know if it is safe to reuse its internal cache.
188          *
189          * The modifier may reuse the derivedData argument (i.e. return it in
190          * modified form), but must not release it.
191          */
192         struct DerivedMesh *(*applyModifier)(struct ModifierData *md, struct Object *ob,
193                                              struct DerivedMesh *derivedData,
194                                              ModifierApplyFlag flag);
195
196         /* Like applyModifier but called during editmode (for supporting
197          * modifiers).
198          * 
199          * The derived object that is returned must support the operations that
200          * are expected from editmode objects. The same qualifications regarding
201          * derivedData apply as for applyModifier.
202          */
203         struct DerivedMesh *(*applyModifierEM)(struct ModifierData *md, struct Object *ob,
204                                                struct BMEditMesh *editData,
205                                                struct DerivedMesh *derivedData,
206                                                ModifierApplyFlag flag);
207
208
209         /********************* Optional functions *********************/
210
211         /* Initialize new instance data for this modifier type, this function
212          * should set modifier variables to their default values.
213          * 
214          * This function is optional.
215          */
216         void (*initData)(struct ModifierData *md);
217
218         /* Should return a CustomDataMask indicating what data this
219          * modifier needs. If (mask & (1 << (layer type))) != 0, this modifier
220          * needs that custom data layer. This function's return value can change
221          * depending on the modifier's settings.
222          *
223          * Note that this means extra data (e.g. vertex groups) - it is assumed
224          * that all modifiers need mesh data and deform modifiers need vertex
225          * coordinates.
226          *
227          * Note that this limits the number of custom data layer types to 32.
228          *
229          * If this function is not present or it returns 0, it is assumed that
230          * no extra data is needed.
231          *
232          * This function is optional.
233          */
234         CustomDataMask (*requiredDataMask)(struct Object *ob, struct ModifierData *md);
235
236         /* Free internal modifier data variables, this function should
237          * not free the md variable itself.
238          *
239          * This function is optional.
240          */
241         void (*freeData)(struct ModifierData *md);
242
243         /* Return a boolean value indicating if this modifier is able to be
244          * calculated based on the modifier data. This is *not* regarding the
245          * md->flag, that is tested by the system, this is just if the data
246          * validates (for example, a lattice will return false if the lattice
247          * object is not defined).
248          *
249          * This function is optional (assumes never disabled if not present).
250          */
251         bool (*isDisabled)(struct ModifierData *md, int userRenderParams);
252
253         /* Add the appropriate relations to the DEP graph depending on the
254          * modifier data. 
255          *
256          * This function is optional.
257          */
258         void (*updateDepgraph)(struct ModifierData *md, struct DagForest *forest, struct Scene *scene,
259                                struct Object *ob, struct DagNode *obNode);
260
261         /* Should return true if the modifier needs to be recalculated on time
262          * changes.
263          *
264          * This function is optional (assumes false if not present).
265          */
266         bool (*dependsOnTime)(struct ModifierData *md);
267
268
269         /* True when a deform modifier uses normals, the requiredDataMask
270          * cant be used here because that refers to a normal layer where as
271          * in this case we need to know if the deform modifier uses normals.
272          * 
273          * this is needed because applying 2 deform modifiers will give the
274          * second modifier bogus normals.
275          * */
276         bool (*dependsOnNormals)(struct ModifierData *md);
277
278
279         /* Should call the given walk function on with a pointer to each Object
280          * pointer that the modifier data stores. This is used for linking on file
281          * load and for unlinking objects or forwarding object references.
282          *
283          * This function is optional.
284          */
285         void (*foreachObjectLink)(struct ModifierData *md, struct Object *ob,
286                                   ObjectWalkFunc walk, void *userData);
287
288         /* Should call the given walk function with a pointer to each ID
289          * pointer (i.e. each datablock pointer) that the modifier data
290          * stores. This is used for linking on file load and for
291          * unlinking datablocks or forwarding datablock references.
292          *
293          * This function is optional. If it is not present, foreachObjectLink
294          * will be used.
295          */
296         void (*foreachIDLink)(struct ModifierData *md, struct Object *ob,
297                               IDWalkFunc walk, void *userData);
298
299         /* Should call the given walk function for each texture that the
300          * modifier data stores. This is used for finding all textures in
301          * the context for the UI.
302          *
303          * This function is optional. If it is not present, it will be
304          * assumed the modifier has no textures.
305          */
306         void (*foreachTexLink)(struct ModifierData *md, struct Object *ob,
307                                TexWalkFunc walk, void *userData);
308 } ModifierTypeInfo;
309
310 ModifierTypeInfo *modifierType_getInfo(ModifierType type);
311
312 /* Modifier utility calls, do call through type pointer and return
313  * default values if pointer is optional.
314  */
315 struct ModifierData  *modifier_new(int type);
316 void          modifier_free(struct ModifierData *md);
317
318 void          modifier_unique_name(struct ListBase *modifiers, struct ModifierData *md);
319
320 void          modifier_copyData(struct ModifierData *md, struct ModifierData *target);
321 bool          modifier_dependsOnTime(struct ModifierData *md);
322 bool          modifier_supportsMapping(struct ModifierData *md);
323 bool          modifier_couldBeCage(struct Scene *scene, struct ModifierData *md);
324 bool          modifier_isCorrectableDeformed(struct ModifierData *md);
325 bool          modifier_isSameTopology(ModifierData *md);
326 bool          modifier_isNonGeometrical(ModifierData *md);
327 bool          modifier_isEnabled(struct Scene *scene, struct ModifierData *md, int required_mode);
328 void          modifier_setError(struct ModifierData *md, const char *format, ...)
329 #ifdef __GNUC__
330 __attribute__ ((format(printf, 2, 3)))
331 #endif
332 ;
333 bool          modifier_isPreview(struct ModifierData *md);
334
335 void          modifiers_foreachObjectLink(struct Object *ob,
336                                           ObjectWalkFunc walk,
337                                           void *userData);
338 void          modifiers_foreachIDLink(struct Object *ob,
339                                       IDWalkFunc walk,
340                                       void *userData);
341 void          modifiers_foreachTexLink(struct Object *ob,
342                                        TexWalkFunc walk,
343                                        void *userData);
344
345 struct ModifierData  *modifiers_findByType(struct Object *ob, ModifierType type);
346 struct ModifierData  *modifiers_findByName(struct Object *ob, const char *name);
347 void          modifiers_clearErrors(struct Object *ob);
348 int           modifiers_getCageIndex(struct Scene *scene, struct Object *ob,
349                                      int *lastPossibleCageIndex_r, int virtual_);
350
351 bool          modifiers_isModifierEnabled(struct Object *ob, int modifierType);
352 bool          modifiers_isSoftbodyEnabled(struct Object *ob);
353 bool          modifiers_isClothEnabled(struct Object *ob);
354 bool          modifiers_isParticleEnabled(struct Object *ob);
355
356 struct Object *modifiers_isDeformedByArmature(struct Object *ob);
357 struct Object *modifiers_isDeformedByLattice(struct Object *ob);
358 struct Object *modifiers_isDeformedByCurve(struct Object *ob);
359 bool          modifiers_usesArmature(struct Object *ob, struct bArmature *arm);
360 bool          modifiers_isCorrectableDeformed(struct Object *ob);
361 void          modifier_freeTemporaryData(struct ModifierData *md);
362 bool          modifiers_isPreview(struct Object *ob);
363
364 typedef struct CDMaskLink {
365         struct CDMaskLink *next;
366         CustomDataMask mask;
367 } CDMaskLink;
368
369 /* Calculates and returns a linked list of CustomDataMasks indicating the
370  * data required by each modifier in the stack pointed to by md for correct
371  * evaluation, assuming the data indicated by dataMask is required at the
372  * end of the stack.
373  */
374 struct CDMaskLink *modifiers_calcDataMasks(struct Scene *scene,
375                                            struct Object *ob,
376                                            struct ModifierData *md,
377                                            CustomDataMask dataMask,
378                                            int required_mode,
379                                            ModifierData *previewmd, CustomDataMask previewmask);
380 struct ModifierData *modifiers_getLastPreview(struct Scene *scene,
381                                               struct ModifierData *md,
382                                               int required_mode);
383 struct ModifierData  *modifiers_getVirtualModifierList(struct Object *ob);
384
385 /* ensure modifier correctness when changing ob->data */
386 void test_object_modifiers(struct Object *ob);
387
388 /* here for do_versions */
389 void modifier_mdef_compact_influences(struct ModifierData *md);
390
391 void        modifier_path_init(char *path, int path_maxlen, const char *name);
392 const char *modifier_path_relbase(struct Object *ob);
393
394 #endif
395