Cleanup: no need for plural for term 'collision'
[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_customdata_types.h"
67 #include "DNA_defs.h"
68 #include "DNA_meshdata_types.h"
69
70 #include "BLI_compiler_attrs.h"
71
72 #include "BKE_bvhutils.h"
73 #include "BKE_customdata.h"
74
75 #ifdef __cplusplus
76 extern "C" {
77 #endif
78
79 struct BMEditMesh;
80 struct CCGElem;
81 struct CCGKey;
82 struct CustomData_MeshMasks;
83 struct Depsgraph;
84 struct MEdge;
85 struct MFace;
86 struct MVert;
87 struct Mesh;
88 struct ModifierData;
89 struct Object;
90 struct Scene;
91
92 /*
93  * Note: all mface interfaces now officially operate on tessellated data.
94  *       Also, the mface origindex layer indexes mpolys, not mfaces.
95  */
96
97 /* keep in sync with MFace/MPoly types */
98 typedef struct DMFlagMat {
99   short mat_nr;
100   char flag;
101 } DMFlagMat;
102
103 typedef enum DerivedMeshType {
104   DM_TYPE_CDDM,
105   DM_TYPE_CCGDM,
106 } DerivedMeshType;
107
108 typedef enum DMDirtyFlag {
109   /* dm has valid tessellated faces, but tessellated CDDATA need to be updated. */
110   DM_DIRTY_TESS_CDLAYERS = 1 << 0,
111
112   /* check this with modifier dependsOnNormals callback to see if normals need recalculation */
113   DM_DIRTY_NORMALS = 1 << 1,
114 } DMDirtyFlag;
115
116 typedef struct DerivedMesh DerivedMesh;
117 struct DerivedMesh {
118   /** Private DerivedMesh data, only for internal DerivedMesh use */
119   CustomData vertData, edgeData, faceData, loopData, polyData;
120   int numVertData, numEdgeData, numTessFaceData, numLoopData, numPolyData;
121   int needsFree;    /* checked on ->release, is set to 0 for cached results */
122   int deformedOnly; /* set by modifier stack if only deformed from original */
123   DerivedMeshType type;
124   DMDirtyFlag dirty;
125
126   /**
127    * \warning Typical access is done via #getLoopTriArray, #getNumLoopTri.
128    */
129   struct {
130     /* WARNING! swapping between array (ready-to-be-used data) and array_wip
131      * (where data is actually computed) shall always be protected by same
132      * lock as one used for looptris computing. */
133     struct MLoopTri *array, *array_wip;
134     int num;
135     int num_alloc;
136   } looptris;
137
138   /* use for converting to BMesh which doesn't store bevel weight and edge crease by default */
139   char cd_flag;
140
141   short tangent_mask; /* which tangent layers are calculated */
142
143   /** Calculate vert and face normals */
144   void (*calcNormals)(DerivedMesh *dm);
145
146   /** Loop tessellation cache (WARNING! Only call inside threading-protected code!) */
147   void (*recalcLoopTri)(DerivedMesh *dm);
148   /** accessor functions */
149   const struct MLoopTri *(*getLoopTriArray)(DerivedMesh *dm);
150   int (*getNumLoopTri)(DerivedMesh *dm);
151
152   /* Misc. Queries */
153
154   /* Also called in Editmode */
155   int (*getNumVerts)(DerivedMesh *dm);
156   int (*getNumEdges)(DerivedMesh *dm);
157   int (*getNumTessFaces)(DerivedMesh *dm);
158   int (*getNumLoops)(DerivedMesh *dm);
159   int (*getNumPolys)(DerivedMesh *dm);
160
161   /** Copy a single vert/edge/tessellated face from the derived mesh into
162    * ``*r_{vert/edge/face}``. note that the current implementation
163    * of this function can be quite slow, iterating over all
164    * elements (editmesh)
165    */
166   void (*getVert)(DerivedMesh *dm, int index, struct MVert *r_vert);
167   void (*getEdge)(DerivedMesh *dm, int index, struct MEdge *r_edge);
168   void (*getTessFace)(DerivedMesh *dm, int index, struct MFace *r_face);
169
170   /** Return a pointer to the entire array of verts/edges/face from the
171    * derived mesh. if such an array does not exist yet, it will be created,
172    * and freed on the next ->release(). consider using getVert/Edge/Face if
173    * you are only interested in a few verts/edges/faces.
174    */
175   struct MVert *(*getVertArray)(DerivedMesh *dm);
176   struct MEdge *(*getEdgeArray)(DerivedMesh *dm);
177   struct MFace *(*getTessFaceArray)(DerivedMesh *dm);
178   struct MLoop *(*getLoopArray)(DerivedMesh *dm);
179   struct MPoly *(*getPolyArray)(DerivedMesh *dm);
180
181   /** Copy all verts/edges/faces from the derived mesh into
182    * *{vert/edge/face}_r (must point to a buffer large enough)
183    */
184   void (*copyVertArray)(DerivedMesh *dm, struct MVert *r_vert);
185   void (*copyEdgeArray)(DerivedMesh *dm, struct MEdge *r_edge);
186   void (*copyTessFaceArray)(DerivedMesh *dm, struct MFace *r_face);
187   void (*copyLoopArray)(DerivedMesh *dm, struct MLoop *r_loop);
188   void (*copyPolyArray)(DerivedMesh *dm, struct MPoly *r_poly);
189
190   /** Return a copy of all verts/edges/faces from the derived mesh
191    * it is the caller's responsibility to free the returned pointer
192    */
193   struct MVert *(*dupVertArray)(DerivedMesh *dm);
194   struct MEdge *(*dupEdgeArray)(DerivedMesh *dm);
195   struct MFace *(*dupTessFaceArray)(DerivedMesh *dm);
196   struct MLoop *(*dupLoopArray)(DerivedMesh *dm);
197   struct MPoly *(*dupPolyArray)(DerivedMesh *dm);
198
199   /** Return a pointer to a single element of vert/edge/face custom data
200    * from the derived mesh (this gives a pointer to the actual data, not
201    * a copy)
202    */
203   void *(*getVertData)(DerivedMesh *dm, int index, int type);
204   void *(*getEdgeData)(DerivedMesh *dm, int index, int type);
205   void *(*getTessFaceData)(DerivedMesh *dm, int index, int type);
206   void *(*getPolyData)(DerivedMesh *dm, int index, int type);
207
208   /** Return a pointer to the entire array of vert/edge/face custom data
209    * from the derived mesh (this gives a pointer to the actual data, not
210    * a copy)
211    */
212   void *(*getVertDataArray)(DerivedMesh *dm, int type);
213   void *(*getEdgeDataArray)(DerivedMesh *dm, int type);
214   void *(*getTessFaceDataArray)(DerivedMesh *dm, int type);
215   void *(*getLoopDataArray)(DerivedMesh *dm, int type);
216   void *(*getPolyDataArray)(DerivedMesh *dm, int type);
217
218   /** Retrieves the base CustomData structures for
219    * verts/edges/tessfaces/loops/facdes*/
220   CustomData *(*getVertDataLayout)(DerivedMesh *dm);
221   CustomData *(*getEdgeDataLayout)(DerivedMesh *dm);
222   CustomData *(*getTessFaceDataLayout)(DerivedMesh *dm);
223   CustomData *(*getLoopDataLayout)(DerivedMesh *dm);
224   CustomData *(*getPolyDataLayout)(DerivedMesh *dm);
225
226   /** Optional grid access for subsurf */
227   int (*getNumGrids)(DerivedMesh *dm);
228   int (*getGridSize)(DerivedMesh *dm);
229   struct CCGElem **(*getGridData)(DerivedMesh *dm);
230   int *(*getGridOffset)(DerivedMesh *dm);
231   void (*getGridKey)(DerivedMesh *dm, struct CCGKey *key);
232   DMFlagMat *(*getGridFlagMats)(DerivedMesh *dm);
233   unsigned int **(*getGridHidden)(DerivedMesh *dm);
234
235   /** Direct Access Operations
236    * - Can be undefined
237    * - Must be defined for modifiers that only deform however */
238
239   /** Get vertex location, undefined if index is not valid */
240   void (*getVertCo)(DerivedMesh *dm, int index, float r_co[3]);
241
242   /** Get smooth vertex normal, undefined if index is not valid */
243   void (*getVertNo)(DerivedMesh *dm, int index, float r_no[3]);
244   void (*getPolyNo)(DerivedMesh *dm, int index, float r_no[3]);
245
246   /** Get a map of vertices to faces
247    */
248   const struct MeshElemMap *(*getPolyMap)(struct Object *ob, DerivedMesh *dm);
249
250   /** Release reference to the DerivedMesh. This function decides internally
251    * if the DerivedMesh will be freed, or cached for later use. */
252   void (*release)(DerivedMesh *dm);
253 };
254
255 void DM_init_funcs(DerivedMesh *dm);
256
257 void DM_init(DerivedMesh *dm,
258              DerivedMeshType type,
259              int numVerts,
260              int numEdges,
261              int numFaces,
262              int numLoops,
263              int numPolys);
264
265 void DM_from_template_ex(DerivedMesh *dm,
266                          DerivedMesh *source,
267                          DerivedMeshType type,
268                          int numVerts,
269                          int numEdges,
270                          int numTessFaces,
271                          int numLoops,
272                          int numPolys,
273                          const struct CustomData_MeshMasks *mask);
274 void DM_from_template(DerivedMesh *dm,
275                       DerivedMesh *source,
276                       DerivedMeshType type,
277                       int numVerts,
278                       int numEdges,
279                       int numFaces,
280                       int numLoops,
281                       int numPolys);
282
283 /**
284  * Utility function to release a DerivedMesh's layers
285  * returns 1 if DerivedMesh has to be released by the backend, 0 otherwise.
286  */
287 int DM_release(DerivedMesh *dm);
288
289 void DM_set_only_copy(DerivedMesh *dm, const struct CustomData_MeshMasks *mask);
290
291 /* adds a vertex/edge/face custom data layer to a DerivedMesh, optionally
292  * backed by an external data array
293  * alloctype defines how the layer is allocated or copied, and how it is
294  * freed, see BKE_customdata.h for the different options
295  */
296 void DM_add_vert_layer(struct DerivedMesh *dm, int type, eCDAllocType alloctype, void *layer);
297 void DM_add_edge_layer(struct DerivedMesh *dm, int type, eCDAllocType alloctype, void *layer);
298 void DM_add_tessface_layer(struct DerivedMesh *dm, int type, eCDAllocType alloctype, void *layer);
299 void DM_add_loop_layer(DerivedMesh *dm, int type, eCDAllocType alloctype, void *layer);
300 void DM_add_poly_layer(struct DerivedMesh *dm, int type, eCDAllocType alloctype, void *layer);
301
302 /* custom data access functions
303  * return pointer to data from first layer which matches type
304  * if they return NULL for valid indices, data doesn't exist
305  * note these return pointers - any change modifies the internals of the mesh
306  */
307 void *DM_get_vert_data(struct DerivedMesh *dm, int index, int type);
308 void *DM_get_edge_data(struct DerivedMesh *dm, int index, int type);
309 void *DM_get_tessface_data(struct DerivedMesh *dm, int index, int type);
310 void *DM_get_poly_data(struct DerivedMesh *dm, int index, int type);
311
312 /* custom data layer access functions
313  * return pointer to first data layer which matches type (a flat array)
314  * if they return NULL, data doesn't exist
315  * note these return pointers - any change modifies the internals of the mesh
316  */
317 void *DM_get_vert_data_layer(struct DerivedMesh *dm, int type);
318 void *DM_get_edge_data_layer(struct DerivedMesh *dm, int type);
319 void *DM_get_tessface_data_layer(struct DerivedMesh *dm, int type);
320 void *DM_get_poly_data_layer(struct DerivedMesh *dm, int type);
321 void *DM_get_loop_data_layer(struct DerivedMesh *dm, int type);
322
323 /* custom data copy functions
324  * copy count elements from source_index in source to dest_index in dest
325  * these copy all layers for which the CD_FLAG_NOCOPY flag is not set
326  */
327 void DM_copy_vert_data(struct DerivedMesh *source,
328                        struct DerivedMesh *dest,
329                        int source_index,
330                        int dest_index,
331                        int count);
332
333 /*sets up mpolys for a DM based on face iterators in source*/
334 void DM_DupPolys(DerivedMesh *source, DerivedMesh *target);
335
336 void DM_ensure_normals(DerivedMesh *dm);
337
338 void DM_ensure_looptri_data(DerivedMesh *dm);
339
340 void DM_interp_vert_data(struct DerivedMesh *source,
341                          struct DerivedMesh *dest,
342                          int *src_indices,
343                          float *weights,
344                          int count,
345                          int dest_index);
346
347 void mesh_get_mapped_verts_coords(struct Mesh *me_eval, float (*r_cos)[3], const int totcos);
348
349 /* same as above but wont use render settings */
350 struct Mesh *editbmesh_get_eval_cage(struct Depsgraph *depsgraph,
351                                      struct Scene *scene,
352                                      struct Object *,
353                                      struct BMEditMesh *em,
354                                      const struct CustomData_MeshMasks *dataMask);
355 struct Mesh *editbmesh_get_eval_cage_from_orig(struct Depsgraph *depsgraph,
356                                                struct Scene *scene,
357                                                struct Object *object,
358                                                const struct CustomData_MeshMasks *dataMask);
359 struct Mesh *editbmesh_get_eval_cage_and_final(struct Depsgraph *depsgraph,
360                                                struct Scene *scene,
361                                                struct Object *,
362                                                struct BMEditMesh *em,
363                                                const struct CustomData_MeshMasks *dataMask,
364                                                struct Mesh **r_final);
365
366 float (*editbmesh_vert_coords_alloc(struct BMEditMesh *em, int *r_vert_len))[3];
367 bool editbmesh_modifier_is_enabled(struct Scene *scene,
368                                    struct ModifierData *md,
369                                    bool has_prev_mesh);
370 void makeDerivedMesh(struct Depsgraph *depsgraph,
371                      struct Scene *scene,
372                      struct Object *ob,
373                      struct BMEditMesh *em,
374                      const struct CustomData_MeshMasks *dataMask);
375
376 void DM_calc_loop_tangents(DerivedMesh *dm,
377                            bool calc_active_tangent,
378                            const char (*tangent_names)[MAX_NAME],
379                            int tangent_names_count);
380
381 /* debug only */
382 #ifndef NDEBUG
383 char *DM_debug_info(DerivedMesh *dm);
384 void DM_debug_print(DerivedMesh *dm);
385 void DM_debug_print_cdlayers(CustomData *cdata);
386
387 bool DM_is_valid(DerivedMesh *dm);
388 #endif
389
390 #ifdef __cplusplus
391 }
392 #endif
393
394 #endif /* __BKE_DERIVEDMESH_H__ */