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