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