Merge branch 'blender2.7'
[blender.git] / source / blender / blenkernel / BKE_DerivedMesh.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  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
17  * All rights reserved.
18  */
19
20 #ifndef __BKE_DERIVEDMESH_H__
21 #define __BKE_DERIVEDMESH_H__
22
23 /** \file
24  * \ingroup bke
25  *
26  * Basic design of the DerivedMesh system:
27  *
28  * DerivedMesh is a common set of interfaces for mesh systems.
29  *
30  * There are three main mesh data structures in Blender:
31  * #Mesh, #CDDerivedMesh and #BMesh.
32  *
33  * These, and a few others, all implement DerivedMesh interfaces,
34  * which contains unified drawing interfaces, a few utility interfaces,
35  * and a bunch of read-only interfaces intended mostly for conversion from
36  * one format to another.
37  *
38  * All Mesh structures in blender make use of CustomData, which is used to store
39  * per-element attributes and interpolate them (e.g. uvs, vcols, vgroups, etc).
40  *
41  * Mesh is the "serialized" structure, used for storing object-mode mesh data
42  * and also for saving stuff to disk.  It's interfaces are also what DerivedMesh
43  * uses to communicate with.
44  *
45  * CDDM is a little mesh library, that uses Mesh data structures in the backend.
46  * It's mostly used for modifiers, and has the advantages of not taking much
47  * resources.
48  *
49  * BMesh is a full-on brep, used for editmode, some modifiers, etc.  It's much
50  * more capable (if memory-intensive) then CDDM.
51  *
52  * DerivedMesh is somewhat hackish.  Many places assumes that a DerivedMesh is
53  * a CDDM (most of the time by simply copying it and converting it to one).
54  * CDDM is the original structure for modifiers, but has since been superseded
55  * by BMesh, at least for the foreseeable future.
56  */
57
58 /*
59  * Note: This structure is read-only, for all practical purposes.
60  *       At some point in the future, we may want to consider
61  *       creating a replacement structure that implements a proper
62  *       abstract mesh kernel interface.  Or, we can leave this
63  *       as it is and stick with using BMesh and CDDM.
64  */
65
66 #include "DNA_defs.h"
67 #include "DNA_customdata_types.h"
68 #include "DNA_meshdata_types.h"
69
70 #include "BLI_compiler_attrs.h"
71
72 #include "BKE_customdata.h"
73 #include "BKE_bvhutils.h"
74
75 struct BMEditMesh;
76 struct CCGElem;
77 struct CCGKey;
78 struct CustomData_MeshMasks;
79 struct Depsgraph;
80 struct MEdge;
81 struct MFace;
82 struct MLoopNorSpaceArray;
83 struct MVert;
84 struct Mesh;
85 struct ModifierData;
86 struct Object;
87 struct PBVH;
88 struct Scene;
89
90 /*
91  * Note: all mface interfaces now officially operate on tessellated data.
92  *       Also, the mface origindex layer indexes mpolys, not mfaces.
93  */
94
95 /* keep in sync with MFace/MPoly types */
96 typedef struct DMFlagMat {
97         short mat_nr;
98         char flag;
99 } DMFlagMat;
100
101 typedef enum DerivedMeshType {
102         DM_TYPE_CDDM,
103         DM_TYPE_CCGDM
104 } DerivedMeshType;
105
106 typedef enum DMForeachFlag {
107         DM_FOREACH_NOP = 0,
108         DM_FOREACH_USE_NORMAL = (1 << 0),  /* foreachMappedVert, foreachMappedLoop, foreachMappedFaceCenter */
109 } DMForeachFlag;
110
111 typedef enum DMDirtyFlag {
112         /* dm has valid tessellated faces, but tessellated CDDATA need to be updated. */
113         DM_DIRTY_TESS_CDLAYERS = 1 << 0,
114
115         /* check this with modifier dependsOnNormals callback to see if normals need recalculation */
116         DM_DIRTY_NORMALS = 1 << 1,
117 }  DMDirtyFlag;
118
119 typedef struct DerivedMesh DerivedMesh;
120 struct DerivedMesh {
121         /** Private DerivedMesh data, only for internal DerivedMesh use */
122         CustomData vertData, edgeData, faceData, loopData, polyData;
123         int numVertData, numEdgeData, numTessFaceData, numLoopData, numPolyData;
124         int needsFree; /* checked on ->release, is set to 0 for cached results */
125         int deformedOnly; /* set by modifier stack if only deformed from original */
126         BVHCache *bvhCache;
127         DerivedMeshType type;
128         DMDirtyFlag dirty;
129         int totmat; /* total materials. Will be valid only before object drawing. */
130         struct Material **mat; /* material array. Will be valid only before object drawing */
131
132         /**
133          * \warning Typical access is done via #getLoopTriArray, #getNumLoopTri.
134          */
135         struct {
136                 /* WARNING! swapping between array (ready-to-be-used data) and array_wip (where data is actually computed)
137                  *          shall always be protected by same lock as one used for looptris computing. */
138                 struct MLoopTri *array, *array_wip;
139                 int num;
140                 int num_alloc;
141         } looptris;
142
143         /* use for converting to BMesh which doesn't store bevel weight and edge crease by default */
144         char cd_flag;
145
146         short tangent_mask; /* which tangent layers are calculated */
147
148         /** Calculate vert and face normals */
149         void (*calcNormals)(DerivedMesh *dm);
150
151         /** Calculate loop (split) normals */
152         void (*calcLoopNormals)(DerivedMesh *dm, const bool use_split_normals, const float split_angle);
153
154         /** Calculate loop (split) normals, and returns split loop normal spacearr. */
155         void (*calcLoopNormalsSpaceArray)(DerivedMesh *dm, const bool use_split_normals, const float split_angle,
156                                           struct MLoopNorSpaceArray *r_lnors_spacearr);
157
158         void (*calcLoopTangents)(
159                 DerivedMesh *dm, bool calc_active_tangent,
160                 const char (*tangent_names)[MAX_NAME], int tangent_names_count);
161
162         /** Recalculates mesh tessellation */
163         void (*recalcTessellation)(DerivedMesh *dm);
164
165         /** Loop tessellation cache (WARNING! Only call inside threading-protected code!) */
166         void (*recalcLoopTri)(DerivedMesh *dm);
167         /** accessor functions */
168         const struct MLoopTri *(*getLoopTriArray)(DerivedMesh * dm);
169         int (*getNumLoopTri)(DerivedMesh *dm);
170
171         /* Misc. Queries */
172
173         /* Also called in Editmode */
174         int (*getNumVerts)(DerivedMesh *dm);
175         int (*getNumEdges)(DerivedMesh *dm);
176         int (*getNumTessFaces)(DerivedMesh *dm);
177         int (*getNumLoops)(DerivedMesh *dm);
178         int (*getNumPolys)(DerivedMesh *dm);
179
180         /** Copy a single vert/edge/tessellated face from the derived mesh into
181          * ``*r_{vert/edge/face}``. note that the current implementation
182          * of this function can be quite slow, iterating over all
183          * elements (editmesh)
184          */
185         void (*getVert)(DerivedMesh *dm, int index, struct MVert *r_vert);
186         void (*getEdge)(DerivedMesh *dm, int index, struct MEdge *r_edge);
187         void (*getTessFace)(DerivedMesh *dm, int index, struct MFace *r_face);
188
189         /** Return a pointer to the entire array of verts/edges/face from the
190          * derived mesh. if such an array does not exist yet, it will be created,
191          * and freed on the next ->release(). consider using getVert/Edge/Face if
192          * you are only interested in a few verts/edges/faces.
193          */
194         struct MVert *(*getVertArray)(DerivedMesh * dm);
195         struct MEdge *(*getEdgeArray)(DerivedMesh * dm);
196         struct MFace *(*getTessFaceArray)(DerivedMesh * dm);
197         struct MLoop *(*getLoopArray)(DerivedMesh * dm);
198         struct MPoly *(*getPolyArray)(DerivedMesh * dm);
199
200         /** Copy all verts/edges/faces from the derived mesh into
201          * *{vert/edge/face}_r (must point to a buffer large enough)
202          */
203         void (*copyVertArray)(DerivedMesh *dm, struct MVert *r_vert);
204         void (*copyEdgeArray)(DerivedMesh *dm, struct MEdge *r_edge);
205         void (*copyTessFaceArray)(DerivedMesh *dm, struct MFace *r_face);
206         void (*copyLoopArray)(DerivedMesh *dm, struct MLoop *r_loop);
207         void (*copyPolyArray)(DerivedMesh *dm, struct MPoly *r_poly);
208
209         /** Return a copy of all verts/edges/faces from the derived mesh
210          * it is the caller's responsibility to free the returned pointer
211          */
212         struct MVert *(*dupVertArray)(DerivedMesh * dm);
213         struct MEdge *(*dupEdgeArray)(DerivedMesh * dm);
214         struct MFace *(*dupTessFaceArray)(DerivedMesh * dm);
215         struct MLoop *(*dupLoopArray)(DerivedMesh * dm);
216         struct MPoly *(*dupPolyArray)(DerivedMesh * dm);
217
218         /** Return a pointer to a single element of vert/edge/face custom data
219          * from the derived mesh (this gives a pointer to the actual data, not
220          * a copy)
221          */
222         void *(*getVertData)(DerivedMesh *dm, int index, int type);
223         void *(*getEdgeData)(DerivedMesh *dm, int index, int type);
224         void *(*getTessFaceData)(DerivedMesh *dm, int index, int type);
225         void *(*getPolyData)(DerivedMesh *dm, int index, int type);
226
227         /** Return a pointer to the entire array of vert/edge/face custom data
228          * from the derived mesh (this gives a pointer to the actual data, not
229          * a copy)
230          */
231         void *(*getVertDataArray)(DerivedMesh *dm, int type);
232         void *(*getEdgeDataArray)(DerivedMesh *dm, int type);
233         void *(*getTessFaceDataArray)(DerivedMesh *dm, int type);
234         void *(*getLoopDataArray)(DerivedMesh *dm, int type);
235         void *(*getPolyDataArray)(DerivedMesh *dm, int type);
236
237         /** Retrieves the base CustomData structures for
238          * verts/edges/tessfaces/loops/facdes*/
239         CustomData *(*getVertDataLayout)(DerivedMesh * dm);
240         CustomData *(*getEdgeDataLayout)(DerivedMesh * dm);
241         CustomData *(*getTessFaceDataLayout)(DerivedMesh * dm);
242         CustomData *(*getLoopDataLayout)(DerivedMesh * dm);
243         CustomData *(*getPolyDataLayout)(DerivedMesh * dm);
244
245         /** Copies all customdata for an element source into dst at index dest */
246         void (*copyFromVertCData)(DerivedMesh *dm, int source, CustomData *dst, int dest);
247         void (*copyFromEdgeCData)(DerivedMesh *dm, int source, CustomData *dst, int dest);
248         void (*copyFromFaceCData)(DerivedMesh *dm, int source, CustomData *dst, int dest);
249
250         /** Optional grid access for subsurf */
251         int (*getNumGrids)(DerivedMesh *dm);
252         int (*getGridSize)(DerivedMesh *dm);
253         struct CCGElem **(*getGridData)(DerivedMesh * dm);
254         int *(*getGridOffset)(DerivedMesh * dm);
255         void (*getGridKey)(DerivedMesh *dm, struct CCGKey *key);
256         DMFlagMat *(*getGridFlagMats)(DerivedMesh * dm);
257         unsigned int **(*getGridHidden)(DerivedMesh * dm);
258
259
260         /** Iterate over each mapped vertex in the derived mesh, calling the
261          * given function with the original vert and the mapped vert's new
262          * coordinate and normal. For historical reasons the normal can be
263          * passed as a float or short array, only one should be non-NULL.
264          */
265         void (*foreachMappedVert)(DerivedMesh *dm,
266                                   void (*func)(void *userData, int index, const float co[3],
267                                                const float no_f[3], const short no_s[3]),
268                                   void *userData,
269                                   DMForeachFlag flag);
270
271         /** Iterate over each mapped edge in the derived mesh, calling the
272          * given function with the original edge and the mapped edge's new
273          * coordinates.
274          */
275         void (*foreachMappedEdge)(DerivedMesh *dm,
276                                   void (*func)(void *userData, int index,
277                                                const float v0co[3], const float v1co[3]),
278                                   void *userData);
279
280         /** Iterate over each mapped loop in the derived mesh, calling the given function
281          * with the original loop index and the mapped loops's new coordinate and normal.
282          */
283         void (*foreachMappedLoop)(DerivedMesh *dm,
284                                   void (*func)(void *userData, int vertex_index, int face_index,
285                                                const float co[3], const float no[3]),
286                                   void *userData,
287                                   DMForeachFlag flag);
288
289         /** Iterate over each mapped face in the derived mesh, calling the
290          * given function with the original face and the mapped face's (or
291          * faces') center and normal.
292          */
293         void (*foreachMappedFaceCenter)(DerivedMesh *dm,
294                                         void (*func)(void *userData, int index,
295                                                      const float cent[3], const float no[3]),
296                                         void *userData,
297                                         DMForeachFlag flag);
298
299         /** Iterate over all vertex points, calling DO_MINMAX with given args.
300          *
301          * Also called in Editmode
302          */
303         void (*getMinMax)(DerivedMesh *dm, float r_min[3], float r_max[3]);
304
305         /** Direct Access Operations
306          * - Can be undefined
307          * - Must be defined for modifiers that only deform however */
308
309         /** Get vertex location, undefined if index is not valid */
310         void (*getVertCo)(DerivedMesh *dm, int index, float r_co[3]);
311
312         /** Fill the array (of length .getNumVerts()) with all vertex locations */
313         void (*getVertCos)(DerivedMesh *dm, float (*r_cos)[3]);
314
315         /** Get smooth vertex normal, undefined if index is not valid */
316         void (*getVertNo)(DerivedMesh *dm, int index, float r_no[3]);
317         void (*getPolyNo)(DerivedMesh *dm, int index, float r_no[3]);
318
319         /** Get a map of vertices to faces
320          */
321         const struct MeshElemMap *(*getPolyMap)(struct Object *ob, DerivedMesh *dm);
322
323         /** Get the BVH used for paint modes
324          */
325         struct PBVH *(*getPBVH)(struct Object *ob, DerivedMesh *dm);
326
327         /** Release reference to the DerivedMesh. This function decides internally
328          * if the DerivedMesh will be freed, or cached for later use. */
329         void (*release)(DerivedMesh *dm);
330 };
331
332 void DM_init_funcs(DerivedMesh *dm);
333
334 void DM_init(
335         DerivedMesh *dm, DerivedMeshType type, int numVerts, int numEdges,
336         int numFaces, int numLoops, int numPolys);
337
338 void DM_from_template_ex(
339         DerivedMesh *dm, DerivedMesh *source, DerivedMeshType type,
340         int numVerts, int numEdges, int numTessFaces,
341         int numLoops, int numPolys,
342         const struct CustomData_MeshMasks *mask);
343 void DM_from_template(
344         DerivedMesh *dm, DerivedMesh *source,
345         DerivedMeshType type,
346         int numVerts, int numEdges, int numFaces,
347         int numLoops, int numPolys);
348
349 /** utility function to release a DerivedMesh's layers
350  * returns 1 if DerivedMesh has to be released by the backend, 0 otherwise
351  */
352 int DM_release(DerivedMesh *dm);
353
354 /** utility function to convert a DerivedMesh to a Mesh
355  */
356 void DM_to_mesh(DerivedMesh *dm, struct Mesh *me, struct Object *ob,
357                 const struct CustomData_MeshMasks *mask, bool take_ownership);
358
359
360 void DM_set_only_copy(DerivedMesh *dm, const struct CustomData_MeshMasks *mask);
361
362 /* adds a vertex/edge/face custom data layer to a DerivedMesh, optionally
363  * backed by an external data array
364  * alloctype defines how the layer is allocated or copied, and how it is
365  * freed, see BKE_customdata.h for the different options
366  */
367 void DM_add_vert_layer(
368         struct DerivedMesh *dm, int type, eCDAllocType alloctype,
369         void *layer);
370 void DM_add_edge_layer(
371         struct DerivedMesh *dm, int type, eCDAllocType alloctype,
372         void *layer);
373 void DM_add_tessface_layer(
374         struct DerivedMesh *dm, int type, eCDAllocType alloctype,
375         void *layer);
376 void DM_add_loop_layer(
377         DerivedMesh *dm, int type, eCDAllocType alloctype,
378         void *layer);
379 void DM_add_poly_layer(
380         struct DerivedMesh *dm, int type, eCDAllocType alloctype,
381         void *layer);
382
383 /* custom data access functions
384  * return pointer to data from first layer which matches type
385  * if they return NULL for valid indices, data doesn't exist
386  * note these return pointers - any change modifies the internals of the mesh
387  */
388 void *DM_get_vert_data(struct DerivedMesh *dm, int index, int type);
389 void *DM_get_edge_data(struct DerivedMesh *dm, int index, int type);
390 void *DM_get_tessface_data(struct DerivedMesh *dm, int index, int type);
391 void *DM_get_poly_data(struct DerivedMesh *dm, int index, int type);
392
393 /* custom data layer access functions
394  * return pointer to first data layer which matches type (a flat array)
395  * if they return NULL, data doesn't exist
396  * note these return pointers - any change modifies the internals of the mesh
397  */
398 void *DM_get_vert_data_layer(struct DerivedMesh *dm, int type);
399 void *DM_get_edge_data_layer(struct DerivedMesh *dm, int type);
400 void *DM_get_tessface_data_layer(struct DerivedMesh *dm, int type);
401 void *DM_get_poly_data_layer(struct DerivedMesh *dm, int type);
402 void *DM_get_loop_data_layer(struct DerivedMesh *dm, int type);
403
404 /* custom data copy functions
405  * copy count elements from source_index in source to dest_index in dest
406  * these copy all layers for which the CD_FLAG_NOCOPY flag is not set
407  */
408 void DM_copy_vert_data(
409         struct DerivedMesh *source, struct DerivedMesh *dest,
410         int source_index, int dest_index, int count);
411
412 /*sets up mpolys for a DM based on face iterators in source*/
413 void DM_DupPolys(DerivedMesh *source, DerivedMesh *target);
414
415 void DM_ensure_normals(DerivedMesh *dm);
416
417 void DM_ensure_looptri_data(DerivedMesh *dm);
418
419 void DM_interp_vert_data(
420         struct DerivedMesh *source, struct DerivedMesh *dest,
421         int *src_indices, float *weights,
422         int count, int dest_index);
423
424 void mesh_get_mapped_verts_coords(struct Mesh *me_eval, float (*r_cos)[3], const int totcos);
425
426 DerivedMesh *mesh_create_derived_render(
427         struct Depsgraph *depsgraph, struct Scene *scene,
428         struct Object *ob, const struct CustomData_MeshMasks *dataMask);
429
430 /* same as above but wont use render settings */
431 DerivedMesh *mesh_create_derived(struct Mesh *me, float (*vertCos)[3]);
432
433 struct Mesh *editbmesh_get_eval_cage(
434         struct Depsgraph *depsgraph, struct Scene *scene, struct Object *,
435         struct BMEditMesh *em, const struct CustomData_MeshMasks *dataMask);
436 struct Mesh *editbmesh_get_eval_cage_from_orig(
437         struct Depsgraph *depsgraph, struct Scene *scene, struct Object *,
438         struct BMEditMesh *em, const struct CustomData_MeshMasks *dataMask);
439 struct Mesh *editbmesh_get_eval_cage_and_final(
440         struct Depsgraph *depsgraph, struct Scene *scene, struct Object *,
441         struct BMEditMesh *em, const struct CustomData_MeshMasks *dataMask,
442         struct Mesh **r_final);
443
444 float (*editbmesh_get_vertex_cos(struct BMEditMesh *em, int *r_numVerts))[3];
445 bool editbmesh_modifier_is_enabled(struct Scene *scene, struct ModifierData *md, bool has_prev_mesh);
446 void makeDerivedMesh(
447         struct Depsgraph *depsgraph, struct Scene *scene, struct Object *ob, struct BMEditMesh *em,
448         const struct CustomData_MeshMasks *dataMask);
449
450 void DM_calc_loop_tangents(
451         DerivedMesh *dm, bool calc_active_tangent, const char (*tangent_names)[MAX_NAME],
452         int tangent_names_count);
453
454 /* debug only */
455 #ifndef NDEBUG
456 char *DM_debug_info(DerivedMesh *dm);
457 void DM_debug_print(DerivedMesh *dm);
458 void DM_debug_print_cdlayers(CustomData *cdata);
459
460 bool DM_is_valid(DerivedMesh *dm);
461 #endif
462
463 #endif  /* __BKE_DERIVEDMESH_H__ */