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