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