Edit Mesh: remove derived-mesh from crazy-space calculation
[blender.git] / source / blender / blenkernel / BKE_DerivedMesh.h
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
19  * All rights reserved.
20  *
21  * The Original Code is: all of this file.
22  *
23  * Contributor(s): none yet.
24  *
25  * ***** END GPL LICENSE BLOCK *****
26  */
27
28 #ifndef __BKE_DERIVEDMESH_H__
29 #define __BKE_DERIVEDMESH_H__
30
31 /** \file BKE_DerivedMesh.h
32  *  \ingroup bke
33  *
34  * Basic design of the DerivedMesh system:
35  *
36  * DerivedMesh is a common set of interfaces for mesh systems.
37  *
38  * There are three main mesh data structures in Blender:
39  * #Mesh, #CDDerivedMesh and #BMesh.
40  *
41  * These, and a few others, all implement DerivedMesh interfaces,
42  * which contains unified drawing interfaces, a few utility interfaces,
43  * and a bunch of read-only interfaces intended mostly for conversion from
44  * one format to another.
45  *
46  * All Mesh structures in blender make use of CustomData, which is used to store
47  * per-element attributes and interpolate them (e.g. uvs, vcols, vgroups, etc).
48  *
49  * Mesh is the "serialized" structure, used for storing object-mode mesh data
50  * and also for saving stuff to disk.  It's interfaces are also what DerivedMesh
51  * uses to communicate with.
52  *
53  * CDDM is a little mesh library, that uses Mesh data structures in the backend.
54  * It's mostly used for modifiers, and has the advantages of not taking much
55  * resources.
56  *
57  * BMesh is a full-on brep, used for editmode, some modifiers, etc.  It's much
58  * more capable (if memory-intensive) then CDDM.
59  *
60  * DerivedMesh is somewhat hackish.  Many places assumes that a DerivedMesh is
61  * a CDDM (most of the time by simply copying it and converting it to one).
62  * CDDM is the original structure for modifiers, but has since been superseded
63  * by BMesh, at least for the foreseeable future.
64  */
65
66 /*
67  * Note: This structure is read-only, for all practical purposes.
68  *       At some point in the future, we may want to consider
69  *       creating a replacement structure that implements a proper
70  *       abstract mesh kernel interface.  Or, we can leave this
71  *       as it is and stick with using BMesh and CDDM.
72  */
73
74 #include "DNA_defs.h"
75 #include "DNA_customdata_types.h"
76 #include "DNA_meshdata_types.h"
77
78 #include "BLI_compiler_attrs.h"
79
80 #include "BKE_customdata.h"
81 #include "BKE_bvhutils.h"
82
83 struct CCGElem;
84 struct CCGKey;
85 struct MVert;
86 struct MEdge;
87 struct MFace;
88 struct MTFace;
89 struct Object;
90 struct Scene;
91 struct Mesh;
92 struct MLoopNorSpaceArray;
93 struct BMEditMesh;
94 struct KeyBlock;
95 struct ModifierData;
96 struct MCol;
97 struct ColorBand;
98 struct Depsgraph;
99 struct GPUVertexAttribs;
100 struct PBVH;
101
102 /* number of sub-elements each mesh element has (for interpolation) */
103 #define SUB_ELEMS_VERT 0
104 #define SUB_ELEMS_EDGE 2
105 #define SUB_ELEMS_FACE 50
106
107 /*
108  * Note: all mface interfaces now officially operate on tessellated data.
109  *       Also, the mface origindex layer indexes mpolys, not mfaces.
110  */
111
112 typedef struct DMCoNo {
113         float co[3];
114         float no[3];
115 } DMCoNo;
116
117 /* keep in sync with MFace/MPoly types */
118 typedef struct DMFlagMat {
119         short mat_nr;
120         char flag;
121 } DMFlagMat;
122
123 typedef enum DerivedMeshType {
124         DM_TYPE_CDDM,
125         DM_TYPE_EDITBMESH,
126         DM_TYPE_CCGDM
127 } DerivedMeshType;
128
129 typedef enum DMForeachFlag {
130         DM_FOREACH_NOP = 0,
131         DM_FOREACH_USE_NORMAL = (1 << 0),  /* foreachMappedVert, foreachMappedLoop, foreachMappedFaceCenter */
132 } DMForeachFlag;
133
134 typedef enum DMDirtyFlag {
135         /* dm has valid tessellated faces, but tessellated CDDATA need to be updated. */
136         DM_DIRTY_TESS_CDLAYERS = 1 << 0,
137
138         /* check this with modifier dependsOnNormals callback to see if normals need recalculation */
139         DM_DIRTY_NORMALS = 1 << 1,
140 }  DMDirtyFlag;
141
142 typedef struct DerivedMesh DerivedMesh;
143 struct DerivedMesh {
144         /** Private DerivedMesh data, only for internal DerivedMesh use */
145         CustomData vertData, edgeData, faceData, loopData, polyData;
146         int numVertData, numEdgeData, numTessFaceData, numLoopData, numPolyData;
147         int needsFree; /* checked on ->release, is set to 0 for cached results */
148         int deformedOnly; /* set by modifier stack if only deformed from original */
149         BVHCache *bvhCache;
150         DerivedMeshType type;
151         DMDirtyFlag dirty;
152         int totmat; /* total materials. Will be valid only before object drawing. */
153         struct Material **mat; /* material array. Will be valid only before object drawing */
154
155         /**
156          * \warning Typical access is done via #getLoopTriArray, #getNumLoopTri.
157          */
158         struct {
159                 /* WARNING! swapping between array (ready-to-be-used data) and array_wip (where data is actually computed)
160                  *          shall always be protected by same lock as one used for looptris computing. */
161                 struct MLoopTri *array, *array_wip;
162                 int num;
163                 int num_alloc;
164         } looptris;
165
166         /* use for converting to BMesh which doesn't store bevel weight and edge crease by default */
167         char cd_flag;
168
169         short tangent_mask; /* which tangent layers are calculated */
170
171         /** Calculate vert and face normals */
172         void (*calcNormals)(DerivedMesh *dm);
173
174         /** Calculate loop (split) normals */
175         void (*calcLoopNormals)(DerivedMesh *dm, const bool use_split_normals, const float split_angle);
176
177         /** Calculate loop (split) normals, and returns split loop normal spacearr. */
178         void (*calcLoopNormalsSpaceArray)(DerivedMesh *dm, const bool use_split_normals, const float split_angle,
179                                           struct MLoopNorSpaceArray *r_lnors_spacearr);
180
181         void (*calcLoopTangents)(
182                 DerivedMesh *dm, bool calc_active_tangent,
183                 const char (*tangent_names)[MAX_NAME], int tangent_names_count);
184
185         /** Recalculates mesh tessellation */
186         void (*recalcTessellation)(DerivedMesh *dm);
187
188         /** Loop tessellation cache (WARNING! Only call inside threading-protected code!) */
189         void (*recalcLoopTri)(DerivedMesh *dm);
190         /** accessor functions */
191         const struct MLoopTri *(*getLoopTriArray)(DerivedMesh * dm);
192         int (*getNumLoopTri)(DerivedMesh *dm);
193
194         /* Misc. Queries */
195
196         /* Also called in Editmode */
197         int (*getNumVerts)(DerivedMesh *dm);
198         int (*getNumEdges)(DerivedMesh *dm);
199         int (*getNumTessFaces)(DerivedMesh *dm);
200         int (*getNumLoops)(DerivedMesh *dm);
201         int (*getNumPolys)(DerivedMesh *dm);
202
203         /** Copy a single vert/edge/tessellated face from the derived mesh into
204          * ``*r_{vert/edge/face}``. note that the current implementation
205          * of this function can be quite slow, iterating over all
206          * elements (editmesh)
207          */
208         void (*getVert)(DerivedMesh *dm, int index, struct MVert *r_vert);
209         void (*getEdge)(DerivedMesh *dm, int index, struct MEdge *r_edge);
210         void (*getTessFace)(DerivedMesh *dm, int index, struct MFace *r_face);
211
212         /** Return a pointer to the entire array of verts/edges/face from the
213          * derived mesh. if such an array does not exist yet, it will be created,
214          * and freed on the next ->release(). consider using getVert/Edge/Face if
215          * you are only interested in a few verts/edges/faces.
216          */
217         struct MVert *(*getVertArray)(DerivedMesh * dm);
218         struct MEdge *(*getEdgeArray)(DerivedMesh * dm);
219         struct MFace *(*getTessFaceArray)(DerivedMesh * dm);
220         struct MLoop *(*getLoopArray)(DerivedMesh * dm);
221         struct MPoly *(*getPolyArray)(DerivedMesh * dm);
222
223         /** Copy all verts/edges/faces from the derived mesh into
224          * *{vert/edge/face}_r (must point to a buffer large enough)
225          */
226         void (*copyVertArray)(DerivedMesh *dm, struct MVert *r_vert);
227         void (*copyEdgeArray)(DerivedMesh *dm, struct MEdge *r_edge);
228         void (*copyTessFaceArray)(DerivedMesh *dm, struct MFace *r_face);
229         void (*copyLoopArray)(DerivedMesh *dm, struct MLoop *r_loop);
230         void (*copyPolyArray)(DerivedMesh *dm, struct MPoly *r_poly);
231
232         /** Return a copy of all verts/edges/faces from the derived mesh
233          * it is the caller's responsibility to free the returned pointer
234          */
235         struct MVert *(*dupVertArray)(DerivedMesh * dm);
236         struct MEdge *(*dupEdgeArray)(DerivedMesh * dm);
237         struct MFace *(*dupTessFaceArray)(DerivedMesh * dm);
238         struct MLoop *(*dupLoopArray)(DerivedMesh * dm);
239         struct MPoly *(*dupPolyArray)(DerivedMesh * dm);
240
241         /** Return a pointer to a single element of vert/edge/face custom data
242          * from the derived mesh (this gives a pointer to the actual data, not
243          * a copy)
244          */
245         void *(*getVertData)(DerivedMesh *dm, int index, int type);
246         void *(*getEdgeData)(DerivedMesh *dm, int index, int type);
247         void *(*getTessFaceData)(DerivedMesh *dm, int index, int type);
248         void *(*getPolyData)(DerivedMesh *dm, int index, int type);
249
250         /** Return a pointer to the entire array of vert/edge/face custom data
251          * from the derived mesh (this gives a pointer to the actual data, not
252          * a copy)
253          */
254         void *(*getVertDataArray)(DerivedMesh *dm, int type);
255         void *(*getEdgeDataArray)(DerivedMesh *dm, int type);
256         void *(*getTessFaceDataArray)(DerivedMesh *dm, int type);
257         void *(*getLoopDataArray)(DerivedMesh *dm, int type);
258         void *(*getPolyDataArray)(DerivedMesh *dm, int type);
259
260         /** Retrieves the base CustomData structures for
261          * verts/edges/tessfaces/loops/facdes*/
262         CustomData *(*getVertDataLayout)(DerivedMesh * dm);
263         CustomData *(*getEdgeDataLayout)(DerivedMesh * dm);
264         CustomData *(*getTessFaceDataLayout)(DerivedMesh * dm);
265         CustomData *(*getLoopDataLayout)(DerivedMesh * dm);
266         CustomData *(*getPolyDataLayout)(DerivedMesh * dm);
267
268         /** Copies all customdata for an element source into dst at index dest */
269         void (*copyFromVertCData)(DerivedMesh *dm, int source, CustomData *dst, int dest);
270         void (*copyFromEdgeCData)(DerivedMesh *dm, int source, CustomData *dst, int dest);
271         void (*copyFromFaceCData)(DerivedMesh *dm, int source, CustomData *dst, int dest);
272
273         /** Optional grid access for subsurf */
274         int (*getNumGrids)(DerivedMesh *dm);
275         int (*getGridSize)(DerivedMesh *dm);
276         struct CCGElem **(*getGridData)(DerivedMesh * dm);
277         int *(*getGridOffset)(DerivedMesh * dm);
278         void (*getGridKey)(DerivedMesh *dm, struct CCGKey *key);
279         DMFlagMat *(*getGridFlagMats)(DerivedMesh * dm);
280         unsigned int **(*getGridHidden)(DerivedMesh * dm);
281
282
283         /** Iterate over each mapped vertex in the derived mesh, calling the
284          * given function with the original vert and the mapped vert's new
285          * coordinate and normal. For historical reasons the normal can be
286          * passed as a float or short array, only one should be non-NULL.
287          */
288         void (*foreachMappedVert)(DerivedMesh *dm,
289                                   void (*func)(void *userData, int index, const float co[3],
290                                                const float no_f[3], const short no_s[3]),
291                                   void *userData,
292                                   DMForeachFlag flag);
293
294         /** Iterate over each mapped edge in the derived mesh, calling the
295          * given function with the original edge and the mapped edge's new
296          * coordinates.
297          */
298         void (*foreachMappedEdge)(DerivedMesh *dm,
299                                   void (*func)(void *userData, int index,
300                                                const float v0co[3], const float v1co[3]),
301                                   void *userData);
302
303         /** Iterate over each mapped loop in the derived mesh, calling the given function
304          * with the original loop index and the mapped loops's new coordinate and normal.
305          */
306         void (*foreachMappedLoop)(DerivedMesh *dm,
307                                   void (*func)(void *userData, int vertex_index, int face_index,
308                                                const float co[3], const float no[3]),
309                                   void *userData,
310                                   DMForeachFlag flag);
311
312         /** Iterate over each mapped face in the derived mesh, calling the
313          * given function with the original face and the mapped face's (or
314          * faces') center and normal.
315          */
316         void (*foreachMappedFaceCenter)(DerivedMesh *dm,
317                                         void (*func)(void *userData, int index,
318                                                      const float cent[3], const float no[3]),
319                                         void *userData,
320                                         DMForeachFlag flag);
321
322         /** Iterate over all vertex points, calling DO_MINMAX with given args.
323          *
324          * Also called in Editmode
325          */
326         void (*getMinMax)(DerivedMesh *dm, float r_min[3], float r_max[3]);
327
328         /** Direct Access Operations
329          * - Can be undefined
330          * - Must be defined for modifiers that only deform however */
331
332         /** Get vertex location, undefined if index is not valid */
333         void (*getVertCo)(DerivedMesh *dm, int index, float r_co[3]);
334
335         /** Fill the array (of length .getNumVerts()) with all vertex locations */
336         void (*getVertCos)(DerivedMesh *dm, float (*r_cos)[3]);
337
338         /** Get smooth vertex normal, undefined if index is not valid */
339         void (*getVertNo)(DerivedMesh *dm, int index, float r_no[3]);
340         void (*getPolyNo)(DerivedMesh *dm, int index, float r_no[3]);
341
342         /** Get a map of vertices to faces
343          */
344         const struct MeshElemMap *(*getPolyMap)(struct Object *ob, DerivedMesh *dm);
345
346         /** Get the BVH used for paint modes
347          */
348         struct PBVH *(*getPBVH)(struct Object *ob, DerivedMesh *dm);
349
350         /** Release reference to the DerivedMesh. This function decides internally
351          * if the DerivedMesh will be freed, or cached for later use. */
352         void (*release)(DerivedMesh *dm);
353 };
354
355 void DM_init_funcs(DerivedMesh *dm);
356
357 void DM_init(
358         DerivedMesh *dm, DerivedMeshType type, int numVerts, int numEdges,
359         int numFaces, int numLoops, int numPolys);
360
361 void DM_from_template_ex(
362         DerivedMesh *dm, DerivedMesh *source, DerivedMeshType type,
363         int numVerts, int numEdges, int numTessFaces,
364         int numLoops, int numPolys,
365         CustomDataMask mask);
366 void DM_from_template(
367         DerivedMesh *dm, DerivedMesh *source,
368         DerivedMeshType type,
369         int numVerts, int numEdges, int numFaces,
370         int numLoops, int numPolys);
371
372 /** utility function to release a DerivedMesh's layers
373  * returns 1 if DerivedMesh has to be released by the backend, 0 otherwise
374  */
375 int DM_release(DerivedMesh *dm);
376
377 /** utility function to convert a DerivedMesh to a Mesh
378  */
379 void DM_to_mesh(DerivedMesh *dm, struct Mesh *me, struct Object *ob, CustomDataMask mask, bool take_ownership);
380
381
382 void DM_set_only_copy(DerivedMesh *dm, CustomDataMask 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(
390         struct DerivedMesh *dm, int type, eCDAllocType alloctype,
391         void *layer);
392 void DM_add_edge_layer(
393         struct DerivedMesh *dm, int type, eCDAllocType alloctype,
394         void *layer);
395 void DM_add_tessface_layer(
396         struct DerivedMesh *dm, int type, eCDAllocType alloctype,
397         void *layer);
398 void DM_add_loop_layer(
399         DerivedMesh *dm, int type, eCDAllocType alloctype,
400         void *layer);
401 void DM_add_poly_layer(
402         struct DerivedMesh *dm, int type, eCDAllocType alloctype,
403         void *layer);
404
405 /* custom data access functions
406  * return pointer to data from first layer which matches type
407  * if they return NULL for valid indices, data doesn't exist
408  * note these return pointers - any change modifies the internals of the mesh
409  */
410 void *DM_get_vert_data(struct DerivedMesh *dm, int index, int type);
411 void *DM_get_edge_data(struct DerivedMesh *dm, int index, int type);
412 void *DM_get_tessface_data(struct DerivedMesh *dm, int index, int type);
413 void *DM_get_poly_data(struct DerivedMesh *dm, int index, int type);
414
415 /* custom data layer access functions
416  * return pointer to first data layer which matches type (a flat array)
417  * if they return NULL, data doesn't exist
418  * note these return pointers - any change modifies the internals of the mesh
419  */
420 void *DM_get_vert_data_layer(struct DerivedMesh *dm, int type);
421 void *DM_get_edge_data_layer(struct DerivedMesh *dm, int type);
422 void *DM_get_tessface_data_layer(struct DerivedMesh *dm, int type);
423 void *DM_get_poly_data_layer(struct DerivedMesh *dm, int type);
424 void *DM_get_loop_data_layer(struct DerivedMesh *dm, int type);
425
426 /* custom data setting functions
427  * copy supplied data into first layer of type using layer's copy function
428  * (deep copy if appropriate)
429  */
430 void DM_set_vert_data(struct DerivedMesh *dm, int index, int type, void *data);
431 void DM_set_edge_data(struct DerivedMesh *dm, int index, int type, void *data);
432 void DM_set_tessface_data(struct DerivedMesh *dm, int index, int type, void *data);
433
434 /* custom data copy functions
435  * copy count elements from source_index in source to dest_index in dest
436  * these copy all layers for which the CD_FLAG_NOCOPY flag is not set
437  */
438 void DM_copy_vert_data(
439         struct DerivedMesh *source, struct DerivedMesh *dest,
440         int source_index, int dest_index, int count);
441 void DM_copy_edge_data(
442         struct DerivedMesh *source, struct DerivedMesh *dest,
443         int source_index, int dest_index, int count);
444 void DM_copy_tessface_data(
445         struct DerivedMesh *source, struct DerivedMesh *dest,
446         int source_index, int dest_index, int count);
447 void DM_copy_loop_data(
448         struct DerivedMesh *source, struct DerivedMesh *dest,
449         int source_index, int dest_index, int count);
450 void DM_copy_poly_data(
451         struct DerivedMesh *source, struct DerivedMesh *dest,
452         int source_index, int dest_index, int count);
453
454 /* custom data free functions
455  * free count elements, starting at index
456  * they free all layers for which the CD_FLAG_NOCOPY flag is not set
457  */
458 void DM_free_vert_data(struct DerivedMesh *dm, int index, int count);
459 void DM_free_edge_data(struct DerivedMesh *dm, int index, int count);
460 void DM_free_tessface_data(struct DerivedMesh *dm, int index, int count);
461 void DM_free_loop_data(struct DerivedMesh *dm, int index, int count);
462 void DM_free_poly_data(struct DerivedMesh *dm, int index, int count);
463
464 /*sets up mpolys for a DM based on face iterators in source*/
465 void DM_DupPolys(DerivedMesh *source, DerivedMesh *target);
466
467 void DM_ensure_normals(DerivedMesh *dm);
468 void DM_ensure_tessface(DerivedMesh *dm);
469
470 void DM_ensure_looptri_data(DerivedMesh *dm);
471 void DM_verttri_from_looptri(MVertTri *verttri, const MLoop *mloop, const MLoopTri *looptri, int looptri_num);
472
473 void DM_update_tessface_data(DerivedMesh *dm);
474 void DM_generate_tangent_tessface_data(DerivedMesh *dm, bool generate);
475
476 void DM_update_materials(DerivedMesh *dm, struct Object *ob);
477 struct MLoopUV *DM_paint_uvlayer_active_get(DerivedMesh *dm, int mat_nr);
478
479 void DM_interp_vert_data(
480         struct DerivedMesh *source, struct DerivedMesh *dest,
481         int *src_indices, float *weights,
482         int count, int dest_index);
483
484 typedef float EdgeVertWeight[SUB_ELEMS_EDGE][SUB_ELEMS_EDGE];
485 void DM_interp_edge_data(
486         struct DerivedMesh *source, struct DerivedMesh *dest,
487         int *src_indices,
488         float *weights, EdgeVertWeight *vert_weights,
489         int count, int dest_index);
490
491 typedef float FaceVertWeight[SUB_ELEMS_FACE][SUB_ELEMS_FACE];
492 void DM_interp_tessface_data(
493         struct DerivedMesh *source, struct DerivedMesh *dest,
494         int *src_indices,
495         float *weights, FaceVertWeight *vert_weights,
496         int count, int dest_index);
497
498 void DM_swap_tessface_data(struct DerivedMesh *dm, int index, const int *corner_indices);
499
500 void DM_interp_loop_data(
501         struct DerivedMesh *source, struct DerivedMesh *dest,
502         int *src_indices,
503         float *weights, int count, int dest_index);
504
505 void DM_interp_poly_data(
506         struct DerivedMesh *source, struct DerivedMesh *dest,
507         int *src_indices,
508         float *weights, int count, int dest_index);
509
510 /* UNUSED */
511 #if 0
512 /** Simple function to get me->totvert amount of vertices/normals,
513  * correctly deformed and subsurfered. Needed especially when vertexgroups are involved.
514  * In use now by vertex/weight paint and particles */
515 DMCoNo *mesh_get_mapped_verts_nors(struct Scene *scene, struct Object *ob);
516 #endif
517 void mesh_get_mapped_verts_coords(DerivedMesh *dm, float (*r_cos)[3], const int totcos);
518
519 /* */
520
521 DerivedMesh *mesh_create_derived_for_modifier(
522         struct Depsgraph *depsgraph, struct Scene *scene, struct Object *ob,
523         struct ModifierData *md, int build_shapekey_layers);
524
525 DerivedMesh *mesh_create_derived_render(
526         struct Depsgraph *depsgraph, struct Scene *scene,
527         struct Object *ob, CustomDataMask dataMask);
528
529 DerivedMesh *getEditDerivedBMesh(
530         struct BMEditMesh *em, struct Object *ob, CustomDataMask data_mask,
531         float (*vertexCos)[3]);
532
533 /* same as above but wont use render settings */
534 DerivedMesh *mesh_create_derived(struct Mesh *me, float (*vertCos)[3]);
535 DerivedMesh *mesh_create_derived_no_deform(
536         struct Depsgraph *depsgraph, struct Scene *scene,
537         struct Object *ob, float (*vertCos)[3],
538         CustomDataMask dataMask);
539 DerivedMesh *mesh_create_derived_no_deform_render(
540         struct Depsgraph *depsgraph, struct Scene *scene,
541         struct Object *ob, float (*vertCos)[3],
542         CustomDataMask dataMask);
543
544 DerivedMesh *editbmesh_get_derived_cage(
545         struct Depsgraph *depsgraph, struct Scene *scene, struct Object *,
546         struct BMEditMesh *em, CustomDataMask dataMask);
547 DerivedMesh *editbmesh_get_derived_cage_and_final(
548         struct Depsgraph *depsgraph, struct Scene *scene, struct Object *,
549         struct BMEditMesh *em, CustomDataMask dataMask,
550         DerivedMesh **r_final);
551
552 DerivedMesh *object_get_derived_final(struct Object *ob, const bool for_render);
553
554 float (*editbmesh_get_vertex_cos(struct BMEditMesh *em, int *r_numVerts))[3];
555 bool editbmesh_modifier_is_enabled(struct Scene *scene, struct ModifierData *md, bool has_prev_mesh);
556 void makeDerivedMesh(
557         struct Depsgraph *depsgraph, struct Scene *scene, struct Object *ob, struct BMEditMesh *em,
558         CustomDataMask dataMask, const bool build_shapekey_layers);
559
560 /** convert layers requested by a GLSL material to actually available layers in
561  * the DerivedMesh, with both a pointer for arrays and an offset for editmesh */
562 typedef struct DMVertexAttribs {
563         struct {
564                 struct MLoopUV *array;
565                 int em_offset, gl_index, gl_texco, gl_info_index;
566         } tface[MAX_MTFACE];
567
568         struct {
569                 struct MLoopCol *array;
570                 int em_offset, gl_index, gl_info_index;
571         } mcol[MAX_MCOL];
572
573         struct {
574                 float (*array)[4];
575                 int em_offset, gl_index, gl_info_index;
576         } tang[MAX_MTFACE];
577
578         struct {
579                 float (*array)[3];
580                 int em_offset, gl_index, gl_texco, gl_info_index;
581         } orco;
582
583         int tottface, totmcol, tottang, totorco;
584 } DMVertexAttribs;
585
586 void DM_vertex_attributes_from_gpu(
587         DerivedMesh *dm,
588         struct GPUVertexAttribs *gattribs, DMVertexAttribs *attribs);
589
590 void DM_calc_tangents_names_from_gpu(
591         const struct GPUVertexAttribs *gattribs,
592         char (*tangent_names)[MAX_NAME], int *tangent_names_count);
593
594 void DM_add_named_tangent_layer_for_uv(
595         CustomData *uv_data, CustomData *tan_data, int numLoopData,
596         const char *layer_name);
597
598 void DM_calc_loop_tangents(
599         DerivedMesh *dm, bool calc_active_tangent, const char (*tangent_names)[MAX_NAME],
600         int tangent_names_count);
601
602 void DM_calc_auto_bump_scale(DerivedMesh *dm);
603
604 /** Set object's bounding box based on DerivedMesh min/max data */
605 void DM_set_object_boundbox(struct Object *ob, DerivedMesh *dm);
606
607 void DM_init_origspace(DerivedMesh *dm);
608
609 /* debug only */
610 #ifndef NDEBUG
611 char *DM_debug_info(DerivedMesh *dm);
612 void DM_debug_print(DerivedMesh *dm);
613 void DM_debug_print_cdlayers(CustomData *cdata);
614
615 bool DM_is_valid(DerivedMesh *dm);
616 #endif
617
618 BLI_INLINE int DM_origindex_mface_mpoly(
619         const int *index_mf_to_mpoly, const int *index_mp_to_orig, const int i) ATTR_NONNULL(1);
620
621 BLI_INLINE int DM_origindex_mface_mpoly(
622         const int *index_mf_to_mpoly, const int *index_mp_to_orig, const int i)
623 {
624         const int j = index_mf_to_mpoly[i];
625         return (j != ORIGINDEX_NONE) ? (index_mp_to_orig ? index_mp_to_orig[j] : j) : ORIGINDEX_NONE;
626 }
627
628 struct MVert *DM_get_vert_array(struct DerivedMesh *dm, bool *r_allocated);
629 struct MEdge *DM_get_edge_array(struct DerivedMesh *dm, bool *r_allocated);
630 struct MLoop *DM_get_loop_array(struct DerivedMesh *dm, bool *r_allocated);
631 struct MPoly *DM_get_poly_array(struct DerivedMesh *dm, bool *r_allocated);
632 struct MFace *DM_get_tessface_array(struct DerivedMesh *dm, bool *r_allocated);
633
634 #endif  /* __BKE_DERIVEDMESH_H__ */