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