Mesh Remap: Face Corner Data: Do not use large epsilon values to create bvhtrees.
[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 GPUVertexAttribs;
99 struct GPUDrawObject;
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 DMDrawOption {
130         /* the element is hidden or otherwise non-drawable */
131         DM_DRAW_OPTION_SKIP = 0,
132         /* normal drawing */
133         DM_DRAW_OPTION_NORMAL = 1,
134         /* draw, but don't set the color from mcol */
135         DM_DRAW_OPTION_NO_MCOL = 2,
136         /* used in drawMappedFaces, use GL stipple for the face */
137         DM_DRAW_OPTION_STIPPLE = 3,
138 } DMDrawOption;
139
140 /* Drawing callback types */
141 typedef int (*DMSetMaterial)(int mat_nr, void *attribs);
142 typedef int (*DMCompareDrawOptions)(void *userData, int cur_index, int next_index);
143 typedef void (*DMSetDrawInterpOptions)(void *userData, int index, float t);
144 typedef DMDrawOption (*DMSetDrawOptions)(void *userData, int index);
145 typedef DMDrawOption (*DMSetDrawOptionsMappedTex)(void *userData, int origindex, int mat_nr);
146 typedef DMDrawOption (*DMSetDrawOptionsTex)(struct MTexPoly *mtexpoly, const bool has_vcol, int matnr);
147
148 typedef enum DMDrawFlag {
149         DM_DRAW_USE_COLORS          = (1 << 0),
150         DM_DRAW_ALWAYS_SMOOTH       = (1 << 1),
151         DM_DRAW_USE_ACTIVE_UV       = (1 << 2),
152         DM_DRAW_USE_TEXPAINT_UV     = (1 << 3),
153         DM_DRAW_SKIP_HIDDEN         = (1 << 4),
154         DM_DRAW_SKIP_SELECT         = (1 << 5),
155         DM_DRAW_SELECT_USE_EDITMODE = (1 << 6),
156         DM_DRAW_NEED_NORMALS        = (1 << 7)
157 } DMDrawFlag;
158
159 typedef enum DMForeachFlag {
160         DM_FOREACH_NOP = 0,
161         DM_FOREACH_USE_NORMAL = (1 << 0),  /* foreachMappedVert, foreachMappedLoop, foreachMappedFaceCenter */
162 } DMForeachFlag;
163
164 typedef enum DMDirtyFlag {
165         /* dm has valid tessellated faces, but tessellated CDDATA need to be updated. */
166         DM_DIRTY_TESS_CDLAYERS = 1 << 0,
167         /* One of the MCOL layers have been updated, force updating of GPUDrawObject's colors buffer.
168          * This is necessary with modern, VBO draw code, as e.g. in vpaint mode me->mcol may be updated
169          * without actually rebuilding dm (hence by default keeping same GPUDrawObject, and same colors
170          * buffer, which prevents update during a stroke!). */
171         DM_DIRTY_MCOL_UPDATE_DRAW = 1 << 1,
172
173         /* check this with modifier dependsOnNormals callback to see if normals need recalculation */
174         DM_DIRTY_NORMALS = 1 << 2,
175 }  DMDirtyFlag;
176
177 typedef struct DerivedMesh DerivedMesh;
178 struct DerivedMesh {
179         /** Private DerivedMesh data, only for internal DerivedMesh use */
180         CustomData vertData, edgeData, faceData, loopData, polyData;
181         int numVertData, numEdgeData, numTessFaceData, numLoopData, numPolyData;
182         int needsFree; /* checked on ->release, is set to 0 for cached results */
183         int deformedOnly; /* set by modifier stack if only deformed from original */
184         BVHCache *bvhCache;
185         struct GPUDrawObject *drawObject;
186         DerivedMeshType type;
187         float auto_bump_scale;
188         DMDirtyFlag dirty;
189         int totmat; /* total materials. Will be valid only before object drawing. */
190         struct Material **mat; /* material array. Will be valid only before object drawing */
191
192         /**
193          * \warning Typical access is done via #getLoopTriArray, #getNumLoopTri.
194          */
195         struct {
196                 /* WARNING! swapping between array (ready-to-be-used data) and array_wip (where data is actually computed)
197                  *          shall always be protected by same lock as one used for looptris computing. */
198                 struct MLoopTri *array, *array_wip;
199                 int num;
200                 int num_alloc;
201         } looptris;
202
203         /* use for converting to BMesh which doesn't store bevel weight and edge crease by default */
204         char cd_flag;
205
206         short tangent_mask; /* which tangent layers are calculated */
207
208         /** Calculate vert and face normals */
209         void (*calcNormals)(DerivedMesh *dm);
210
211         /** Calculate loop (split) normals */
212         void (*calcLoopNormals)(DerivedMesh *dm, const bool use_split_normals, const float split_angle);
213
214         /** Calculate loop (split) normals, and returns split loop normal spacearr. */
215         void (*calcLoopNormalsSpaceArray)(DerivedMesh *dm, const bool use_split_normals, const float split_angle,
216                                           struct MLoopNorSpaceArray *r_lnors_spacearr);
217
218         void (*calcLoopTangents)(
219                 DerivedMesh *dm, bool calc_active_tangent,
220                 const char (*tangent_names)[MAX_NAME], int tangent_names_count);
221
222         /** Recalculates mesh tessellation */
223         void (*recalcTessellation)(DerivedMesh *dm);
224
225         /** Loop tessellation cache (WARNING! Only call inside threading-protected code!) */
226         void (*recalcLoopTri)(DerivedMesh *dm);
227         /** accessor functions */
228         const struct MLoopTri *(*getLoopTriArray)(DerivedMesh * dm);
229         int (*getNumLoopTri)(DerivedMesh *dm);
230
231         /* Misc. Queries */
232
233         /* Also called in Editmode */
234         int (*getNumVerts)(DerivedMesh *dm);
235         int (*getNumEdges)(DerivedMesh *dm);
236         int (*getNumTessFaces)(DerivedMesh *dm);
237         int (*getNumLoops)(DerivedMesh *dm);
238         int (*getNumPolys)(DerivedMesh *dm);
239
240         /** Copy a single vert/edge/tessellated face from the derived mesh into
241          * ``*r_{vert/edge/face}``. note that the current implementation
242          * of this function can be quite slow, iterating over all
243          * elements (editmesh)
244          */
245         void (*getVert)(DerivedMesh *dm, int index, struct MVert *r_vert);
246         void (*getEdge)(DerivedMesh *dm, int index, struct MEdge *r_edge);
247         void (*getTessFace)(DerivedMesh *dm, int index, struct MFace *r_face);
248
249         /** Return a pointer to the entire array of verts/edges/face from the
250          * derived mesh. if such an array does not exist yet, it will be created,
251          * and freed on the next ->release(). consider using getVert/Edge/Face if
252          * you are only interested in a few verts/edges/faces.
253          */
254         struct MVert *(*getVertArray)(DerivedMesh * dm);
255         struct MEdge *(*getEdgeArray)(DerivedMesh * dm);
256         struct MFace *(*getTessFaceArray)(DerivedMesh * dm);
257         struct MLoop *(*getLoopArray)(DerivedMesh * dm);
258         struct MPoly *(*getPolyArray)(DerivedMesh * dm);
259
260         /** Copy all verts/edges/faces from the derived mesh into
261          * *{vert/edge/face}_r (must point to a buffer large enough)
262          */
263         void (*copyVertArray)(DerivedMesh *dm, struct MVert *r_vert);
264         void (*copyEdgeArray)(DerivedMesh *dm, struct MEdge *r_edge);
265         void (*copyTessFaceArray)(DerivedMesh *dm, struct MFace *r_face);
266         void (*copyLoopArray)(DerivedMesh *dm, struct MLoop *r_loop);
267         void (*copyPolyArray)(DerivedMesh *dm, struct MPoly *r_poly);
268
269         /** Return a copy of all verts/edges/faces from the derived mesh
270          * it is the caller's responsibility to free the returned pointer
271          */
272         struct MVert *(*dupVertArray)(DerivedMesh * dm);
273         struct MEdge *(*dupEdgeArray)(DerivedMesh * dm);
274         struct MFace *(*dupTessFaceArray)(DerivedMesh * dm);
275         struct MLoop *(*dupLoopArray)(DerivedMesh * dm);
276         struct MPoly *(*dupPolyArray)(DerivedMesh * dm);
277
278         /** Return a pointer to a single element of vert/edge/face custom data
279          * from the derived mesh (this gives a pointer to the actual data, not
280          * a copy)
281          */
282         void *(*getVertData)(DerivedMesh *dm, int index, int type);
283         void *(*getEdgeData)(DerivedMesh *dm, int index, int type);
284         void *(*getTessFaceData)(DerivedMesh *dm, int index, int type);
285         void *(*getPolyData)(DerivedMesh *dm, int index, int type);
286
287         /** Return a pointer to the entire array of vert/edge/face custom data
288          * from the derived mesh (this gives a pointer to the actual data, not
289          * a copy)
290          */
291         void *(*getVertDataArray)(DerivedMesh *dm, int type);
292         void *(*getEdgeDataArray)(DerivedMesh *dm, int type);
293         void *(*getTessFaceDataArray)(DerivedMesh *dm, int type);
294         void *(*getLoopDataArray)(DerivedMesh *dm, int type);
295         void *(*getPolyDataArray)(DerivedMesh *dm, int type);
296
297         /** Retrieves the base CustomData structures for
298          * verts/edges/tessfaces/loops/facdes*/
299         CustomData *(*getVertDataLayout)(DerivedMesh * dm);
300         CustomData *(*getEdgeDataLayout)(DerivedMesh * dm);
301         CustomData *(*getTessFaceDataLayout)(DerivedMesh * dm);
302         CustomData *(*getLoopDataLayout)(DerivedMesh * dm);
303         CustomData *(*getPolyDataLayout)(DerivedMesh * dm);
304         
305         /** Copies all customdata for an element source into dst at index dest */
306         void (*copyFromVertCData)(DerivedMesh *dm, int source, CustomData *dst, int dest);
307         void (*copyFromEdgeCData)(DerivedMesh *dm, int source, CustomData *dst, int dest);
308         void (*copyFromFaceCData)(DerivedMesh *dm, int source, CustomData *dst, int dest);
309         
310         /** Optional grid access for subsurf */
311         int (*getNumGrids)(DerivedMesh *dm);
312         int (*getGridSize)(DerivedMesh *dm);
313         struct CCGElem **(*getGridData)(DerivedMesh * dm);
314         int *(*getGridOffset)(DerivedMesh * dm);
315         void (*getGridKey)(DerivedMesh *dm, struct CCGKey *key);
316         DMFlagMat *(*getGridFlagMats)(DerivedMesh * dm);
317         unsigned int **(*getGridHidden)(DerivedMesh * dm);
318         
319
320         /** Iterate over each mapped vertex in the derived mesh, calling the
321          * given function with the original vert and the mapped vert's new
322          * coordinate and normal. For historical reasons the normal can be
323          * passed as a float or short array, only one should be non-NULL.
324          */
325         void (*foreachMappedVert)(DerivedMesh *dm,
326                                   void (*func)(void *userData, int index, const float co[3],
327                                                const float no_f[3], const short no_s[3]),
328                                   void *userData,
329                                   DMForeachFlag flag);
330
331         /** Iterate over each mapped edge in the derived mesh, calling the
332          * given function with the original edge and the mapped edge's new
333          * coordinates.
334          */
335         void (*foreachMappedEdge)(DerivedMesh *dm,
336                                   void (*func)(void *userData, int index,
337                                                const float v0co[3], const float v1co[3]),
338                                   void *userData);
339
340         /** Iterate over each mapped loop in the derived mesh, calling the given function
341          * with the original loop index and the mapped loops's new coordinate and normal.
342          */
343         void (*foreachMappedLoop)(DerivedMesh *dm,
344                                   void (*func)(void *userData, int vertex_index, int face_index,
345                                                const float co[3], const float no[3]),
346                                   void *userData,
347                                   DMForeachFlag flag);
348
349         /** Iterate over each mapped face in the derived mesh, calling the
350          * given function with the original face and the mapped face's (or
351          * faces') center and normal.
352          */
353         void (*foreachMappedFaceCenter)(DerivedMesh *dm,
354                                         void (*func)(void *userData, int index,
355                                                      const float cent[3], const float no[3]),
356                                         void *userData,
357                                         DMForeachFlag flag);
358
359         /** Iterate over all vertex points, calling DO_MINMAX with given args.
360          *
361          * Also called in Editmode
362          */
363         void (*getMinMax)(DerivedMesh *dm, float r_min[3], float r_max[3]);
364
365         /** Direct Access Operations
366          * - Can be undefined
367          * - Must be defined for modifiers that only deform however */
368
369         /** Get vertex location, undefined if index is not valid */
370         void (*getVertCo)(DerivedMesh *dm, int index, float r_co[3]);
371
372         /** Fill the array (of length .getNumVerts()) with all vertex locations */
373         void (*getVertCos)(DerivedMesh *dm, float (*r_cos)[3]);
374
375         /** Get smooth vertex normal, undefined if index is not valid */
376         void (*getVertNo)(DerivedMesh *dm, int index, float r_no[3]);
377         void (*getPolyNo)(DerivedMesh *dm, int index, float r_no[3]);
378
379         /** Get a map of vertices to faces
380          */
381         const struct MeshElemMap *(*getPolyMap)(struct Object *ob, DerivedMesh *dm);
382
383         /** Get the BVH used for paint modes
384          */
385         struct PBVH *(*getPBVH)(struct Object *ob, DerivedMesh *dm);
386
387         /* Drawing Operations */
388
389         /** Draw all vertices as bgl points (no options) */
390         void (*drawVerts)(DerivedMesh *dm);
391
392         /** Draw edges in the UV mesh (if exists) */
393         void (*drawUVEdges)(DerivedMesh *dm);
394
395         /** Draw all edges as lines (no options)
396          *
397          * Also called for *final* editmode DerivedMeshes
398          */
399         void (*drawEdges)(DerivedMesh *dm, bool drawLooseEdges, bool drawAllEdges);
400         
401         /** Draw all loose edges (edges w/ no adjoining faces) */
402         void (*drawLooseEdges)(DerivedMesh *dm);
403
404         /** Draw all faces
405          *  o Set face normal or vertex normal based on inherited face flag
406          *  o Use inherited face material index to call setMaterial
407          *  o Only if setMaterial returns true
408          *
409          * Also called for *final* editmode DerivedMeshes
410          */
411         void (*drawFacesSolid)(DerivedMesh *dm, float (*partial_redraw_planes)[4],
412                                bool fast, DMSetMaterial setMaterial);
413
414         /** Draw all faces using MTFace
415          * - Drawing options too complicated to enumerate, look at code.
416          */
417         void (*drawFacesTex)(DerivedMesh *dm,
418                              DMSetDrawOptionsTex setDrawOptions,
419                              DMCompareDrawOptions compareDrawOptions,
420                              void *userData, DMDrawFlag flag);
421
422         /** Draw all faces with GLSL materials
423          *  o setMaterial is called for every different material nr
424          *  o Only if setMaterial returns true
425          */
426         void (*drawFacesGLSL)(DerivedMesh *dm, DMSetMaterial setMaterial);
427
428         /** Draw mapped faces (no color, or texture)
429          * - Only if !setDrawOptions or
430          *   setDrawOptions(userData, mapped-face-index, r_drawSmooth)
431          *   returns true
432          *
433          * If drawSmooth is set to true then vertex normals should be set and
434          * glShadeModel called with GL_SMOOTH. Otherwise the face normal should
435          * be set and glShadeModel called with GL_FLAT.
436          *
437          * The setDrawOptions is allowed to not set drawSmooth (for example, when
438          * lighting is disabled), in which case the implementation should draw as
439          * smooth shaded.
440          */
441         void (*drawMappedFaces)(DerivedMesh *dm,
442                                 DMSetDrawOptions setDrawOptions,
443                                 DMSetMaterial setMaterial,
444                                 DMCompareDrawOptions compareDrawOptions,
445                                 void *userData,
446                                 DMDrawFlag flag);
447
448         /** Draw mapped faces using MTFace
449          * - Drawing options too complicated to enumerate, look at code.
450          */
451         void (*drawMappedFacesTex)(DerivedMesh *dm,
452                                    DMSetDrawOptionsMappedTex setDrawOptions,
453                                    DMCompareDrawOptions compareDrawOptions,
454                                    void *userData, DMDrawFlag flag);
455
456         /** Draw mapped faces with GLSL materials
457          * - setMaterial is called for every different material nr
458          * - setDrawOptions is called for every face
459          * - Only if setMaterial and setDrawOptions return true
460          */
461         void (*drawMappedFacesGLSL)(DerivedMesh *dm,
462                                     DMSetMaterial setMaterial,
463                                     DMSetDrawOptions setDrawOptions,
464                                     void *userData);
465
466         /** Draw mapped edges as lines
467          * - Only if !setDrawOptions or setDrawOptions(userData, mapped-edge)
468          *   returns true
469          */
470         void (*drawMappedEdges)(DerivedMesh *dm,
471                                 DMSetDrawOptions setDrawOptions,
472                                 void *userData);
473
474         /** Draw mapped edges as lines with interpolation values
475          * - Only if !setDrawOptions or
476          *   setDrawOptions(userData, mapped-edge, mapped-v0, mapped-v1, t)
477          *   returns true
478          *
479          * NOTE: This routine is optional!
480          */
481         void (*drawMappedEdgesInterp)(DerivedMesh *dm, 
482                                       DMSetDrawOptions setDrawOptions,
483                                       DMSetDrawInterpOptions setDrawInterpOptions,
484                                       void *userData);
485
486         /** Draw all faces with materials
487          * - setMaterial is called for every different material nr
488          * - setFace is called to verify if a face must be hidden
489          */
490         void (*drawMappedFacesMat)(DerivedMesh *dm,
491                                    void (*setMaterial)(void *userData, int matnr, void *attribs),
492                                    bool (*setFace)(void *userData, int index), void *userData);
493
494         struct GPUDrawObject *(*gpuObjectNew)(DerivedMesh *dm);
495         void (*copy_gpu_data)(DerivedMesh *dm, int type, void *varray_p,
496                               const int *mat_orig_to_new, const void *user_data);
497
498         /** Release reference to the DerivedMesh. This function decides internally
499          * if the DerivedMesh will be freed, or cached for later use. */
500         void (*release)(DerivedMesh *dm);
501 };
502
503 void DM_init_funcs(DerivedMesh *dm);
504
505 void DM_init(
506         DerivedMesh *dm, DerivedMeshType type, int numVerts, int numEdges,
507         int numFaces, int numLoops, int numPolys);
508
509 void DM_from_template_ex(
510         DerivedMesh *dm, DerivedMesh *source, DerivedMeshType type,
511         int numVerts, int numEdges, int numTessFaces,
512         int numLoops, int numPolys,
513         CustomDataMask mask);
514 void DM_from_template(
515         DerivedMesh *dm, DerivedMesh *source,
516         DerivedMeshType type,
517         int numVerts, int numEdges, int numFaces,
518         int numLoops, int numPolys);
519
520 /** utility function to release a DerivedMesh's layers
521  * returns 1 if DerivedMesh has to be released by the backend, 0 otherwise
522  */
523 int DM_release(DerivedMesh *dm);
524
525 /** utility function to convert a DerivedMesh to a Mesh
526  */
527 void DM_to_mesh(DerivedMesh *dm, struct Mesh *me, struct Object *ob, CustomDataMask mask, bool take_ownership);
528
529 struct BMEditMesh *DM_to_editbmesh(
530         struct DerivedMesh *dm,
531         struct BMEditMesh *existing, const bool do_tessellate);
532
533 /* conversion to bmesh only */
534 void          DM_to_bmesh_ex(struct DerivedMesh *dm, struct BMesh *bm, const bool calc_face_normal);
535 struct BMesh *DM_to_bmesh(struct DerivedMesh *dm, const bool calc_face_normal);
536
537
538 /** Utility function to convert a DerivedMesh to a shape key block */
539 void DM_to_meshkey(DerivedMesh *dm, struct Mesh *me, struct KeyBlock *kb);
540
541 void DM_set_only_copy(DerivedMesh *dm, CustomDataMask mask);
542
543 /* adds a vertex/edge/face custom data layer to a DerivedMesh, optionally
544  * backed by an external data array
545  * alloctype defines how the layer is allocated or copied, and how it is
546  * freed, see BKE_customdata.h for the different options
547  */
548 void DM_add_vert_layer(
549         struct DerivedMesh *dm, int type, int alloctype,
550         void *layer);
551 void DM_add_edge_layer(
552         struct DerivedMesh *dm, int type, int alloctype,
553         void *layer);
554 void DM_add_tessface_layer(
555         struct DerivedMesh *dm, int type, int alloctype,
556         void *layer);
557 void DM_add_loop_layer(
558         DerivedMesh *dm, int type, int alloctype,
559         void *layer);
560 void DM_add_poly_layer(
561         struct DerivedMesh *dm, int type, int alloctype,
562         void *layer);
563
564 /* custom data access functions
565  * return pointer to data from first layer which matches type
566  * if they return NULL for valid indices, data doesn't exist
567  * note these return pointers - any change modifies the internals of the mesh
568  */
569 void *DM_get_vert_data(struct DerivedMesh *dm, int index, int type);
570 void *DM_get_edge_data(struct DerivedMesh *dm, int index, int type);
571 void *DM_get_tessface_data(struct DerivedMesh *dm, int index, int type);
572 void *DM_get_poly_data(struct DerivedMesh *dm, int index, int type);
573
574 /* custom data layer access functions
575  * return pointer to first data layer which matches type (a flat array)
576  * if they return NULL, data doesn't exist
577  * note these return pointers - any change modifies the internals of the mesh
578  */
579 void *DM_get_vert_data_layer(struct DerivedMesh *dm, int type);
580 void *DM_get_edge_data_layer(struct DerivedMesh *dm, int type);
581 void *DM_get_tessface_data_layer(struct DerivedMesh *dm, int type);
582 void *DM_get_poly_data_layer(struct DerivedMesh *dm, int type);
583 void *DM_get_loop_data_layer(struct DerivedMesh *dm, int type);
584
585 /* custom data setting functions
586  * copy supplied data into first layer of type using layer's copy function
587  * (deep copy if appropriate)
588  */
589 void DM_set_vert_data(struct DerivedMesh *dm, int index, int type, void *data);
590 void DM_set_edge_data(struct DerivedMesh *dm, int index, int type, void *data);
591 void DM_set_tessface_data(struct DerivedMesh *dm, int index, int type, void *data);
592
593 /* custom data copy functions
594  * copy count elements from source_index in source to dest_index in dest
595  * these copy all layers for which the CD_FLAG_NOCOPY flag is not set
596  */
597 void DM_copy_vert_data(
598         struct DerivedMesh *source, struct DerivedMesh *dest,
599         int source_index, int dest_index, int count);
600 void DM_copy_edge_data(
601         struct DerivedMesh *source, struct DerivedMesh *dest,
602         int source_index, int dest_index, int count);
603 void DM_copy_tessface_data(
604         struct DerivedMesh *source, struct DerivedMesh *dest,
605         int source_index, int dest_index, int count);
606 void DM_copy_loop_data(
607         struct DerivedMesh *source, struct DerivedMesh *dest,
608         int source_index, int dest_index, int count);
609 void DM_copy_poly_data(
610         struct DerivedMesh *source, struct DerivedMesh *dest,
611         int source_index, int dest_index, int count);
612
613 /* custom data free functions
614  * free count elements, starting at index
615  * they free all layers for which the CD_FLAG_NOCOPY flag is not set
616  */
617 void DM_free_vert_data(struct DerivedMesh *dm, int index, int count);
618 void DM_free_edge_data(struct DerivedMesh *dm, int index, int count);
619 void DM_free_tessface_data(struct DerivedMesh *dm, int index, int count);
620 void DM_free_loop_data(struct DerivedMesh *dm, int index, int count);
621 void DM_free_poly_data(struct DerivedMesh *dm, int index, int count);
622
623 /*sets up mpolys for a DM based on face iterators in source*/
624 void DM_DupPolys(DerivedMesh *source, DerivedMesh *target);
625
626 void DM_ensure_normals(DerivedMesh *dm);
627 void DM_ensure_tessface(DerivedMesh *dm);
628
629 void DM_ensure_looptri_data(DerivedMesh *dm);
630 void DM_verttri_from_looptri(MVertTri *verttri, const MLoop *mloop, const MLoopTri *looptri, int looptri_num);
631
632 void DM_update_tessface_data(DerivedMesh *dm);
633 void DM_generate_tangent_tessface_data(DerivedMesh *dm, bool generate);
634
635 void DM_update_materials(DerivedMesh *dm, struct Object *ob);
636 struct MLoopUV *DM_paint_uvlayer_active_get(DerivedMesh *dm, int mat_nr);
637
638 void DM_interp_vert_data(
639         struct DerivedMesh *source, struct DerivedMesh *dest,
640         int *src_indices, float *weights,
641         int count, int dest_index);
642
643 typedef float EdgeVertWeight[SUB_ELEMS_EDGE][SUB_ELEMS_EDGE];
644 void DM_interp_edge_data(
645         struct DerivedMesh *source, struct DerivedMesh *dest,
646         int *src_indices,
647         float *weights, EdgeVertWeight *vert_weights,
648         int count, int dest_index);
649
650 typedef float FaceVertWeight[SUB_ELEMS_FACE][SUB_ELEMS_FACE];
651 void DM_interp_tessface_data(
652         struct DerivedMesh *source, struct DerivedMesh *dest,
653         int *src_indices,
654         float *weights, FaceVertWeight *vert_weights,
655         int count, int dest_index);
656
657 void DM_swap_tessface_data(struct DerivedMesh *dm, int index, const int *corner_indices);
658
659 void DM_interp_loop_data(
660         struct DerivedMesh *source, struct DerivedMesh *dest,
661         int *src_indices,
662         float *weights, int count, int dest_index);
663
664 void DM_interp_poly_data(
665         struct DerivedMesh *source, struct DerivedMesh *dest,
666         int *src_indices,
667         float *weights, int count, int dest_index);
668
669 /* Temporary? A function to give a colorband to derivedmesh for vertexcolor ranges */
670 void vDM_ColorBand_store(const struct ColorBand *coba, const char alert_color[4]);
671
672 /* UNUSED */
673 #if 0
674 /** Simple function to get me->totvert amount of vertices/normals,
675  * correctly deformed and subsurfered. Needed especially when vertexgroups are involved.
676  * In use now by vertex/weight paint and particles */
677 DMCoNo *mesh_get_mapped_verts_nors(struct Scene *scene, struct Object *ob);
678 #endif
679 void mesh_get_mapped_verts_coords(DerivedMesh *dm, float (*r_cos)[3], const int totcos);
680
681 /* */
682 DerivedMesh *mesh_get_derived_final(
683         struct Scene *scene, struct Object *ob,
684         CustomDataMask dataMask);
685 DerivedMesh *mesh_get_derived_deform(
686         struct Scene *scene, struct Object *ob,
687         CustomDataMask dataMask);
688
689 DerivedMesh *mesh_create_derived_for_modifier(
690         struct Scene *scene, struct Object *ob,
691         struct ModifierData *md, int build_shapekey_layers);
692
693 DerivedMesh *mesh_create_derived_render(
694         struct Scene *scene, struct Object *ob,
695         CustomDataMask dataMask);
696
697 DerivedMesh *getEditDerivedBMesh(
698         struct BMEditMesh *em, struct Object *ob, CustomDataMask data_mask,
699         float (*vertexCos)[3]);
700
701 DerivedMesh *mesh_create_derived_index_render(
702         struct Scene *scene, struct Object *ob,
703         CustomDataMask dataMask, int index);
704
705 /* same as above but wont use render settings */
706 DerivedMesh *mesh_create_derived(struct Mesh *me, float (*vertCos)[3]);
707 DerivedMesh *mesh_create_derived_view(
708         struct Scene *scene, struct Object *ob,
709         CustomDataMask dataMask);
710 DerivedMesh *mesh_create_derived_no_deform(
711         struct Scene *scene, struct Object *ob,
712         float (*vertCos)[3],
713         CustomDataMask dataMask);
714 DerivedMesh *mesh_create_derived_no_deform_render(
715         struct Scene *scene, struct Object *ob,
716         float (*vertCos)[3],
717         CustomDataMask dataMask);
718 /* for gameengine */
719 DerivedMesh *mesh_create_derived_no_virtual(
720         struct Scene *scene, struct Object *ob, float (*vertCos)[3],
721         CustomDataMask dataMask);
722 DerivedMesh *mesh_create_derived_physics(
723         struct Scene *scene, struct Object *ob, float (*vertCos)[3],
724         CustomDataMask dataMask);
725
726 DerivedMesh *editbmesh_get_derived_base(
727         struct Object *ob, struct BMEditMesh *em, CustomDataMask data_mask);
728 DerivedMesh *editbmesh_get_derived_cage(
729         struct Scene *scene, struct Object *,
730         struct BMEditMesh *em, CustomDataMask dataMask);
731 DerivedMesh *editbmesh_get_derived_cage_and_final(
732         struct Scene *scene, struct Object *,
733         struct BMEditMesh *em, CustomDataMask dataMask,
734         DerivedMesh **r_final);
735
736 DerivedMesh *object_get_derived_final(struct Object *ob, const bool for_render);
737
738 float (*editbmesh_get_vertex_cos(struct BMEditMesh *em, int *r_numVerts))[3];
739 bool editbmesh_modifier_is_enabled(struct Scene *scene, struct ModifierData *md, DerivedMesh *dm);
740 void makeDerivedMesh(
741         struct Scene *scene, struct Object *ob, struct BMEditMesh *em,
742         CustomDataMask dataMask, const bool build_shapekey_layers);
743
744 void weight_to_rgb(float r_rgb[3], const float weight);
745 /** Update the weight MCOL preview layer.
746  * If weights are NULL, use object's active vgroup(s).
747  * Else, weights must be an array of weight float values.
748  *     If indices is NULL, it must be of numVerts length.
749  *     Else, it must be of num length, as indices, which contains vertices' idx to apply weights to.
750  *         (other vertices are assumed zero weight).
751  */
752 void DM_update_weight_mcol(
753         struct Object *ob, struct DerivedMesh *dm, int const draw_flag,
754         float *weights, int num, const int *indices);
755
756 /** convert layers requested by a GLSL material to actually available layers in
757  * the DerivedMesh, with both a pointer for arrays and an offset for editmesh */
758 typedef struct DMVertexAttribs {
759         struct {
760                 struct MLoopUV *array;
761                 int em_offset, gl_index, gl_texco, gl_info_index;
762         } tface[MAX_MTFACE];
763
764         struct {
765                 struct MLoopCol *array;
766                 int em_offset, gl_index, gl_info_index;
767         } mcol[MAX_MCOL];
768
769         struct {
770                 float (*array)[4];
771                 int em_offset, gl_index, gl_info_index;
772         } tang[MAX_MTFACE];
773
774         struct {
775                 float (*array)[3];
776                 int em_offset, gl_index, gl_texco, gl_info_index;
777         } orco;
778
779         int tottface, totmcol, tottang, totorco;
780 } DMVertexAttribs;
781
782 void DM_vertex_attributes_from_gpu(
783         DerivedMesh *dm,
784         struct GPUVertexAttribs *gattribs, DMVertexAttribs *attribs);
785
786 void DM_draw_attrib_vertex(DMVertexAttribs *attribs, int a, int index, int vert, int loop);
787 void DM_draw_attrib_vertex_uniforms(const DMVertexAttribs *attribs);
788
789 void DM_calc_tangents_names_from_gpu(
790         const struct GPUVertexAttribs *gattribs,
791         char (*tangent_names)[MAX_NAME], int *tangent_names_count);
792 void DM_add_named_tangent_layer_for_uv(
793         CustomData *uv_data, CustomData *tan_data, int numLoopData,
794         const char *layer_name);
795
796 #define DM_TANGENT_MASK_ORCO (1 << 9)
797 void DM_calc_loop_tangents_step_0(
798         const CustomData *loopData, bool calc_active_tangent,
799         const char (*tangent_names)[MAX_NAME], int tangent_names_count,
800         bool *rcalc_act, bool *rcalc_ren, int *ract_uv_n, int *rren_uv_n,
801         char *ract_uv_name, char *rren_uv_name, short *rtangent_mask);
802 void DM_calc_loop_tangents(
803         DerivedMesh *dm, bool calc_active_tangent, const char (*tangent_names)[MAX_NAME],
804         int tangent_names_count);
805 void DM_calc_auto_bump_scale(DerivedMesh *dm);
806
807 /** Set object's bounding box based on DerivedMesh min/max data */
808 void DM_set_object_boundbox(struct Object *ob, DerivedMesh *dm);
809
810 void DM_init_origspace(DerivedMesh *dm);
811
812 /* debug only */
813 #ifndef NDEBUG
814 char *DM_debug_info(DerivedMesh *dm);
815 void DM_debug_print(DerivedMesh *dm);
816 void DM_debug_print_cdlayers(CustomData *cdata);
817
818 bool DM_is_valid(DerivedMesh *dm);
819 #endif
820
821 BLI_INLINE int DM_origindex_mface_mpoly(
822         const int *index_mf_to_mpoly, const int *index_mp_to_orig, const int i) ATTR_NONNULL(1);
823
824 BLI_INLINE int DM_origindex_mface_mpoly(
825         const int *index_mf_to_mpoly, const int *index_mp_to_orig, const int i)
826 {
827         const int j = index_mf_to_mpoly[i];
828         return (j != ORIGINDEX_NONE) ? (index_mp_to_orig ? index_mp_to_orig[j] : j) : ORIGINDEX_NONE;
829 }
830
831 struct MVert *DM_get_vert_array(struct DerivedMesh *dm, bool *r_allocated);
832 struct MEdge *DM_get_edge_array(struct DerivedMesh *dm, bool *r_allocated);
833 struct MLoop *DM_get_loop_array(struct DerivedMesh *dm, bool *r_allocated);
834 struct MPoly *DM_get_poly_array(struct DerivedMesh *dm, bool *r_allocated);
835 struct MFace *DM_get_tessface_array(struct DerivedMesh *dm, bool *r_allocated);
836
837 #endif  /* __BKE_DERIVEDMESH_H__ */