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