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