this someone didn't get committed
[blender-staging.git] / source / blender / blenkernel / BKE_DerivedMesh.h
1 /**
2  * $Id$
3  *
4  * ***** BEGIN GPL LICENSE BLOCK *****
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * as published by the Free Software Foundation; either version 2
9  * of the License, or (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software Foundation,
18  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
19  *
20  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
21  * All rights reserved.
22  *
23  * The Original Code is: all of this file.
24  *
25  * Contributor(s): none yet.
26  *
27  * ***** END GPL LICENSE BLOCK *****
28  */
29
30 #ifndef BKE_DERIVEDMESH_H
31 #define BKE_DERIVEDMESH_H
32
33 /*
34   Basic design of the DerivedMesh system:
35
36   DerivedMesh is a common set of interfaces for mesh systems.
37
38   There are three main mesh data structures in Blender: Mesh, CDDM, and BMesh.
39   These, and a few others, all implement DerivedMesh interfaces, 
40   which contains unified drawing interfaces, a few utility interfaces, 
41   and a bunch of read-only interfaces intended mostly for conversion from 
42   one format to another.
43
44   All Mesh structures in blender make use of CustomData, which is used to store
45   per-element attributes and interpolate them (e.g. uvs, vcols, vgroups, etc).
46   
47   Mesh is the "serialized" structure, used for storing object-mode mesh data
48   and also for saving stuff to disk.  It's interfaces are also what DerivedMesh
49   uses to communicate with.
50   
51   CDDM is a little mesh library, that uses Mesh data structures in the backend.
52   It's mostly used for modifiers, and has the advantages of not taking much
53   resources.
54
55   BMesh is a full-on brep, used for editmode, some modifiers, etc.  It's much
56   more capable (if memory-intensive) then CDDM.
57
58   DerivedMesh is somewhat hackish.  Many places assumes that a DerivedMesh is
59   a CDDM (most of the time by simply copying it and converting it to one).
60   CDDM is the original structure for modifiers, but has since been superseded
61   by BMesh, at least for the foreseeable future.
62 */
63
64 /* 
65  * Note: This sturcture is read-only, for all practical purposes.
66  *       At some point in the future, we may want to consider
67  *       creating a replacement structure that implements a proper
68  *       abstract mesh kernel interface.  Or, we can leave this
69  *       as it is and stick with using BMesh and CDDM.
70  */
71
72 /* TODO (Probably)
73  *
74  *  o Make drawMapped* functions take a predicate function that
75  *    determines whether to draw the edge (this predicate can
76  *    also set color, etc). This will be slightly more general 
77  *    and allow some of the functions to be collapsed.
78  *  o Once accessor functions are added then single element draw
79  *    functions can be implemented using primitive accessors.
80  *  o Add function to dispatch to renderer instead of using
81  *    conversion to DLM.
82  */
83
84 #include "DNA_customdata_types.h"
85 #include "DNA_meshdata_types.h"
86
87 #include "BKE_customdata.h"
88 #include "BKE_bvhutils.h"
89
90 struct MVert;
91 struct MEdge;
92 struct MFace;
93 struct MTFace;
94 struct Object;
95 struct Scene;
96 struct Mesh;
97 struct BMEditMesh;
98 struct ModifierData;
99 struct MCol;
100 struct ColorBand;
101 struct GPUVertexAttribs;
102 struct GPUDrawObject;
103 struct BMEditMesh;
104
105 /* number of sub-elements each mesh element has (for interpolation) */
106 #define SUB_ELEMS_VERT 0
107 #define SUB_ELEMS_EDGE 2
108 #define SUB_ELEMS_FACE 50
109
110 /*
111 Note: all mface interfaces now officially operate on tesselated data.
112       Also, the mface origindex layer indexes mpolys, not mfaces.
113 */
114
115 /*DM Iterators.  For now, first implement face iterators.
116   These are read-only, at least for now.*/
117
118 typedef struct DMLoopIter {
119         void (*step)(void *self);
120         int done;
121
122         int index, vindex, eindex;
123         MVert v; /*copy of the associated vert's data*/ 
124
125         /*note: if layer is -1, then the active layer is retrieved.
126           loop refers to per-face-vertex data.*/
127         void *(*getLoopCDData)(void *self, int type, int layer);
128         void *(*getVertCDData)(void *self, int type, int layer);
129         
130 /* derivedmesh 2.0 interface ideas (will likely never be implemented ;):
131         void (*interpLoopData)(void *self, void **src_blocks, 
132                                float *weights, float *sub_weights, int count);
133
134         //a generic handle for a loop
135         intptr_t lhandle;
136
137         inside DerivedMesh itself:
138         //
139         //void (*interpLoopData)(DerivedMesh *dm, DMLoopIter *destloop, 
140         //                       intptr_t *loop_handles, int totloop);
141 */
142 } DMLoopIter;
143
144 typedef struct DMFaceIter {
145         void (*step)(void *self);
146         void (*free)(void *self);
147         int done;
148
149         int index;
150         int len;
151         int mat_nr;
152         int flags;
153
154         /*note: you may only use one
155           loop iterator at a time.*/
156         DMLoopIter *(*getLoopsIter)(void *self);
157
158         /*if layer is -1, returns active layer*/
159         void *(*getCDData)(void *self, int type, int layer);
160 } DMFaceIter;
161
162 typedef struct DerivedMesh DerivedMesh;
163 struct DerivedMesh {
164         /* Private DerivedMesh data, only for internal DerivedMesh use */
165         CustomData vertData, edgeData, faceData, loopData, polyData;
166         int numVertData, numEdgeData, numFaceData, numLoopData, numPolyData;
167         int needsFree; /* checked on ->release, is set to 0 for cached results */
168         int deformedOnly; /* set by modifier stack if only deformed from original */
169         BVHCache bvhCache;
170         struct GPUDrawObject *drawObject;
171
172         /* Misc. Queries */
173         
174         /*face iterator.  initializes iter.*/
175         DMFaceIter *(*newFaceIter)(DerivedMesh *dm);
176
177         /*recalculates mesh tesselation*/
178         void (*recalcTesselation)(DerivedMesh *dm);
179
180         /* Also called in Editmode */
181         int (*getNumVerts)(DerivedMesh *dm);
182         int (*getNumEdges)(DerivedMesh *dm);
183         int (*getNumTessFaces)(DerivedMesh *dm);
184         int (*getNumFaces) (DerivedMesh *dm);
185
186         /* copy a single vert/edge/tesselated face from the derived mesh into
187          * *{vert/edge/face}_r. note that the current implementation
188          * of this function can be quite slow, iterating over all
189          * elements (editmesh)
190          */
191         void (*getVert)(DerivedMesh *dm, int index, struct MVert *vert_r);
192         void (*getEdge)(DerivedMesh *dm, int index, struct MEdge *edge_r);
193         void (*getTessFace)(DerivedMesh *dm, int index, struct MFace *face_r);
194
195         /* return a pointer to the entire array of verts/edges/face from the
196          * derived mesh. if such an array does not exist yet, it will be created,
197          * and freed on the next ->release(). consider using getVert/Edge/Face if
198          * you are only interested in a few verts/edges/faces.
199          */
200         struct MVert *(*getVertArray)(DerivedMesh *dm);
201         struct MEdge *(*getEdgeArray)(DerivedMesh *dm);
202         struct MFace *(*getTessFaceArray)(DerivedMesh *dm);
203
204         /* copy all verts/edges/faces from the derived mesh into
205          * *{vert/edge/face}_r (must point to a buffer large enough)
206          */
207         void (*copyVertArray)(DerivedMesh *dm, struct MVert *vert_r);
208         void (*copyEdgeArray)(DerivedMesh *dm, struct MEdge *edge_r);
209         void (*copyTessFaceArray)(DerivedMesh *dm, struct MFace *face_r);
210
211         /* return a copy of all verts/edges/faces from the derived mesh
212          * it is the caller's responsibility to free the returned pointer
213          */
214         struct MVert *(*dupVertArray)(DerivedMesh *dm);
215         struct MEdge *(*dupEdgeArray)(DerivedMesh *dm);
216         struct MFace *(*dupTessFaceArray)(DerivedMesh *dm);
217
218         /* return a pointer to a single element of vert/edge/face custom data
219          * from the derived mesh (this gives a pointer to the actual data, not
220          * a copy)
221          */
222         void *(*getVertData)(DerivedMesh *dm, int index, int type);
223         void *(*getEdgeData)(DerivedMesh *dm, int index, int type);
224         void *(*getTessFaceData)(DerivedMesh *dm, int index, int type);
225
226         /* return a pointer to the entire array of vert/edge/face custom data
227          * from the derived mesh (this gives a pointer to the actual data, not
228          * a copy)
229          */
230         void *(*getVertDataArray)(DerivedMesh *dm, int type);
231         void *(*getEdgeDataArray)(DerivedMesh *dm, int type);
232         void *(*getTessFaceDataArray)(DerivedMesh *dm, int type);
233         
234         /*retrieves the base CustomData structures for 
235           verts/edges/tessfaces/loops/facdes*/
236         CustomData *(*getVertDataLayout)(DerivedMesh *dm);
237         CustomData *(*getEdgeDataLayout)(DerivedMesh *dm);
238         CustomData *(*getTessFaceDataLayout)(DerivedMesh *dm);
239         CustomData *(*getLoopDataLayout)(DerivedMesh *dm);
240         CustomData *(*getFaceDataLayout)(DerivedMesh *dm);
241         
242         /*copies all customdata for an element source into dst at index dest*/
243         void (*copyFromVertCData)(DerivedMesh *dm, int source, CustomData *dst, int dest);
244         void (*copyFromEdgeCData)(DerivedMesh *dm, int source, CustomData *dst, int dest);
245         void (*copyFromFaceCData)(DerivedMesh *dm, int source, CustomData *dst, int dest);
246         
247         /* Iterate over each mapped vertex in the derived mesh, calling the
248          * given function with the original vert and the mapped vert's new
249          * coordinate and normal. For historical reasons the normal can be
250          * passed as a float or short array, only one should be non-NULL.
251          */
252         void (*foreachMappedVert)(
253                               DerivedMesh *dm,
254                               void (*func)(void *userData, int index, float *co,
255                                            float *no_f, short *no_s),
256                               void *userData);
257
258         /* Iterate over each mapped edge in the derived mesh, calling the
259          * given function with the original edge and the mapped edge's new
260          * coordinates.
261          */
262         void (*foreachMappedEdge)(DerivedMesh *dm,
263                                   void (*func)(void *userData, int index,
264                                                float *v0co, float *v1co),
265                                   void *userData);
266
267         /* Iterate over each mapped face in the derived mesh, calling the
268          * given function with the original face and the mapped face's (or
269          * faces') center and normal.
270          */
271         void (*foreachMappedFaceCenter)(DerivedMesh *dm,
272                                         void (*func)(void *userData, int index,
273                                                      float *cent, float *no),
274                                         void *userData);
275
276         /* Iterate over all vertex points, calling DO_MINMAX with given args.
277          *
278          * Also called in Editmode
279          */
280         void (*getMinMax)(DerivedMesh *dm, float min_r[3], float max_r[3]);
281
282         /* Direct Access Operations */
283         /*  o Can be undefined */
284         /*  o Must be defined for modifiers that only deform however */
285
286         /* Get vertex location, undefined if index is not valid */
287         void (*getVertCo)(DerivedMesh *dm, int index, float co_r[3]);
288
289         /* Fill the array (of length .getNumVerts()) with all vertex locations */
290         void (*getVertCos)(DerivedMesh *dm, float (*cos_r)[3]);
291
292         /* Get vertex normal, undefined if index is not valid */
293         void (*getVertNo)(DerivedMesh *dm, int index, float no_r[3]);
294
295         /* Drawing Operations */
296
297         /* Draw all vertices as bgl points (no options) */
298         void (*drawVerts)(DerivedMesh *dm);
299
300         /* Draw edges in the UV mesh (if exists) */
301         void (*drawUVEdges)(DerivedMesh *dm);
302
303         /* Draw all edges as lines (no options) 
304          *
305          * Also called for *final* editmode DerivedMeshes
306          */
307         void (*drawEdges)(DerivedMesh *dm, int drawLooseEdges);
308         
309         /* Draw all loose edges (edges w/ no adjoining faces) */
310         void (*drawLooseEdges)(DerivedMesh *dm);
311
312         /* Draw all faces
313          *  o Set face normal or vertex normal based on inherited face flag
314          *  o Use inherited face material index to call setMaterial
315          *  o Only if setMaterial returns true
316          *
317          * Also called for *final* editmode DerivedMeshes
318          */
319         void (*drawFacesSolid)(DerivedMesh *dm,
320                                int (*setMaterial)(int, void *attribs));
321
322         /* Draw all faces
323          *  o If useTwoSided, draw front and back using col arrays
324          *  o col1,col2 are arrays of length numFace*4 of 4 component colors
325          *    in ABGR format, and should be passed as per-face vertex color.
326          */
327         void (*drawFacesColored)(DerivedMesh *dm, int useTwoSided,
328                                  unsigned char *col1, unsigned char *col2);
329
330         /* Draw all faces using MTFace 
331          *  o Drawing options too complicated to enumerate, look at code.
332          */
333         void (*drawFacesTex)(DerivedMesh *dm,
334                              int (*setDrawOptions)(struct MTFace *tface,
335                              int has_vcol, int matnr));
336
337         /* Draw all faces with GLSL materials
338          *  o setMaterial is called for every different material nr
339          *  o Only if setMaterial returns true
340          */
341         void (*drawFacesGLSL)(DerivedMesh *dm,
342                 int (*setMaterial)(int, void *attribs));
343
344         /* Draw mapped faces (no color, or texture)
345          *  o Only if !setDrawOptions or
346          *    setDrawOptions(userData, mapped-face-index, drawSmooth_r)
347          *    returns true
348          *
349          * If drawSmooth is set to true then vertex normals should be set and
350          * glShadeModel called with GL_SMOOTH. Otherwise the face normal should
351          * be set and glShadeModel called with GL_FLAT.
352          *
353          * The setDrawOptions is allowed to not set drawSmooth (for example, when
354          * lighting is disabled), in which case the implementation should draw as
355          * smooth shaded.
356          */
357         void (*drawMappedFaces)(DerivedMesh *dm,
358                                 int (*setDrawOptions)(void *userData, int index,
359                                                       int *drawSmooth_r),
360                                 void *userData, int useColors);
361
362         /* Draw mapped faces using MTFace 
363          *  o Drawing options too complicated to enumerate, look at code.
364          */
365         void (*drawMappedFacesTex)(DerivedMesh *dm,
366                                    int (*setDrawOptions)(void *userData,
367                                                          int index),
368                                    void *userData);
369
370         /* Draw mapped faces with GLSL materials
371          *  o setMaterial is called for every different material nr
372          *  o setDrawOptions is called for every face
373          *  o Only if setMaterial and setDrawOptions return true
374          */
375         void (*drawMappedFacesGLSL)(DerivedMesh *dm,
376                 int (*setMaterial)(int, void *attribs),
377                 int (*setDrawOptions)(void *userData, int index), void *userData);
378
379         /* Draw mapped edges as lines
380          *  o Only if !setDrawOptions or setDrawOptions(userData, mapped-edge)
381          *    returns true
382          */
383         void (*drawMappedEdges)(DerivedMesh *dm,
384                                 int (*setDrawOptions)(void *userData, int index),
385                                 void *userData);
386
387         /* Draw mapped edges as lines with interpolation values
388          *  o Only if !setDrawOptions or
389          *    setDrawOptions(userData, mapped-edge, mapped-v0, mapped-v1, t)
390          *    returns true
391          *
392          * NOTE: This routine is optional!
393          */
394         void (*drawMappedEdgesInterp)(DerivedMesh *dm, 
395                                       int (*setDrawOptions)(void *userData,
396                                                             int index), 
397                                       void (*setDrawInterpOptions)(void *userData,
398                                                                    int index,
399                                                                    float t),
400                                       void *userData);
401
402         /* Release reference to the DerivedMesh. This function decides internally
403          * if the DerivedMesh will be freed, or cached for later use. */
404         void (*release)(DerivedMesh *dm);
405 };
406
407 /* utility function to initialise a DerivedMesh's function pointers to
408  * the default implementation (for those functions which have a default)
409  */
410 void DM_init_funcs(DerivedMesh *dm);
411
412 /* utility function to initialise a DerivedMesh for the desired number
413  * of vertices, edges and faces (doesn't allocate memory for them, just
414  * sets up the custom data layers)
415  */
416 void DM_init(DerivedMesh *dm, int numVerts, int numEdges, int numFaces,
417              int numLoops, int numPolys);
418
419 /* utility function to initialise a DerivedMesh for the desired number
420  * of vertices, edges and faces, with a layer setup copied from source
421  */
422 void DM_from_template(DerivedMesh *dm, DerivedMesh *source,
423                       int numVerts, int numEdges, int numFaces,
424                       int numLoops, int numPolys);
425
426 /* utility function to release a DerivedMesh's layers
427  * returns 1 if DerivedMesh has to be released by the backend, 0 otherwise
428  */
429 int DM_release(DerivedMesh *dm);
430
431 /* utility function to convert a DerivedMesh to a Mesh
432  */
433 void DM_to_mesh(DerivedMesh *dm, struct Mesh *me);
434
435 /* set the CD_FLAG_NOCOPY flag in custom data layers where the mask is
436  * zero for the layer type, so only layer types specified by the mask
437  * will be copied
438  */
439 void DM_set_only_copy(DerivedMesh *dm, CustomDataMask mask);
440
441 /* adds a vertex/edge/face custom data layer to a DerivedMesh, optionally
442  * backed by an external data array
443  * alloctype defines how the layer is allocated or copied, and how it is
444  * freed, see BKE_customdata.h for the different options
445  */
446 void DM_add_vert_layer(struct DerivedMesh *dm, int type, int alloctype,
447                        void *layer);
448 void DM_add_edge_layer(struct DerivedMesh *dm, int type, int alloctype,
449                        void *layer);
450 void DM_add_tessface_layer(struct DerivedMesh *dm, int type, int alloctype,
451                        void *layer);
452 void DM_add_face_layer(struct DerivedMesh *dm, int type, int alloctype,
453                        void *layer);
454
455 /* custom data access functions
456  * return pointer to data from first layer which matches type
457  * if they return NULL for valid indices, data doesn't exist
458  * note these return pointers - any change modifies the internals of the mesh
459  */
460 void *DM_get_vert_data(struct DerivedMesh *dm, int index, int type);
461 void *DM_get_edge_data(struct DerivedMesh *dm, int index, int type);
462 void *DM_get_face_data(struct DerivedMesh *dm, int index, int type);
463
464 /* custom data layer access functions
465  * return pointer to first data layer which matches type (a flat array)
466  * if they return NULL, data doesn't exist
467  * note these return pointers - any change modifies the internals of the mesh
468  */
469 void *DM_get_vert_data_layer(struct DerivedMesh *dm, int type);
470 void *DM_get_edge_data_layer(struct DerivedMesh *dm, int type);
471 void *DM_get_tessface_data_layer(struct DerivedMesh *dm, int type);
472 void *DM_get_face_data_layer(struct DerivedMesh *dm, int type);
473
474 /* custom data setting functions
475  * copy supplied data into first layer of type using layer's copy function
476  * (deep copy if appropriate)
477  */
478 void DM_set_vert_data(struct DerivedMesh *dm, int index, int type, void *data);
479 void DM_set_edge_data(struct DerivedMesh *dm, int index, int type, void *data);
480 void DM_set_face_data(struct DerivedMesh *dm, int index, int type, void *data);
481
482 /* custom data copy functions
483  * copy count elements from source_index in source to dest_index in dest
484  * these copy all layers for which the CD_FLAG_NOCOPY flag is not set
485  */
486 void DM_copy_vert_data(struct DerivedMesh *source, struct DerivedMesh *dest,
487                        int source_index, int dest_index, int count);
488 void DM_copy_edge_data(struct DerivedMesh *source, struct DerivedMesh *dest,
489                        int source_index, int dest_index, int count);
490 void DM_copy_tessface_data(struct DerivedMesh *source, struct DerivedMesh *dest,
491                        int source_index, int dest_index, int count);
492 void DM_copy_loop_data(struct DerivedMesh *source, struct DerivedMesh *dest,
493                        int source_index, int dest_index, int count);
494 void DM_copy_face_data(struct DerivedMesh *source, struct DerivedMesh *dest,
495                        int source_index, int dest_index, int count);
496
497 /* custom data free functions
498  * free count elements, starting at index
499  * they free all layers for which the CD_FLAG_NOCOPY flag is not set
500  */
501 void DM_free_vert_data(struct DerivedMesh *dm, int index, int count);
502 void DM_free_edge_data(struct DerivedMesh *dm, int index, int count);
503 void DM_free_tessface_data(struct DerivedMesh *dm, int index, int count);
504 void DM_free_loop_data(struct DerivedMesh *dm, int index, int count);
505 void DM_free_face_data(struct DerivedMesh *dm, int index, int count);
506
507 /*sets up mpolys for a DM based on face iterators in source*/
508 void DM_DupPolys(DerivedMesh *source, DerivedMesh *target);
509
510 /* interpolates vertex data from the vertices indexed by src_indices in the
511  * source mesh using the given weights and stores the result in the vertex
512  * indexed by dest_index in the dest mesh
513  */
514 void DM_interp_vert_data(struct DerivedMesh *source, struct DerivedMesh *dest,
515                          int *src_indices, float *weights,
516                          int count, int dest_index);
517
518 /* interpolates edge data from the edges indexed by src_indices in the
519  * source mesh using the given weights and stores the result in the edge indexed
520  * by dest_index in the dest mesh.
521  * if weights is NULL, all weights default to 1.
522  * if vert_weights is non-NULL, any per-vertex edge data is interpolated using
523  * vert_weights[i] multiplied by weights[i].
524  */
525 typedef float EdgeVertWeight[SUB_ELEMS_EDGE][SUB_ELEMS_EDGE];
526 void DM_interp_edge_data(struct DerivedMesh *source, struct DerivedMesh *dest,
527                          int *src_indices,
528                          float *weights, EdgeVertWeight *vert_weights,
529                          int count, int dest_index);
530
531 /* interpolates face data from the faces indexed by src_indices in the
532  * source mesh using the given weights and stores the result in the face indexed
533  * by dest_index in the dest mesh.
534  * if weights is NULL, all weights default to 1.
535  * if vert_weights is non-NULL, any per-vertex face data is interpolated using
536  * vert_weights[i] multiplied by weights[i].
537  */
538 typedef float FaceVertWeight[SUB_ELEMS_FACE][SUB_ELEMS_FACE];
539 void DM_interp_tessface_data(struct DerivedMesh *source, struct DerivedMesh *dest,
540                          int *src_indices,
541                          float *weights, FaceVertWeight *vert_weights,
542                          int count, int dest_index);
543
544 void DM_swap_tessface_data(struct DerivedMesh *dm, int index, int *corner_indices);
545
546 void DM_interp_loop_data(struct DerivedMesh *source, struct DerivedMesh *dest,
547                          int *src_indices,
548                          float *weights, int count, int dest_index);
549
550 void DM_interp_face_data(struct DerivedMesh *source, struct DerivedMesh *dest,
551                          int *src_indices,
552                          float *weights, int count, int dest_index);
553
554 /* Temporary? A function to give a colorband to derivedmesh for vertexcolor ranges */
555 void vDM_ColorBand_store(struct ColorBand *coba);
556
557 /* Simple function to get me->totvert amount of vertices/normals,
558    correctly deformed and subsurfered. Needed especially when vertexgroups are involved.
559    In use now by vertex/weigt paint and particles */
560 float *mesh_get_mapped_verts_nors(struct Scene *scene, struct Object *ob);
561
562         /* */
563 DerivedMesh *mesh_get_derived_final(struct Scene *scene, struct Object *ob,
564                                     CustomDataMask dataMask);
565 DerivedMesh *mesh_get_derived_deform(struct Scene *scene, struct Object *ob,
566                                      CustomDataMask dataMask);
567
568 DerivedMesh *mesh_create_derived_for_modifier(struct Scene *scene, struct Object *ob, struct ModifierData *md);
569
570 DerivedMesh *mesh_create_derived_render(struct Scene *scene, struct Object *ob,
571                                         CustomDataMask dataMask);
572
573 DerivedMesh *getEditDerivedBMesh(struct BMEditMesh *em, struct Object *ob,
574                                            float (*vertexCos)[3]);
575
576 DerivedMesh *mesh_create_derived_index_render(struct Scene *scene, struct Object *ob, CustomDataMask dataMask, int index);
577
578                 /* same as above but wont use render settings */
579 DerivedMesh *mesh_create_derived_view(struct Scene *scene, struct Object *ob,
580                                       CustomDataMask dataMask);
581 DerivedMesh *mesh_create_derived_no_deform(struct Scene *scene, struct Object *ob,
582                                            float (*vertCos)[3],
583                                            CustomDataMask dataMask);
584 DerivedMesh *mesh_create_derived_no_deform_render(struct Scene *scene, struct Object *ob,
585                                                   float (*vertCos)[3],
586                                                   CustomDataMask dataMask);
587 /* for gameengine */
588 DerivedMesh *mesh_create_derived_no_virtual(struct Scene *scene, struct Object *ob, float (*vertCos)[3],
589                                             CustomDataMask dataMask);
590
591 DerivedMesh *editbmesh_get_derived_base(struct Object *, struct BMEditMesh *em);
592 DerivedMesh *editbmesh_get_derived_cage(struct Scene *scene, struct Object *, 
593                                                                            struct BMEditMesh *em, CustomDataMask dataMask);
594 DerivedMesh *editbmesh_get_derived_cage_and_final(struct Scene *scene, struct Object *, 
595                                                  struct BMEditMesh *em, DerivedMesh **final_r,
596                                                  CustomDataMask dataMask);
597 void makeDerivedMesh(struct Scene *scene, struct Object *ob, struct BMEditMesh *em, CustomDataMask dataMask);
598
599 /* returns an array of deform matrices for crazyspace correction, and the
600    number of modifiers left */
601 int editbmesh_get_first_deform_matrices(struct Object *, struct BMEditMesh *em, float (**deformmats)[3][3],
602                                        float (**deformcos)[3]);
603
604 void weight_to_rgb(float input, float *fr, float *fg, float *fb);
605
606 /* convert layers requested by a GLSL material to actually available layers in
607  * the DerivedMesh, with both a pointer for arrays and an offset for editmesh */
608 typedef struct DMVertexAttribs {
609         struct {
610                 struct MTFace *array;
611                 int emOffset, glIndex;
612         } tface[MAX_MTFACE];
613
614         struct {
615                 struct MCol *array;
616                 int emOffset, glIndex;
617         } mcol[MAX_MCOL];
618
619         struct {
620                 float (*array)[3];
621                 int emOffset, glIndex;
622         } tang;
623
624         struct {
625                 float (*array)[3];
626                 int emOffset, glIndex;
627         } orco;
628
629         int tottface, totmcol, tottang, totorco;
630 } DMVertexAttribs;
631
632 void DM_vertex_attributes_from_gpu(DerivedMesh *dm,
633         struct GPUVertexAttribs *gattribs, DMVertexAttribs *attribs);
634
635 void DM_add_tangent_layer(DerivedMesh *dm);
636
637 #endif
638