Merge trunk up to revision 40611
[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
51 typedef enum {
52         /* Should not be used, only for None modifier type */
53         eModifierTypeType_None,
54
55         /* Modifier only does deformation, implies that modifier
56          * type should have a valid deformVerts function. OnlyDeform
57          * style modifiers implicitly accept either mesh or CV
58          * input but should still declare flags appropriately.
59          */
60         eModifierTypeType_OnlyDeform,
61
62         eModifierTypeType_Constructive,
63         eModifierTypeType_Nonconstructive,
64
65         /* both deformVerts & applyModifier are valid calls
66          * used for particles modifier that doesn't actually modify the object
67          * unless it's a mesh and can be exploded -> curve can also emit particles
68          */
69         eModifierTypeType_DeformOrConstruct,
70 } ModifierTypeType;
71
72 typedef enum {
73         eModifierTypeFlag_AcceptsMesh          = (1<<0),
74         eModifierTypeFlag_AcceptsCVs           = (1<<1),
75         eModifierTypeFlag_SupportsMapping      = (1<<2),
76         eModifierTypeFlag_SupportsEditmode     = (1<<3),
77
78         /* For modifiers that support editmode this determines if the
79          * modifier should be enabled by default in editmode. This should
80          * only be used by modifiers that are relatively speedy and
81          * also generally used in editmode, otherwise let the user enable
82          * it by hand.
83          */
84         eModifierTypeFlag_EnableInEditmode     = (1<<4),
85
86         /* For modifiers that require original data and so cannot
87          * be placed after any non-deformative modifier.
88          */
89         eModifierTypeFlag_RequiresOriginalData = (1<<5),
90
91         /* For modifiers that support pointcache, so we can check to see if it has files we need to deal with
92         */
93         eModifierTypeFlag_UsesPointCache = (1<<6),
94
95         /* For physics modifiers, max one per type */
96         eModifierTypeFlag_Single = (1<<7),
97
98         /* Some modifier can't be added manually by user */
99         eModifierTypeFlag_NoUserAdd = (1<<8)
100 } ModifierTypeFlag;
101
102 typedef void (*ObjectWalkFunc)(void *userData, struct Object *ob, struct Object **obpoin);
103 typedef void (*IDWalkFunc)(void *userData, struct Object *ob, struct ID **idpoin);
104 typedef void (*TexWalkFunc)(void *userData, struct Object *ob, struct ModifierData *md, const char *propname);
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 EditMesh *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 EditMesh *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 EditMesh *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
289         /* Should call the given walk function for each texture that the
290          * modifier data stores. This is used for finding all textures in
291          * the context for the UI.
292          *
293          * This function is optional. If it is not present, it will be
294          * assumed the modifier has no textures.
295          */
296         void (*foreachTexLink)(struct ModifierData *md, struct Object *ob,
297                                                   TexWalkFunc walk, void *userData);
298 } ModifierTypeInfo;
299
300 ModifierTypeInfo *modifierType_getInfo (ModifierType type);
301
302 /* Modifier utility calls, do call through type pointer and return
303  * default values if pointer is optional.
304  */
305 struct ModifierData  *modifier_new(int type);
306 void          modifier_free(struct ModifierData *md);
307
308 void              modifier_unique_name(struct ListBase *modifiers, struct ModifierData *md);
309
310 void          modifier_copyData(struct ModifierData *md, struct ModifierData *target);
311 int           modifier_dependsOnTime(struct ModifierData *md);
312 int           modifier_supportsMapping(struct ModifierData *md);
313 int           modifier_couldBeCage(struct Scene *scene, struct ModifierData *md);
314 int           modifier_isCorrectableDeformed(struct ModifierData *md);
315 int                       modifier_sameTopology(ModifierData *md);
316 int           modifier_isEnabled(struct Scene *scene, struct ModifierData *md, int required_mode);
317 void          modifier_setError(struct ModifierData *md, const char *format, ...)
318 #ifdef __GNUC__
319 __attribute__ ((format (printf, 2, 3)))
320 #endif
321 ;
322
323 void          modifiers_foreachObjectLink(struct Object *ob,
324                                                                                   ObjectWalkFunc walk,
325                                                                                   void *userData);
326 void          modifiers_foreachIDLink(struct Object *ob,
327                                                                           IDWalkFunc walk,
328                                                                           void *userData);
329 void          modifiers_foreachTexLink(struct Object *ob,
330                                                                           TexWalkFunc walk,
331                                                                           void *userData);
332
333 struct ModifierData  *modifiers_findByType(struct Object *ob, ModifierType type);
334 struct ModifierData  *modifiers_findByName(struct Object *ob, const char *name);
335 void          modifiers_clearErrors(struct Object *ob);
336 int           modifiers_getCageIndex(struct Scene *scene, struct Object *ob,
337                                                                          int *lastPossibleCageIndex_r, int virtual_);
338
339 int           modifiers_isSoftbodyEnabled(struct Object *ob);
340 int           modifiers_isClothEnabled(struct Object *ob);
341 int           modifiers_isParticleEnabled(struct Object *ob);
342
343 struct Object *modifiers_isDeformedByArmature(struct Object *ob);
344 struct Object *modifiers_isDeformedByLattice(struct Object *ob);
345 int           modifiers_usesArmature(struct Object *ob, struct bArmature *arm);
346 int           modifiers_isCorrectableDeformed(struct Object *ob);
347 void          modifier_freeTemporaryData(struct ModifierData *md);
348
349 int           modifiers_indexInObject(struct Object *ob, struct ModifierData *md);
350
351 /* Calculates and returns a linked list of CustomDataMasks indicating the
352  * data required by each modifier in the stack pointed to by md for correct
353  * evaluation, assuming the data indicated by dataMask is required at the
354  * end of the stack.
355  */
356 struct LinkNode *modifiers_calcDataMasks(struct Scene *scene, 
357                                                                                  struct Object *ob,
358                                                                                  struct ModifierData *md,
359                                                                                  CustomDataMask dataMask,
360                                                                                  int required_mode);
361 struct ModifierData  *modifiers_getVirtualModifierList(struct Object *ob);
362
363 /* ensure modifier correctness when changing ob->data */
364 void test_object_modifiers(struct Object *ob);
365
366 /* here for do_versions */
367 void modifier_mdef_compact_influences(struct ModifierData *md);
368
369 #endif
370