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