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