4b679c1587f658acde977b2a8b7348004c93d978
[blender.git] / source / blender / blenkernel / BKE_modifier.h
1 /**
2  *      
3  * $Id$ 
4  *
5  * ***** BEGIN GPL/BL DUAL 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. The Blender
11  * Foundation also sells licenses for use in proprietary software under
12  * the Blender License.  See http://www.blender.org/BL/ for information
13  * about this.
14  *
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU General Public License for more details.
19  *
20  * You should have received a copy of the GNU General Public License
21  * along with this program; if not, write to the Free Software Foundation,
22  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
23  *
24  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
25  * All rights reserved.
26  *
27  * The Original Code is: all of this file.
28  *
29  * Contributor(s): none yet.
30  *
31  * ***** END GPL/BL DUAL LICENSE BLOCK *****
32  */
33 #ifndef BKE_MODIFIER_H
34 #define BKE_MODIFIER_H
35
36 #include "DNA_modifier_types.h"         /* needed for all enum typdefs */
37 #include "BKE_customdata.h"
38
39 struct EditMesh;
40 struct DerivedMesh;
41 struct DagForest;
42 struct DagNode;
43 struct Object;
44 struct ListBase;
45 struct LinkNode;
46 struct bArmature;
47 struct ModifierData;
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 } ModifierTypeFlag;
93
94 typedef void (*ObjectWalkFunc)(void *userData, struct Object *ob, struct Object **obpoin);
95 typedef void (*IDWalkFunc)(void *userData, struct Object *ob, struct ID **idpoin);
96
97 typedef struct ModifierTypeInfo {
98         /* The user visible name for this modifier */
99         char name[32];
100
101         /* The DNA struct name for the modifier data type, used to
102          * write the DNA data out.
103          */
104         char structName[32];
105
106         /* The size of the modifier data type, used by allocation. */
107         int structSize;
108
109         ModifierTypeType type;
110         ModifierTypeFlag flags;
111
112
113         /********************* Non-optional functions *********************/
114
115         /* Copy instance data for this modifier type. Should copy all user
116          * level settings to the target modifier.
117          */
118         void (*copyData)(struct ModifierData *md, struct ModifierData *target);
119
120         /********************* Deform modifier functions *********************/
121
122         /* Only for deform types, should apply the deformation
123          * to the given vertex array. If the deformer requires information from
124          * the object it can obtain it from the derivedData argument if non-NULL,
125          * and otherwise the ob argument.
126          */
127         void (*deformVerts)(struct ModifierData *md, struct Object *ob,
128                             struct DerivedMesh *derivedData,
129                             float (*vertexCos)[3], int numVerts);
130
131         /* Like deformVerts but called during editmode (for supporting modifiers)
132          */
133         void (*deformVertsEM)(
134                     struct ModifierData *md, struct Object *ob,
135                     struct EditMesh *editData, struct DerivedMesh *derivedData,
136                     float (*vertexCos)[3], int numVerts);
137
138         /* Set deform matrix per vertex for crazyspace correction */
139         void (*deformMatricesEM)(
140                     struct ModifierData *md, struct Object *ob,
141                     struct EditMesh *editData, struct DerivedMesh *derivedData,
142                     float (*vertexCos)[3], float (*defMats)[3][3], int numVerts);
143
144         /********************* Non-deform modifier functions *********************/
145
146         /* For non-deform types: apply the modifier and return a derived
147          * data object (type is dependent on object type).
148          *
149          * The derivedData argument should always be non-NULL; the modifier
150          * should read the object data from the derived object instead of the
151          * actual object data. 
152          *
153          * The useRenderParams argument indicates if the modifier is being
154          * applied in the service of the renderer which may alter quality
155          * settings.
156          *
157          * The isFinalCalc parameter indicates if the modifier is being
158          * calculated for a final result or for something temporary
159          * (like orcos). This is a hack at the moment, it is meant so subsurf
160          * can know if it is safe to reuse its internal cache.
161          *
162          * The modifier may reuse the derivedData argument (i.e. return it in
163          * modified form), but must not release it.
164          */
165         struct DerivedMesh *(*applyModifier)(
166                                     struct ModifierData *md, struct Object *ob,
167                                     struct DerivedMesh *derivedData,
168                                     int useRenderParams, int isFinalCalc);
169
170         /* Like applyModifier but called during editmode (for supporting
171          * modifiers).
172          * 
173          * The derived object that is returned must support the operations that
174          * are expected from editmode objects. The same qualifications regarding
175          * derivedData apply as for applyModifier.
176          */
177         struct DerivedMesh *(*applyModifierEM)(
178                                     struct ModifierData *md, struct Object *ob,
179                                     struct EditMesh *editData,
180                                     struct DerivedMesh *derivedData);
181
182
183         /********************* Optional functions *********************/
184
185         /* Initialize new instance data for this modifier type, this function
186          * should set modifier variables to their default values.
187          * 
188          * This function is optional.
189          */
190         void (*initData)(struct ModifierData *md);
191
192         /* Should return a CustomDataMask indicating what data this
193          * modifier needs. If (mask & (1 << (layer type))) != 0, this modifier
194          * needs that custom data layer. This function's return value can change
195          * depending on the modifier's settings.
196          *
197          * Note that this means extra data (e.g. vertex groups) - it is assumed
198          * that all modifiers need mesh data and deform modifiers need vertex
199          * coordinates.
200          *
201          * Note that this limits the number of custom data layer types to 32.
202          *
203          * If this function is not present or it returns 0, it is assumed that
204          * no extra data is needed.
205          *
206          * This function is optional.
207          */
208         CustomDataMask (*requiredDataMask)(struct ModifierData *md);
209
210         /* Free internal modifier data variables, this function should
211          * not free the md variable itself.
212          *
213          * This function is optional.
214          */
215         void (*freeData)(struct ModifierData *md);
216
217         /* Return a boolean value indicating if this modifier is able to be
218          * calculated based on the modifier data. This is *not* regarding the
219          * md->flag, that is tested by the system, this is just if the data
220          * validates (for example, a lattice will return false if the lattice
221          * object is not defined).
222          *
223          * This function is optional (assumes never disabled if not present).
224          */
225         int (*isDisabled)(struct ModifierData *md);
226
227         /* Add the appropriate relations to the DEP graph depending on the
228          * modifier data. 
229          *
230          * This function is optional.
231          */
232         void (*updateDepgraph)(struct ModifierData *md, struct DagForest *forest,
233                                struct Object *ob, struct DagNode *obNode);
234
235         /* Should return true if the modifier needs to be recalculated on time
236          * changes.
237          *
238          * This function is optional (assumes false if not present).
239          */
240         int (*dependsOnTime)(struct ModifierData *md);
241
242         /* Should call the given walk function on with a pointer to each Object
243          * pointer that the modifier data stores. This is used for linking on file
244          * load and for unlinking objects or forwarding object references.
245          *
246          * This function is optional.
247          */
248         void (*foreachObjectLink)(struct ModifierData *md, struct Object *ob,
249                                   ObjectWalkFunc walk, void *userData);
250
251         /* Should call the given walk function with a pointer to each ID
252          * pointer (i.e. each datablock pointer) that the modifier data
253          * stores. This is used for linking on file load and for
254          * unlinking datablocks or forwarding datablock references.
255          *
256          * This function is optional. If it is not present, foreachObjectLink
257          * will be used.
258          */
259         void (*foreachIDLink)(struct ModifierData *md, struct Object *ob,
260                               IDWalkFunc walk, void *userData);
261 } ModifierTypeInfo;
262
263 ModifierTypeInfo *modifierType_getInfo (ModifierType type);
264
265 /* Modifier utility calls, do call through type pointer and return
266  * default values if pointer is optional.
267  */
268 struct ModifierData  *modifier_new(int type);
269 void          modifier_free(struct ModifierData *md);
270
271 void          modifier_copyData(struct ModifierData *md, struct ModifierData *target);
272 int           modifier_dependsOnTime(struct ModifierData *md);
273 int           modifier_supportsMapping(struct ModifierData *md);
274 int           modifier_couldBeCage(struct ModifierData *md);
275 int           modifier_isDeformer(struct ModifierData *md);
276 void          modifier_setError(struct ModifierData *md, char *format, ...);
277
278 void          modifiers_foreachObjectLink(struct Object *ob,
279                                           ObjectWalkFunc walk,
280                                           void *userData);
281 void          modifiers_foreachIDLink(struct Object *ob,
282                                       IDWalkFunc walk,
283                                       void *userData);
284 struct ModifierData  *modifiers_findByType(struct Object *ob, ModifierType type);
285 void          modifiers_clearErrors(struct Object *ob);
286 int           modifiers_getCageIndex(struct Object *ob,
287                                      int *lastPossibleCageIndex_r);
288
289 int           modifiers_isSoftbodyEnabled(struct Object *ob);
290 int           modifiers_isParticleEnabled(struct Object *ob);
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 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