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