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