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