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