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