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