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