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