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