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