ClangFormat: apply to source, most of intern
[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 =
109       (1 << 0), /* foreachMappedVert, foreachMappedLoop, foreachMappedFaceCenter */
110 } DMForeachFlag;
111
112 typedef enum DMDirtyFlag {
113   /* dm has valid tessellated faces, but tessellated CDDATA need to be updated. */
114   DM_DIRTY_TESS_CDLAYERS = 1 << 0,
115
116   /* check this with modifier dependsOnNormals callback to see if normals need recalculation */
117   DM_DIRTY_NORMALS = 1 << 1,
118 } DMDirtyFlag;
119
120 typedef struct DerivedMesh DerivedMesh;
121 struct DerivedMesh {
122   /** Private DerivedMesh data, only for internal DerivedMesh use */
123   CustomData vertData, edgeData, faceData, loopData, polyData;
124   int numVertData, numEdgeData, numTessFaceData, numLoopData, numPolyData;
125   int needsFree;    /* checked on ->release, is set to 0 for cached results */
126   int deformedOnly; /* set by modifier stack if only deformed from original */
127   BVHCache *bvhCache;
128   DerivedMeshType type;
129   DMDirtyFlag dirty;
130   int totmat;            /* total materials. Will be valid only before object drawing. */
131   struct Material **mat; /* material array. Will be valid only before object drawing */
132
133   /**
134    * \warning Typical access is done via #getLoopTriArray, #getNumLoopTri.
135    */
136   struct {
137     /* WARNING! swapping between array (ready-to-be-used data) and array_wip (where data is actually computed)
138      *          shall always be protected by same lock as one used for looptris computing. */
139     struct MLoopTri *array, *array_wip;
140     int num;
141     int num_alloc;
142   } looptris;
143
144   /* use for converting to BMesh which doesn't store bevel weight and edge crease by default */
145   char cd_flag;
146
147   short tangent_mask; /* which tangent layers are calculated */
148
149   /** Calculate vert and face normals */
150   void (*calcNormals)(DerivedMesh *dm);
151
152   /** Calculate loop (split) normals */
153   void (*calcLoopNormals)(DerivedMesh *dm, const bool use_split_normals, const float split_angle);
154
155   /** Calculate loop (split) normals, and returns split loop normal spacearr. */
156   void (*calcLoopNormalsSpaceArray)(DerivedMesh *dm,
157                                     const bool use_split_normals,
158                                     const float split_angle,
159                                     struct MLoopNorSpaceArray *r_lnors_spacearr);
160
161   void (*calcLoopTangents)(DerivedMesh *dm,
162                            bool calc_active_tangent,
163                            const char (*tangent_names)[MAX_NAME],
164                            int tangent_names_count);
165
166   /** Recalculates mesh tessellation */
167   void (*recalcTessellation)(DerivedMesh *dm);
168
169   /** Loop tessellation cache (WARNING! Only call inside threading-protected code!) */
170   void (*recalcLoopTri)(DerivedMesh *dm);
171   /** accessor functions */
172   const struct MLoopTri *(*getLoopTriArray)(DerivedMesh *dm);
173   int (*getNumLoopTri)(DerivedMesh *dm);
174
175   /* Misc. Queries */
176
177   /* Also called in Editmode */
178   int (*getNumVerts)(DerivedMesh *dm);
179   int (*getNumEdges)(DerivedMesh *dm);
180   int (*getNumTessFaces)(DerivedMesh *dm);
181   int (*getNumLoops)(DerivedMesh *dm);
182   int (*getNumPolys)(DerivedMesh *dm);
183
184   /** Copy a single vert/edge/tessellated face from the derived mesh into
185    * ``*r_{vert/edge/face}``. note that the current implementation
186    * of this function can be quite slow, iterating over all
187    * elements (editmesh)
188    */
189   void (*getVert)(DerivedMesh *dm, int index, struct MVert *r_vert);
190   void (*getEdge)(DerivedMesh *dm, int index, struct MEdge *r_edge);
191   void (*getTessFace)(DerivedMesh *dm, int index, struct MFace *r_face);
192
193   /** Return a pointer to the entire array of verts/edges/face from the
194    * derived mesh. if such an array does not exist yet, it will be created,
195    * and freed on the next ->release(). consider using getVert/Edge/Face if
196    * you are only interested in a few verts/edges/faces.
197    */
198   struct MVert *(*getVertArray)(DerivedMesh *dm);
199   struct MEdge *(*getEdgeArray)(DerivedMesh *dm);
200   struct MFace *(*getTessFaceArray)(DerivedMesh *dm);
201   struct MLoop *(*getLoopArray)(DerivedMesh *dm);
202   struct MPoly *(*getPolyArray)(DerivedMesh *dm);
203
204   /** Copy all verts/edges/faces from the derived mesh into
205    * *{vert/edge/face}_r (must point to a buffer large enough)
206    */
207   void (*copyVertArray)(DerivedMesh *dm, struct MVert *r_vert);
208   void (*copyEdgeArray)(DerivedMesh *dm, struct MEdge *r_edge);
209   void (*copyTessFaceArray)(DerivedMesh *dm, struct MFace *r_face);
210   void (*copyLoopArray)(DerivedMesh *dm, struct MLoop *r_loop);
211   void (*copyPolyArray)(DerivedMesh *dm, struct MPoly *r_poly);
212
213   /** Return a copy of all verts/edges/faces from the derived mesh
214    * it is the caller's responsibility to free the returned pointer
215    */
216   struct MVert *(*dupVertArray)(DerivedMesh *dm);
217   struct MEdge *(*dupEdgeArray)(DerivedMesh *dm);
218   struct MFace *(*dupTessFaceArray)(DerivedMesh *dm);
219   struct MLoop *(*dupLoopArray)(DerivedMesh *dm);
220   struct MPoly *(*dupPolyArray)(DerivedMesh *dm);
221
222   /** Return a pointer to a single element of vert/edge/face custom data
223    * from the derived mesh (this gives a pointer to the actual data, not
224    * a copy)
225    */
226   void *(*getVertData)(DerivedMesh *dm, int index, int type);
227   void *(*getEdgeData)(DerivedMesh *dm, int index, int type);
228   void *(*getTessFaceData)(DerivedMesh *dm, int index, int type);
229   void *(*getPolyData)(DerivedMesh *dm, int index, int type);
230
231   /** Return a pointer to the entire array of vert/edge/face custom data
232    * from the derived mesh (this gives a pointer to the actual data, not
233    * a copy)
234    */
235   void *(*getVertDataArray)(DerivedMesh *dm, int type);
236   void *(*getEdgeDataArray)(DerivedMesh *dm, int type);
237   void *(*getTessFaceDataArray)(DerivedMesh *dm, int type);
238   void *(*getLoopDataArray)(DerivedMesh *dm, int type);
239   void *(*getPolyDataArray)(DerivedMesh *dm, int type);
240
241   /** Retrieves the base CustomData structures for
242    * verts/edges/tessfaces/loops/facdes*/
243   CustomData *(*getVertDataLayout)(DerivedMesh *dm);
244   CustomData *(*getEdgeDataLayout)(DerivedMesh *dm);
245   CustomData *(*getTessFaceDataLayout)(DerivedMesh *dm);
246   CustomData *(*getLoopDataLayout)(DerivedMesh *dm);
247   CustomData *(*getPolyDataLayout)(DerivedMesh *dm);
248
249   /** Copies all customdata for an element source into dst at index dest */
250   void (*copyFromVertCData)(DerivedMesh *dm, int source, CustomData *dst, int dest);
251   void (*copyFromEdgeCData)(DerivedMesh *dm, int source, CustomData *dst, int dest);
252   void (*copyFromFaceCData)(DerivedMesh *dm, int source, CustomData *dst, int dest);
253
254   /** Optional grid access for subsurf */
255   int (*getNumGrids)(DerivedMesh *dm);
256   int (*getGridSize)(DerivedMesh *dm);
257   struct CCGElem **(*getGridData)(DerivedMesh *dm);
258   int *(*getGridOffset)(DerivedMesh *dm);
259   void (*getGridKey)(DerivedMesh *dm, struct CCGKey *key);
260   DMFlagMat *(*getGridFlagMats)(DerivedMesh *dm);
261   unsigned int **(*getGridHidden)(DerivedMesh *dm);
262
263   /** Iterate over each mapped vertex in the derived mesh, calling the
264    * given function with the original vert and the mapped vert's new
265    * coordinate and normal. For historical reasons the normal can be
266    * passed as a float or short array, only one should be non-NULL.
267    */
268   void (*foreachMappedVert)(DerivedMesh *dm,
269                             void (*func)(void *userData,
270                                          int index,
271                                          const float co[3],
272                                          const float no_f[3],
273                                          const short no_s[3]),
274                             void *userData,
275                             DMForeachFlag flag);
276
277   /** Iterate over each mapped edge in the derived mesh, calling the
278    * given function with the original edge and the mapped edge's new
279    * coordinates.
280    */
281   void (*foreachMappedEdge)(
282       DerivedMesh *dm,
283       void (*func)(void *userData, int index, const float v0co[3], const float v1co[3]),
284       void *userData);
285
286   /** Iterate over each mapped loop in the derived mesh, calling the given function
287    * with the original loop index and the mapped loops's new coordinate and normal.
288    */
289   void (*foreachMappedLoop)(DerivedMesh *dm,
290                             void (*func)(void *userData,
291                                          int vertex_index,
292                                          int face_index,
293                                          const float co[3],
294                                          const float no[3]),
295                             void *userData,
296                             DMForeachFlag flag);
297
298   /** Iterate over each mapped face in the derived mesh, calling the
299    * given function with the original face and the mapped face's (or
300    * faces') center and normal.
301    */
302   void (*foreachMappedFaceCenter)(
303       DerivedMesh *dm,
304       void (*func)(void *userData, int index, const float cent[3], const float no[3]),
305       void *userData,
306       DMForeachFlag flag);
307
308   /** Iterate over all vertex points, calling DO_MINMAX with given args.
309    *
310    * Also called in Editmode
311    */
312   void (*getMinMax)(DerivedMesh *dm, float r_min[3], float r_max[3]);
313
314   /** Direct Access Operations
315    * - Can be undefined
316    * - Must be defined for modifiers that only deform however */
317
318   /** Get vertex location, undefined if index is not valid */
319   void (*getVertCo)(DerivedMesh *dm, int index, float r_co[3]);
320
321   /** Fill the array (of length .getNumVerts()) with all vertex locations */
322   void (*getVertCos)(DerivedMesh *dm, float (*r_cos)[3]);
323
324   /** Get smooth vertex normal, undefined if index is not valid */
325   void (*getVertNo)(DerivedMesh *dm, int index, float r_no[3]);
326   void (*getPolyNo)(DerivedMesh *dm, int index, float r_no[3]);
327
328   /** Get a map of vertices to faces
329    */
330   const struct MeshElemMap *(*getPolyMap)(struct Object *ob, DerivedMesh *dm);
331
332   /** Get the BVH used for paint modes
333    */
334   struct PBVH *(*getPBVH)(struct Object *ob, DerivedMesh *dm);
335
336   /** Release reference to the DerivedMesh. This function decides internally
337    * if the DerivedMesh will be freed, or cached for later use. */
338   void (*release)(DerivedMesh *dm);
339 };
340
341 void DM_init_funcs(DerivedMesh *dm);
342
343 void DM_init(DerivedMesh *dm,
344              DerivedMeshType type,
345              int numVerts,
346              int numEdges,
347              int numFaces,
348              int numLoops,
349              int numPolys);
350
351 void DM_from_template_ex(DerivedMesh *dm,
352                          DerivedMesh *source,
353                          DerivedMeshType type,
354                          int numVerts,
355                          int numEdges,
356                          int numTessFaces,
357                          int numLoops,
358                          int numPolys,
359                          const struct CustomData_MeshMasks *mask);
360 void DM_from_template(DerivedMesh *dm,
361                       DerivedMesh *source,
362                       DerivedMeshType type,
363                       int numVerts,
364                       int numEdges,
365                       int numFaces,
366                       int numLoops,
367                       int numPolys);
368
369 /** utility function to release a DerivedMesh's layers
370  * returns 1 if DerivedMesh has to be released by the backend, 0 otherwise
371  */
372 int DM_release(DerivedMesh *dm);
373
374 /** utility function to convert a DerivedMesh to a Mesh
375  */
376 void DM_to_mesh(DerivedMesh *dm,
377                 struct Mesh *me,
378                 struct Object *ob,
379                 const struct CustomData_MeshMasks *mask,
380                 bool take_ownership);
381
382 void DM_set_only_copy(DerivedMesh *dm, const struct CustomData_MeshMasks *mask);
383
384 /* adds a vertex/edge/face custom data layer to a DerivedMesh, optionally
385  * backed by an external data array
386  * alloctype defines how the layer is allocated or copied, and how it is
387  * freed, see BKE_customdata.h for the different options
388  */
389 void DM_add_vert_layer(struct DerivedMesh *dm, int type, eCDAllocType alloctype, void *layer);
390 void DM_add_edge_layer(struct DerivedMesh *dm, int type, eCDAllocType alloctype, void *layer);
391 void DM_add_tessface_layer(struct DerivedMesh *dm, int type, eCDAllocType alloctype, void *layer);
392 void DM_add_loop_layer(DerivedMesh *dm, int type, eCDAllocType alloctype, void *layer);
393 void DM_add_poly_layer(struct DerivedMesh *dm, int type, eCDAllocType alloctype, void *layer);
394
395 /* custom data access functions
396  * return pointer to data from first layer which matches type
397  * if they return NULL for valid indices, data doesn't exist
398  * note these return pointers - any change modifies the internals of the mesh
399  */
400 void *DM_get_vert_data(struct DerivedMesh *dm, int index, int type);
401 void *DM_get_edge_data(struct DerivedMesh *dm, int index, int type);
402 void *DM_get_tessface_data(struct DerivedMesh *dm, int index, int type);
403 void *DM_get_poly_data(struct DerivedMesh *dm, int index, int type);
404
405 /* custom data layer access functions
406  * return pointer to first data layer which matches type (a flat array)
407  * if they return NULL, data doesn't exist
408  * note these return pointers - any change modifies the internals of the mesh
409  */
410 void *DM_get_vert_data_layer(struct DerivedMesh *dm, int type);
411 void *DM_get_edge_data_layer(struct DerivedMesh *dm, int type);
412 void *DM_get_tessface_data_layer(struct DerivedMesh *dm, int type);
413 void *DM_get_poly_data_layer(struct DerivedMesh *dm, int type);
414 void *DM_get_loop_data_layer(struct DerivedMesh *dm, int type);
415
416 /* custom data copy functions
417  * copy count elements from source_index in source to dest_index in dest
418  * these copy all layers for which the CD_FLAG_NOCOPY flag is not set
419  */
420 void DM_copy_vert_data(struct DerivedMesh *source,
421                        struct DerivedMesh *dest,
422                        int source_index,
423                        int dest_index,
424                        int count);
425
426 /*sets up mpolys for a DM based on face iterators in source*/
427 void DM_DupPolys(DerivedMesh *source, DerivedMesh *target);
428
429 void DM_ensure_normals(DerivedMesh *dm);
430
431 void DM_ensure_looptri_data(DerivedMesh *dm);
432
433 void DM_interp_vert_data(struct DerivedMesh *source,
434                          struct DerivedMesh *dest,
435                          int *src_indices,
436                          float *weights,
437                          int count,
438                          int dest_index);
439
440 void mesh_get_mapped_verts_coords(struct Mesh *me_eval, float (*r_cos)[3], const int totcos);
441
442 DerivedMesh *mesh_create_derived_render(struct Depsgraph *depsgraph,
443                                         struct Scene *scene,
444                                         struct Object *ob,
445                                         const struct CustomData_MeshMasks *dataMask);
446
447 /* same as above but wont use render settings */
448 DerivedMesh *mesh_create_derived(struct Mesh *me, float (*vertCos)[3]);
449
450 struct Mesh *editbmesh_get_eval_cage(struct Depsgraph *depsgraph,
451                                      struct Scene *scene,
452                                      struct Object *,
453                                      struct BMEditMesh *em,
454                                      const struct CustomData_MeshMasks *dataMask);
455 struct Mesh *editbmesh_get_eval_cage_from_orig(struct Depsgraph *depsgraph,
456                                                struct Scene *scene,
457                                                struct Object *,
458                                                struct BMEditMesh *em,
459                                                const struct CustomData_MeshMasks *dataMask);
460 struct Mesh *editbmesh_get_eval_cage_and_final(struct Depsgraph *depsgraph,
461                                                struct Scene *scene,
462                                                struct Object *,
463                                                struct BMEditMesh *em,
464                                                const struct CustomData_MeshMasks *dataMask,
465                                                struct Mesh **r_final);
466
467 float (*editbmesh_get_vertex_cos(struct BMEditMesh *em, int *r_numVerts))[3];
468 bool editbmesh_modifier_is_enabled(struct Scene *scene,
469                                    struct ModifierData *md,
470                                    bool has_prev_mesh);
471 void makeDerivedMesh(struct Depsgraph *depsgraph,
472                      struct Scene *scene,
473                      struct Object *ob,
474                      struct BMEditMesh *em,
475                      const struct CustomData_MeshMasks *dataMask);
476
477 void DM_calc_loop_tangents(DerivedMesh *dm,
478                            bool calc_active_tangent,
479                            const char (*tangent_names)[MAX_NAME],
480                            int tangent_names_count);
481
482 /* debug only */
483 #ifndef NDEBUG
484 char *DM_debug_info(DerivedMesh *dm);
485 void DM_debug_print(DerivedMesh *dm);
486 void DM_debug_print_cdlayers(CustomData *cdata);
487
488 bool DM_is_valid(DerivedMesh *dm);
489 #endif
490
491 #endif /* __BKE_DERIVEDMESH_H__ */