Merge branch 'blender2.7'
[blender.git] / source / blender / blenkernel / BKE_modifier.h
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * The Original Code is: all of this file.
19  *
20  * Contributor(s): none yet.
21  *
22  * ***** END GPL LICENSE BLOCK *****
23  */
24 #ifndef __BKE_MODIFIER_H__
25 #define __BKE_MODIFIER_H__
26
27 /** \file BKE_modifier.h
28  *  \ingroup bke
29  */
30
31 #include "DNA_modifier_types.h"     /* needed for all enum typdefs */
32 #include "BLI_compiler_attrs.h"
33 #include "BKE_customdata.h"
34
35 struct ID;
36 struct Depsgraph;
37 struct DerivedMesh;
38 struct Mesh;
39 struct Object;
40 struct Scene;
41 struct ViewLayer;
42 struct ListBase;
43 struct bArmature;
44 struct Main;
45 struct ModifierData;
46 struct BMEditMesh;
47 struct DepsNodeHandle;
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
69         /* Like eModifierTypeType_Nonconstructive, but does not affect the geometry
70          * of the object, rather some of its CustomData layers.
71          * E.g. UVProject and WeightVG modifiers. */
72         eModifierTypeType_NonGeometrical,
73 } ModifierTypeType;
74
75 typedef enum {
76         eModifierTypeFlag_AcceptsMesh          = (1 << 0),
77         eModifierTypeFlag_AcceptsCVs           = (1 << 1),
78         eModifierTypeFlag_SupportsMapping      = (1 << 2),
79         eModifierTypeFlag_SupportsEditmode     = (1 << 3),
80
81         /* For modifiers that support editmode this determines if the
82          * modifier should be enabled by default in editmode. This should
83          * only be used by modifiers that are relatively speedy and
84          * also generally used in editmode, otherwise let the user enable
85          * it by hand.
86          */
87         eModifierTypeFlag_EnableInEditmode     = (1 << 4),
88
89         /* For modifiers that require original data and so cannot
90          * be placed after any non-deformative modifier.
91          */
92         eModifierTypeFlag_RequiresOriginalData = (1 << 5),
93
94         /* For modifiers that support pointcache, so we can check to see if it has files we need to deal with
95          */
96         eModifierTypeFlag_UsesPointCache = (1 << 6),
97
98         /* For physics modifiers, max one per type */
99         eModifierTypeFlag_Single = (1 << 7),
100
101         /* Some modifier can't be added manually by user */
102         eModifierTypeFlag_NoUserAdd = (1 << 8),
103
104         /* For modifiers that use CD_PREVIEW_MCOL for preview. */
105         eModifierTypeFlag_UsesPreview = (1 << 9),
106         eModifierTypeFlag_AcceptsLattice = (1 << 10),
107 } ModifierTypeFlag;
108
109 /* IMPORTANT! Keep ObjectWalkFunc and IDWalkFunc signatures compatible. */
110 typedef void (*ObjectWalkFunc)(void *userData, struct Object *ob, struct Object **obpoin, int cb_flag);
111 typedef void (*IDWalkFunc)(void *userData, struct Object *ob, struct ID **idpoin, int cb_flag);
112 typedef void (*TexWalkFunc)(void *userData, struct Object *ob, struct ModifierData *md, const char *propname);
113
114 typedef enum ModifierApplyFlag {
115         MOD_APPLY_RENDER = 1 << 0,       /* Render time. */
116         MOD_APPLY_USECACHE = 1 << 1,     /* Result of evaluation will be cached, so modifier might
117                                           * want to cache data for quick updates (used by subsurf) */
118         MOD_APPLY_ORCO = 1 << 2,         /* Modifier evaluated for undeformed texture coordinates */
119         MOD_APPLY_IGNORE_SIMPLIFY = 1 << 3, /* Ignore scene simplification flag and use subdivisions
120                                              * level set in multires modifier.
121                                              */
122 } ModifierApplyFlag;
123
124 typedef struct ModifierUpdateDepsgraphContext {
125         struct Scene *scene;
126         struct Object *object;
127         struct DepsNodeHandle *node;
128 } ModifierUpdateDepsgraphContext;
129
130 /* Contains the information for deformXXX and applyXXX functions below that
131  * doesn't change between consecutive modifiers. */
132 typedef struct ModifierEvalContext {
133         struct Depsgraph *depsgraph;
134         struct Object *object;
135         ModifierApplyFlag flag;
136 } ModifierEvalContext;
137
138
139 typedef struct ModifierTypeInfo {
140         /* The user visible name for this modifier */
141         char name[32];
142
143         /* The DNA struct name for the modifier data type, used to
144          * write the DNA data out.
145          */
146         char structName[32];
147
148         /* The size of the modifier data type, used by allocation. */
149         int structSize;
150
151         ModifierTypeType type;
152         ModifierTypeFlag flags;
153
154
155         /********************* Non-optional functions *********************/
156
157         /* Copy instance data for this modifier type. Should copy all user
158          * level settings to the target modifier.
159          *
160          * \param flag: Copying options (see BKE_library.h's LIB_ID_COPY_... flags for more).
161          */
162         void (*copyData)(const struct ModifierData *md, struct ModifierData *target, const int flag);
163
164
165         /********************* Deform modifier functions *********************/ /* DEPRECATED */
166
167         void (*deformVerts_DM_removed)(void);
168         void (*deformMatrices_DM_removed)(void);
169         void (*deformVertsEM_DM_removed)(void);
170         void (*deformMatricesEM_DM_removed)(void);
171
172         /********************* Non-deform modifier functions *********************/ /* DEPRECATED */
173
174         void (*applyModifier_DM_removed)(void);
175
176         /********************* Deform modifier functions *********************/
177
178         /* Only for deform types, should apply the deformation
179          * to the given vertex array. If the deformer requires information from
180          * the object it can obtain it from the mesh argument if non-NULL,
181          * and otherwise the ob argument.
182          */
183         void (*deformVerts)(struct ModifierData *md,  const struct ModifierEvalContext *ctx,
184                             struct Mesh *mesh, float (*vertexCos)[3], int numVerts);
185
186         /* Like deformMatricesEM but called from object mode (for supporting modifiers in sculpt mode) */
187         void (*deformMatrices)(struct ModifierData *md,  const struct ModifierEvalContext *ctx,
188                                struct Mesh *mesh, float (*vertexCos)[3], float (*defMats)[3][3], int numVerts);
189
190         /* Like deformVerts but called during editmode (for supporting modifiers)
191          */
192         void (*deformVertsEM)(struct ModifierData *md,  const struct ModifierEvalContext *ctx,
193                               struct BMEditMesh *editData,
194                               struct Mesh *mesh, float (*vertexCos)[3], int numVerts);
195
196         /* Set deform matrix per vertex for crazyspace correction */
197         void (*deformMatricesEM)(struct ModifierData *md,  const struct ModifierEvalContext *ctx,
198                                  struct BMEditMesh *editData,
199                                  struct Mesh *mesh, float (*vertexCos)[3], float (*defMats)[3][3], int numVerts);
200
201         /********************* Non-deform modifier functions *********************/
202
203         /* For non-deform types: apply the modifier and return a mesh object.
204          *
205          * The mesh argument should always be non-NULL; the modifier
206          * should read the object data from the mesh object instead of the
207          * actual object data.
208          *
209          * The modifier may reuse the mesh argument (i.e. return it in
210          * modified form), but must not release it.
211          */
212         struct Mesh *(*applyModifier)(struct ModifierData *md, const struct ModifierEvalContext *ctx,
213                                       struct Mesh *mesh);
214
215
216         /********************* Optional functions *********************/
217
218         /* Initialize new instance data for this modifier type, this function
219          * should set modifier variables to their default values.
220          *
221          * This function is optional.
222          */
223         void (*initData)(struct ModifierData *md);
224
225         /* Should return a CustomDataMask indicating what data this
226          * modifier needs. If (mask & (1 << (layer type))) != 0, this modifier
227          * needs that custom data layer. This function's return value can change
228          * depending on the modifier's settings.
229          *
230          * Note that this means extra data (e.g. vertex groups) - it is assumed
231          * that all modifiers need mesh data and deform modifiers need vertex
232          * coordinates.
233          *
234          * Note that this limits the number of custom data layer types to 32.
235          *
236          * If this function is not present or it returns 0, it is assumed that
237          * no extra data is needed.
238          *
239          * This function is optional.
240          */
241         CustomDataMask (*requiredDataMask)(struct Object *ob, struct ModifierData *md);
242
243         /* Free internal modifier data variables, this function should
244          * not free the md variable itself.
245          *
246          * This function is optional.
247          */
248         void (*freeData)(struct ModifierData *md);
249
250         /* Return a boolean value indicating if this modifier is able to be
251          * calculated based on the modifier data. This is *not* regarding the
252          * md->flag, that is tested by the system, this is just if the data
253          * validates (for example, a lattice will return false if the lattice
254          * object is not defined).
255          *
256          * This function is optional (assumes never disabled if not present).
257          */
258         bool (*isDisabled)(const struct Scene *scene, struct ModifierData *md, bool userRenderParams);
259
260         /* Add the appropriate relations to the dependency graph.
261          *
262          * This function is optional.
263          */
264         void (*updateDepsgraph)(struct ModifierData *md,
265                                 const ModifierUpdateDepsgraphContext *ctx);
266
267         /* Should return true if the modifier needs to be recalculated on time
268          * changes.
269          *
270          * This function is optional (assumes false if not present).
271          */
272         bool (*dependsOnTime)(struct ModifierData *md);
273
274
275         /* True when a deform modifier uses normals, the requiredDataMask
276          * cant be used here because that refers to a normal layer whereas
277          * in this case we need to know if the deform modifier uses normals.
278          *
279          * this is needed because applying 2 deform modifiers will give the
280          * second modifier bogus normals.
281          * */
282         bool (*dependsOnNormals)(struct ModifierData *md);
283
284
285         /* Should call the given walk function on with a pointer to each Object
286          * pointer that the modifier data stores. This is used for linking on file
287          * load and for unlinking objects or forwarding object references.
288          *
289          * This function is optional.
290          */
291         void (*foreachObjectLink)(struct ModifierData *md, struct Object *ob,
292                                   ObjectWalkFunc walk, void *userData);
293
294         /* Should call the given walk function with a pointer to each ID
295          * pointer (i.e. each datablock pointer) that the modifier data
296          * stores. This is used for linking on file load and for
297          * unlinking datablocks or forwarding datablock references.
298          *
299          * This function is optional. If it is not present, foreachObjectLink
300          * will be used.
301          */
302         void (*foreachIDLink)(struct ModifierData *md, struct Object *ob,
303                               IDWalkFunc walk, void *userData);
304
305         /* Should call the given walk function for each texture that the
306          * modifier data stores. This is used for finding all textures in
307          * the context for the UI.
308          *
309          * This function is optional. If it is not present, it will be
310          * assumed the modifier has no textures.
311          */
312         void (*foreachTexLink)(struct ModifierData *md, struct Object *ob,
313                                TexWalkFunc walk, void *userData);
314 } ModifierTypeInfo;
315
316 /* Initialize modifier's global data (type info and some common global storages). */
317 void BKE_modifier_init(void);
318
319 const ModifierTypeInfo *modifierType_getInfo(ModifierType type);
320
321 /* Modifier utility calls, do call through type pointer and return
322  * default values if pointer is optional.
323  */
324 struct ModifierData  *modifier_new(int type);
325 void          modifier_free_ex(struct ModifierData *md, const int flag);
326 void          modifier_free(struct ModifierData *md);
327
328 bool          modifier_unique_name(struct ListBase *modifiers, struct ModifierData *md);
329
330 void          modifier_copyData_generic(const struct ModifierData *md, struct ModifierData *target, const int flag);
331 void          modifier_copyData(struct ModifierData *md, struct ModifierData *target);
332 void          modifier_copyData_ex(struct ModifierData *md, struct ModifierData *target, const int flag);
333 bool          modifier_dependsOnTime(struct ModifierData *md);
334 bool          modifier_supportsMapping(struct ModifierData *md);
335 bool          modifier_supportsCage(struct Scene *scene, struct ModifierData *md);
336 bool          modifier_couldBeCage(struct Scene *scene, struct ModifierData *md);
337 bool          modifier_isCorrectableDeformed(struct ModifierData *md);
338 bool          modifier_isSameTopology(ModifierData *md);
339 bool          modifier_isNonGeometrical(ModifierData *md);
340 bool          modifier_isEnabled(const struct Scene *scene, struct ModifierData *md, int required_mode);
341 void          modifier_setError(struct ModifierData *md, const char *format, ...) ATTR_PRINTF_FORMAT(2, 3);
342 bool          modifier_isPreview(struct ModifierData *md);
343
344 void          modifiers_foreachObjectLink(struct Object *ob,
345                                           ObjectWalkFunc walk,
346                                           void *userData);
347 void          modifiers_foreachIDLink(struct Object *ob,
348                                       IDWalkFunc walk,
349                                       void *userData);
350 void          modifiers_foreachTexLink(struct Object *ob,
351                                        TexWalkFunc walk,
352                                        void *userData);
353
354 struct ModifierData  *modifiers_findByType(struct Object *ob, ModifierType type);
355 struct ModifierData  *modifiers_findByName(struct Object *ob, const char *name);
356 void          modifiers_clearErrors(struct Object *ob);
357 int           modifiers_getCageIndex(struct Scene *scene, struct Object *ob,
358                                      int *r_lastPossibleCageIndex, bool is_virtual);
359
360 bool          modifiers_isModifierEnabled(struct Object *ob, int modifierType);
361 bool          modifiers_isSoftbodyEnabled(struct Object *ob);
362 bool          modifiers_isClothEnabled(struct Object *ob);
363 bool          modifiers_isParticleEnabled(struct Object *ob);
364
365 struct Object *modifiers_isDeformedByArmature(struct Object *ob);
366 struct Object *modifiers_isDeformedByMeshDeform(struct Object *ob);
367 struct Object *modifiers_isDeformedByLattice(struct Object *ob);
368 struct Object *modifiers_isDeformedByCurve(struct Object *ob);
369 bool          modifiers_usesArmature(struct Object *ob, struct bArmature *arm);
370 bool          modifiers_isCorrectableDeformed(struct Scene *scene, struct Object *ob);
371 void          modifier_freeTemporaryData(struct ModifierData *md);
372 bool          modifiers_isPreview(struct Object *ob);
373
374 typedef struct CDMaskLink {
375         struct CDMaskLink *next;
376         CustomDataMask mask;
377 } CDMaskLink;
378
379 /* Calculates and returns a linked list of CustomDataMasks indicating the
380  * data required by each modifier in the stack pointed to by md for correct
381  * evaluation, assuming the data indicated by dataMask is required at the
382  * end of the stack.
383  */
384 struct CDMaskLink *modifiers_calcDataMasks(struct Scene *scene,
385                                            struct Object *ob,
386                                            struct ModifierData *md,
387                                            CustomDataMask dataMask,
388                                            int required_mode,
389                                            ModifierData *previewmd, CustomDataMask previewmask);
390 struct ModifierData *modifiers_getLastPreview(struct Scene *scene,
391                                               struct ModifierData *md,
392                                               int required_mode);
393
394 typedef struct VirtualModifierData {
395         ArmatureModifierData amd;
396         CurveModifierData cmd;
397         LatticeModifierData lmd;
398         ShapeKeyModifierData smd;
399 } VirtualModifierData;
400
401 struct ModifierData  *modifiers_getVirtualModifierList(struct Object *ob, struct VirtualModifierData *data);
402
403 /* ensure modifier correctness when changing ob->data */
404 void test_object_modifiers(struct Object *ob);
405
406 /* here for do_versions */
407 void modifier_mdef_compact_influences(struct ModifierData *md);
408
409 void        modifier_path_init(char *path, int path_maxlen, const char *name);
410 const char *modifier_path_relbase(struct Main *bmain, struct Object *ob);
411 const char *modifier_path_relbase_from_global(struct Object *ob);
412
413 /* wrappers for modifier callbacks that ensure valid normals */
414
415 struct Mesh *modwrap_applyModifier(
416         ModifierData *md, const struct ModifierEvalContext *ctx,
417         struct Mesh *me);
418
419 void modwrap_deformVerts(
420         ModifierData *md, const struct ModifierEvalContext *ctx,
421         struct Mesh *me,
422         float (*vertexCos)[3], int numVerts);
423
424 void modwrap_deformVertsEM(
425         ModifierData *md, const struct ModifierEvalContext *ctx,
426         struct BMEditMesh *em, struct Mesh *me,
427         float (*vertexCos)[3], int numVerts);
428
429 #define applyModifier_DM_wrapper(NEW_FUNC_NAME, OLD_FUNC_NAME) \
430         static Mesh *NEW_FUNC_NAME(ModifierData *md, const ModifierEvalContext *ctx, Mesh *mesh) \
431         { \
432                 DerivedMesh *dm = CDDM_from_mesh_ex(mesh, CD_REFERENCE, CD_MASK_EVERYTHING); \
433                 DerivedMesh *ndm = OLD_FUNC_NAME(md, ctx, dm); \
434                 if (ndm != dm) dm->release(dm); \
435                 DM_to_mesh(ndm, mesh, ctx->object, CD_MASK_EVERYTHING, true); \
436                 return mesh; \
437         }
438
439 /* wrappers for modifier callbacks that accept Mesh and select the proper implementation
440  * depending on if the modifier has been ported to Mesh or is still using DerivedMesh
441  */
442
443 struct DerivedMesh *modifier_applyModifier_DM_deprecated(
444         struct ModifierData *md, const struct ModifierEvalContext *ctx,
445         struct DerivedMesh *dm);
446
447 struct Mesh *BKE_modifier_get_evaluated_mesh_from_evaluated_object(
448         struct Object *ob_eval, bool *r_free_mesh);
449
450 #endif