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