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