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