merge with/from trunk at r35190
[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
106 typedef struct ModifierTypeInfo {
107         /* The user visible name for this modifier */
108         char name[32];
109
110         /* The DNA struct name for the modifier data type, used to
111          * write the DNA data out.
112          */
113         char structName[32];
114
115         /* The size of the modifier data type, used by allocation. */
116         int structSize;
117
118         ModifierTypeType type;
119         ModifierTypeFlag flags;
120
121
122         /********************* Non-optional functions *********************/
123
124         /* Copy instance data for this modifier type. Should copy all user
125          * level settings to the target modifier.
126          */
127         void (*copyData)(struct ModifierData *md, struct ModifierData *target);
128
129         /********************* Deform modifier functions *********************/
130
131         /* Only for deform types, should apply the deformation
132          * to the given vertex array. If the deformer requires information from
133          * the object it can obtain it from the derivedData argument if non-NULL,
134          * and otherwise the ob argument.
135          */
136         void (*deformVerts)(struct ModifierData *md, struct Object *ob,
137                                                 struct DerivedMesh *derivedData,
138                                                 float (*vertexCos)[3], int numVerts,
139                                                 int useRenderParams, int isFinalCalc);
140
141         /* Like deformMatricesEM but called from object mode (for supporting modifiers in sculpt mode) */
142         void (*deformMatrices)(
143                                 struct ModifierData *md, struct Object *ob,
144                                 struct DerivedMesh *derivedData,
145                                 float (*vertexCos)[3], float (*defMats)[3][3], int numVerts);
146
147         /* Like deformVerts but called during editmode (for supporting modifiers)
148          */
149         void (*deformVertsEM)(
150                                 struct ModifierData *md, struct Object *ob,
151                                 struct BMEditMesh *editData, struct DerivedMesh *derivedData,
152                                 float (*vertexCos)[3], int numVerts);
153
154         /* Set deform matrix per vertex for crazyspace correction */
155         void (*deformMatricesEM)(
156                                 struct ModifierData *md, struct Object *ob,
157                                 struct BMEditMesh *editData, struct DerivedMesh *derivedData,
158                                 float (*vertexCos)[3], float (*defMats)[3][3], int numVerts);
159
160         /********************* Non-deform modifier functions *********************/
161
162         /* For non-deform types: apply the modifier and return a derived
163          * data object (type is dependent on object type).
164          *
165          * The derivedData argument should always be non-NULL; the modifier
166          * should read the object data from the derived object instead of the
167          * actual object data. 
168          *
169          * The useRenderParams argument indicates if the modifier is being
170          * applied in the service of the renderer which may alter quality
171          * settings.
172          *
173          * The isFinalCalc parameter indicates if the modifier is being
174          * calculated for a final result or for something temporary
175          * (like orcos). This is a hack at the moment, it is meant so subsurf
176          * can know if it is safe to reuse its internal cache.
177          *
178          * The modifier may reuse the derivedData argument (i.e. return it in
179          * modified form), but must not release it.
180          */
181         struct DerivedMesh *(*applyModifier)(
182                                                                 struct ModifierData *md, struct Object *ob,
183                                                                 struct DerivedMesh *derivedData,
184                                                                 int useRenderParams, int isFinalCalc);
185
186         /* Like applyModifier but called during editmode (for supporting
187          * modifiers).
188          * 
189          * The derived object that is returned must support the operations that
190          * are expected from editmode objects. The same qualifications regarding
191          * derivedData apply as for applyModifier.
192          */
193         struct DerivedMesh *(*applyModifierEM)(
194                                                                 struct ModifierData *md, struct Object *ob,
195                                                                 struct BMEditMesh *editData,
196                                                                 struct DerivedMesh *derivedData);
197
198
199         /********************* Optional functions *********************/
200
201         /* Initialize new instance data for this modifier type, this function
202          * should set modifier variables to their default values.
203          * 
204          * This function is optional.
205          */
206         void (*initData)(struct ModifierData *md);
207
208         /* Should return a CustomDataMask indicating what data this
209          * modifier needs. If (mask & (1 << (layer type))) != 0, this modifier
210          * needs that custom data layer. This function's return value can change
211          * depending on the modifier's settings.
212          *
213          * Note that this means extra data (e.g. vertex groups) - it is assumed
214          * that all modifiers need mesh data and deform modifiers need vertex
215          * coordinates.
216          *
217          * Note that this limits the number of custom data layer types to 32.
218          *
219          * If this function is not present or it returns 0, it is assumed that
220          * no extra data is needed.
221          *
222          * This function is optional.
223          */
224         CustomDataMask (*requiredDataMask)(struct Object *ob, struct ModifierData *md);
225
226         /* Free internal modifier data variables, this function should
227          * not free the md variable itself.
228          *
229          * This function is optional.
230          */
231         void (*freeData)(struct ModifierData *md);
232
233         /* Return a boolean value indicating if this modifier is able to be
234          * calculated based on the modifier data. This is *not* regarding the
235          * md->flag, that is tested by the system, this is just if the data
236          * validates (for example, a lattice will return false if the lattice
237          * object is not defined).
238          *
239          * This function is optional (assumes never disabled if not present).
240          */
241         int (*isDisabled)(struct ModifierData *md, int userRenderParams);
242
243         /* Add the appropriate relations to the DEP graph depending on the
244          * modifier data. 
245          *
246          * This function is optional.
247          */
248         void (*updateDepgraph)(struct ModifierData *md, struct DagForest *forest, struct Scene *scene,
249                                                    struct Object *ob, struct DagNode *obNode);
250
251         /* Should return true if the modifier needs to be recalculated on time
252          * changes.
253          *
254          * This function is optional (assumes false if not present).
255          */
256         int (*dependsOnTime)(struct ModifierData *md);
257
258
259         /* True when a deform modifier uses normals, the requiredDataMask
260          * cant be used here because that refers to a normal layer where as
261          * in this case we need to know if the deform modifier uses normals.
262          * 
263          * this is needed because applying 2 deform modifiers will give the
264          * second modifier bogus normals.
265          * */
266         int (*dependsOnNormals)(struct ModifierData *md);
267
268
269         /* Should call the given walk function on with a pointer to each Object
270          * pointer that the modifier data stores. This is used for linking on file
271          * load and for unlinking objects or forwarding object references.
272          *
273          * This function is optional.
274          */
275         void (*foreachObjectLink)(struct ModifierData *md, struct Object *ob,
276                                                           ObjectWalkFunc walk, void *userData);
277
278         /* Should call the given walk function with a pointer to each ID
279          * pointer (i.e. each datablock pointer) that the modifier data
280          * stores. This is used for linking on file load and for
281          * unlinking datablocks or forwarding datablock references.
282          *
283          * This function is optional. If it is not present, foreachObjectLink
284          * will be used.
285          */
286         void (*foreachIDLink)(struct ModifierData *md, struct Object *ob,
287                                                   IDWalkFunc walk, void *userData);
288 } ModifierTypeInfo;
289
290 ModifierTypeInfo *modifierType_getInfo (ModifierType type);
291
292 /* Modifier utility calls, do call through type pointer and return
293  * default values if pointer is optional.
294  */
295 struct ModifierData  *modifier_new(int type);
296 void          modifier_free(struct ModifierData *md);
297
298 void              modifier_unique_name(struct ListBase *modifiers, struct ModifierData *md);
299
300 void          modifier_copyData(struct ModifierData *md, struct ModifierData *target);
301 int           modifier_dependsOnTime(struct ModifierData *md);
302 int           modifier_supportsMapping(struct ModifierData *md);
303 int           modifier_couldBeCage(struct Scene *scene, struct ModifierData *md);
304 int           modifier_isCorrectableDeformed(struct ModifierData *md);
305 int                       modifier_sameTopology(ModifierData *md);
306 int           modifier_isEnabled(struct Scene *scene, struct ModifierData *md, int required_mode);
307 void          modifier_setError(struct ModifierData *md, const char *format, ...)
308 #ifdef __GNUC__
309 __attribute__ ((format (printf, 2, 3)));
310 #endif
311 ;
312
313 void          modifiers_foreachObjectLink(struct Object *ob,
314                                                                                   ObjectWalkFunc walk,
315                                                                                   void *userData);
316 void          modifiers_foreachIDLink(struct Object *ob,
317                                                                           IDWalkFunc walk,
318                                                                           void *userData);
319 struct ModifierData  *modifiers_findByType(struct Object *ob, ModifierType type);
320 struct ModifierData  *modifiers_findByName(struct Object *ob, const char *name);
321 void          modifiers_clearErrors(struct Object *ob);
322 int           modifiers_getCageIndex(struct Scene *scene, struct Object *ob,
323                                                                          int *lastPossibleCageIndex_r, int virtual_);
324
325 int           modifiers_isSoftbodyEnabled(struct Object *ob);
326 int           modifiers_isClothEnabled(struct Object *ob);
327 int           modifiers_isParticleEnabled(struct Object *ob);
328
329 struct Object *modifiers_isDeformedByArmature(struct Object *ob);
330 struct Object *modifiers_isDeformedByLattice(struct Object *ob);
331 int           modifiers_usesArmature(struct Object *ob, struct bArmature *arm);
332 int           modifiers_isCorrectableDeformed(struct Object *ob);
333 void          modifier_freeTemporaryData(struct ModifierData *md);
334
335 int           modifiers_indexInObject(struct Object *ob, struct ModifierData *md);
336
337 /* Calculates and returns a linked list of CustomDataMasks indicating the
338  * data required by each modifier in the stack pointed to by md for correct
339  * evaluation, assuming the data indicated by dataMask is required at the
340  * end of the stack.
341  */
342 struct LinkNode *modifiers_calcDataMasks(struct Scene *scene, 
343                                                                                  struct Object *ob,
344                                                                                  struct ModifierData *md,
345                                                                                  CustomDataMask dataMask,
346                                                                                  int required_mode);
347 struct ModifierData  *modifiers_getVirtualModifierList(struct Object *ob);
348
349 /* ensure modifier correctness when changing ob->data */
350 void test_object_modifiers(struct Object *ob);
351
352 /* here for do_versions */
353 void modifier_mdef_compact_influences(struct ModifierData *md);
354
355 #endif
356