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