Bugfix #5476
[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
129         /********************* Non-deform modifier functions *********************/
130
131         /* For non-deform types: apply the modifier and return a derived
132          * data object (type is dependent on object type).
133          *
134          * The derivedData argument should always be non-NULL; the modifier
135          * should read the object data from the derived object instead of the
136          * actual object data. 
137          *
138          * The useRenderParams argument indicates if the modifier is being
139          * applied in the service of the renderer which may alter quality
140          * settings.
141          *
142          * The isFinalCalc parameter indicates if the modifier is being
143          * calculated for a final result or for something temporary
144          * (like orcos). This is a hack at the moment, it is meant so subsurf
145          * can know if it is safe to reuse its internal cache.
146          *
147          * The modifier may reuse the derivedData argument (i.e. return it in
148          * modified form), but must not release it.
149          */
150         struct DerivedMesh *(*applyModifier)(
151                                     struct ModifierData *md, struct Object *ob,
152                                     struct DerivedMesh *derivedData,
153                                     int useRenderParams, int isFinalCalc);
154
155         /* Like applyModifier but called during editmode (for supporting
156          * modifiers).
157          * 
158          * The derived object that is returned must support the operations that
159          * are expected from editmode objects. The same qualifications regarding
160          * derivedData apply as for applyModifier.
161          */
162         struct DerivedMesh *(*applyModifierEM)(
163                                     struct ModifierData *md, struct Object *ob,
164                                     struct EditMesh *editData,
165                                     struct DerivedMesh *derivedData);
166
167
168         /********************* Optional functions *********************/
169
170         /* Initialize new instance data for this modifier type, this function
171          * should set modifier variables to their default values.
172          * 
173          * This function is optional.
174          */
175         void (*initData)(struct ModifierData *md);
176
177         /* Should return a CustomDataMask indicating what data this
178          * modifier needs. If (mask & (1 << (layer type))) != 0, this modifier
179          * needs that custom data layer. This function's return value can change
180          * depending on the modifier's settings.
181          *
182          * Note that this means extra data (e.g. vertex groups) - it is assumed
183          * that all modifiers need mesh data and deform modifiers need vertex
184          * coordinates.
185          *
186          * Note that this limits the number of custom data layer types to 32.
187          *
188          * If this function is not present or it returns 0, it is assumed that
189          * no extra data is needed.
190          *
191          * This function is optional.
192          */
193         CustomDataMask (*requiredDataMask)(struct ModifierData *md);
194
195         /* Free internal modifier data variables, this function should
196          * not free the md variable itself.
197          *
198          * This function is optional.
199          */
200         void (*freeData)(struct ModifierData *md);
201
202         /* Return a boolean value indicating if this modifier is able to be
203          * calculated based on the modifier data. This is *not* regarding the
204          * md->flag, that is tested by the system, this is just if the data
205          * validates (for example, a lattice will return false if the lattice
206          * object is not defined).
207          *
208          * This function is optional (assumes never disabled if not present).
209          */
210         int (*isDisabled)(struct ModifierData *md);
211
212         /* Add the appropriate relations to the DEP graph depending on the
213          * modifier data. 
214          *
215          * This function is optional.
216          */
217         void (*updateDepgraph)(struct ModifierData *md, struct DagForest *forest,
218                                struct Object *ob, struct DagNode *obNode);
219
220         /* Should return true if the modifier needs to be recalculated on time
221          * changes.
222          *
223          * This function is optional (assumes false if not present).
224          */
225         int (*dependsOnTime)(struct ModifierData *md);
226
227         /* Should call the given walk function on with a pointer to each Object
228          * pointer that the modifier data stores. This is used for linking on file
229          * load and for unlinking objects or forwarding object references.
230          *
231          * This function is optional.
232          */
233         void (*foreachObjectLink)(struct ModifierData *md, struct Object *ob,
234                                   ObjectWalkFunc walk, void *userData);
235
236         /* Should call the given walk function with a pointer to each ID
237          * pointer (i.e. each datablock pointer) that the modifier data
238          * stores. This is used for linking on file load and for
239          * unlinking datablocks or forwarding datablock references.
240          *
241          * This function is optional. If it is not present, foreachObjectLink
242          * will be used.
243          */
244         void (*foreachIDLink)(struct ModifierData *md, struct Object *ob,
245                               IDWalkFunc walk, void *userData);
246 } ModifierTypeInfo;
247
248 ModifierTypeInfo *modifierType_getInfo (ModifierType type);
249
250 /* Modifier utility calls, do call through type pointer and return
251  * default values if pointer is optional.
252  */
253 struct ModifierData  *modifier_new(int type);
254 void          modifier_free(struct ModifierData *md);
255
256 void          modifier_copyData(struct ModifierData *md, struct ModifierData *target);
257 int           modifier_dependsOnTime(struct ModifierData *md);
258 int           modifier_supportsMapping(struct ModifierData *md);
259 int           modifier_couldBeCage(struct ModifierData *md);
260 void          modifier_setError(struct ModifierData *md, char *format, ...);
261
262 void          modifiers_foreachObjectLink(struct Object *ob,
263                                           ObjectWalkFunc walk,
264                                           void *userData);
265 void          modifiers_foreachIDLink(struct Object *ob,
266                                       IDWalkFunc walk,
267                                       void *userData);
268 struct ModifierData  *modifiers_findByType(struct Object *ob, ModifierType type);
269 void          modifiers_clearErrors(struct Object *ob);
270 int           modifiers_getCageIndex(struct Object *ob,
271                                      int *lastPossibleCageIndex_r);
272
273 int           modifiers_isSoftbodyEnabled(struct Object *ob);
274 struct Object *modifiers_isDeformedByArmature(struct Object *ob);
275 struct Object *modifiers_isDeformedByLattice(struct Object *ob);
276 int           modifiers_usesArmature(struct Object *ob, struct bArmature *arm);
277 int           modifiers_isDeformed(struct Object *ob);
278
279 /* Calculates and returns a linked list of CustomDataMasks indicating the
280  * data required by each modifier in the stack pointed to by md for correct
281  * evaluation, assuming the data indicated by dataMask is required at the
282  * end of the stack.
283  */
284 struct LinkNode *modifiers_calcDataMasks(struct ModifierData *md,
285                                          CustomDataMask dataMask);
286 struct ModifierData  *modifiers_getVirtualModifierList(struct Object *ob);
287
288 #endif
289