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