Integration of the Google Summer of Code Modifier Stack Upgrade project. The
[blender.git] / source / blender / blenkernel / BKE_DerivedMesh.h
1 /**
2  * $Id$
3  *
4  * ***** BEGIN GPL/BL DUAL 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. The Blender
10  * Foundation also sells licenses for use in proprietary software under
11  * the Blender License.  See http://www.blender.org/BL/ for information
12  * about this.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program; if not, write to the Free Software Foundation,
21  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
22  *
23  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
24  * All rights reserved.
25  *
26  * The Original Code is: all of this file.
27  *
28  * Contributor(s): none yet.
29  *
30  * ***** END GPL/BL DUAL LICENSE BLOCK *****
31  */
32
33 #ifndef BKE_DERIVEDMESH_H
34 #define BKE_DERIVEDMESH_H
35
36 /* TODO (Probably)
37  *
38  *  o Make drawMapped* functions take a predicate function that
39  *    determines whether to draw the edge (this predicate can
40  *    also set color, etc). This will be slightly more general 
41  *    and allow some of the functions to be collapsed.
42  *  o Once accessor functions are added then single element draw
43  *    functions can be implemented using primitive accessors.
44  *  o Add function to dispatch to renderer instead of using
45  *    conversion to DLM.
46  */
47
48 #include "BKE_customdata.h"
49
50 struct MVert;
51 struct MEdge;
52 struct MFace;
53 struct TFace;
54 struct Object;
55 struct Mesh;
56 struct EditMesh;
57 struct DispListMesh;
58 struct ModifierData;
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         /* custom data for verts, edges & faces */
68         CustomData vertData, edgeData, faceData;
69
70         /* Misc. Queries */
71
72         /* Also called in Editmode */
73         int (*getNumVerts)(DerivedMesh *dm);
74         /* Also called in Editmode */
75         int (*getNumFaces)(DerivedMesh *dm);
76
77         int (*getNumEdges)(DerivedMesh *dm);
78
79         /* copy a single vert/edge/face from the derived mesh into
80          * *{vert/edge/face}_r
81          */
82         void (*getVert)(DerivedMesh *dm, int index, struct MVert *vert_r);
83         void (*getEdge)(DerivedMesh *dm, int index, struct MEdge *edge_r);
84         void (*getFace)(DerivedMesh *dm, int index, struct MFace *face_r);
85
86         /* copy all verts/edges/faces from the derived mesh into
87          * *{vert/edge/face}_r (must point to a buffer large enough)
88          */
89         void (*getVertArray)(DerivedMesh *dm, struct MVert *vert_r);
90         void (*getEdgeArray)(DerivedMesh *dm, struct MEdge *edge_r);
91         void (*getFaceArray)(DerivedMesh *dm, struct MFace *face_r);
92
93         /* return a copy of all verts/edges/faces from the derived mesh
94          * it is the caller's responsibility to free the returned pointer
95          */
96         struct MVert *(*dupVertArray)(DerivedMesh *dm);
97         struct MEdge *(*dupEdgeArray)(DerivedMesh *dm);
98         struct MFace *(*dupFaceArray)(DerivedMesh *dm);
99
100         /* return a pointer to a single element of vert/edge/face custom data
101          * from the derived mesh (this gives a pointer to the actual data, not
102          * a copy)
103          */
104         void *(*getVertData)(DerivedMesh *dm, int index, int type);
105         void *(*getEdgeData)(DerivedMesh *dm, int index, int type);
106         void *(*getFaceData)(DerivedMesh *dm, int index, int type);
107
108         /* return a pointer to the entire array of vert/edge/face custom data
109          * from the derived mesh (this gives a pointer to the actual data, not
110          * a copy)
111          */
112         void *(*getVertDataArray)(DerivedMesh *dm, int type);
113         void *(*getEdgeDataArray)(DerivedMesh *dm, int type);
114         void *(*getFaceDataArray)(DerivedMesh *dm, int type);
115
116         /* Iterate over each mapped vertex in the derived mesh, calling the
117          * given function with the original vert and the mapped vert's new
118          * coordinate and normal. For historical reasons the normal can be
119          * passed as a float or short array, only one should be non-NULL.
120          */
121         void (*foreachMappedVert)(
122                               DerivedMesh *dm,
123                               void (*func)(void *userData, int index, float *co,
124                                            float *no_f, short *no_s),
125                               void *userData);
126
127         /* Iterate over each mapped edge in the derived mesh, calling the
128          * given function with the original edge and the mapped edge's new
129          * coordinates.
130          */
131         void (*foreachMappedEdge)(DerivedMesh *dm,
132                                   void (*func)(void *userData, int index,
133                                                float *v0co, float *v1co),
134                                   void *userData);
135
136         /* Iterate over each mapped face in the derived mesh, calling the
137          * given function with the original face and the mapped face's (or
138          * faces') center and normal.
139          */
140         void (*foreachMappedFaceCenter)(DerivedMesh *dm,
141                                         void (*func)(void *userData, int index,
142                                                      float *cent, float *no),
143                                         void *userData);
144
145         /* Convert to new DispListMesh, should be free'd by caller.
146          *
147          * If allowShared is true then the caller is committing to not free'ng
148          * the DerivedMesh before free'ng the DispListMesh, which means that
149          * certain fields of the returned DispListMesh can safely be share with
150          * the DerivedMesh's internal data.
151          */
152         struct DispListMesh* (*convertToDispListMesh)(DerivedMesh *dm,
153                                                       int allowShared);
154
155         /* Iterate over all vertex points, calling DO_MINMAX with given args.
156          *
157          * Also called in Editmode
158          */
159         void (*getMinMax)(DerivedMesh *dm, float min_r[3], float max_r[3]);
160
161         /* Direct Access Operations */
162         /*  o Can be undefined */
163         /*  o Must be defined for modifiers that only deform however */
164
165         /* Get vertex location, undefined if index is not valid */
166         void (*getVertCo)(DerivedMesh *dm, int index, float co_r[3]);
167
168         /* Fill the array (of length .getNumVerts()) with all vertex locations */
169         void (*getVertCos)(DerivedMesh *dm, float (*cos_r)[3]);
170
171         /* Get vertex normal, undefined if index is not valid */
172         void (*getVertNo)(DerivedMesh *dm, int index, float no_r[3]);
173
174         /* Drawing Operations */
175
176         /* Draw all vertices as bgl points (no options) */
177         void (*drawVerts)(DerivedMesh *dm);
178
179         /* Draw edges in the UV mesh (if exists) */
180         void (*drawUVEdges)(DerivedMesh *dm);
181
182         /* Draw all edges as lines (no options) 
183          *
184          * Also called for *final* editmode DerivedMeshes
185          */
186         void (*drawEdges)(DerivedMesh *dm, int drawLooseEdges);
187         
188         /* Draw all loose edges (edges w/ no adjoining faces) */
189         void (*drawLooseEdges)(DerivedMesh *dm);
190
191         /* Draw all faces
192          *  o Set face normal or vertex normal based on inherited face flag
193          *  o Use inherited face material index to call setMaterial
194          *  o Only if setMaterial returns true
195          *
196          * Also called for *final* editmode DerivedMeshes
197          */
198         void (*drawFacesSolid)(DerivedMesh *dm, int (*setMaterial)(int));
199
200         /* Draw all faces
201          *  o If useTwoSided, draw front and back using col arrays
202          *  o col1,col2 are arrays of length numFace*4 of 4 component colors
203          *    in ABGR format, and should be passed as per-face vertex color.
204          */
205         void (*drawFacesColored)(DerivedMesh *dm, int useTwoSided,
206                                  unsigned char *col1, unsigned char *col2);
207
208         /* Draw all faces using TFace 
209          *  o Drawing options too complicated to enumerate, look at code.
210          */
211         void (*drawFacesTex)(DerivedMesh *dm,
212                              int (*setDrawOptions)(struct TFace *tface, int matnr));
213
214         /* Draw mapped faces (no color, or texture)
215          *  o Only if !setDrawOptions or
216          *    setDrawOptions(userData, mapped-face-index, drawSmooth_r)
217          *    returns true
218          *
219          * If drawSmooth is set to true then vertex normals should be set and
220          * glShadeModel called with GL_SMOOTH. Otherwise the face normal should
221          * be set and glShadeModel called with GL_FLAT.
222          *
223          * The setDrawOptions is allowed to not set drawSmooth (for example, when
224          * lighting is disabled), in which case the implementation should draw as
225          * smooth shaded.
226          */
227         void (*drawMappedFaces)(DerivedMesh *dm,
228                                 int (*setDrawOptions)(void *userData, int index,
229                                                       int *drawSmooth_r),
230                                 void *userData, int useColors);
231
232         /* Draw mapped faces using TFace 
233          *  o Drawing options too complicated to enumerate, look at code.
234          */
235         void (*drawMappedFacesTex)(DerivedMesh *dm,
236                                    int (*setDrawOptions)(void *userData,
237                                                          int index),
238                                    void *userData);
239
240         /* Draw mapped edges as lines
241          *  o Only if !setDrawOptions or setDrawOptions(userData, mapped-edge)
242          *    returns true
243          */
244         void (*drawMappedEdges)(DerivedMesh *dm,
245                                 int (*setDrawOptions)(void *userData, int index),
246                                 void *userData);
247
248         /* Draw mapped edges as lines with interpolation values
249          *  o Only if !setDrawOptions or
250          *    setDrawOptions(userData, mapped-edge, mapped-v0, mapped-v1, t)
251          *    returns true
252          *
253          * NOTE: This routine is optional!
254          */
255         void (*drawMappedEdgesInterp)(DerivedMesh *dm, 
256                                       int (*setDrawOptions)(void *userData,
257                                                             int index), 
258                                       void (*setDrawInterpOptions)(void *userData,
259                                                                    int index,
260                                                                    float t),
261                                       void *userData);
262
263         void (*release)(DerivedMesh *dm);
264 };
265
266 /* utility function to initialise a DerivedMesh's function pointers to
267  * the default implementation (for those functions which have a default)
268  */
269 void DM_init_funcs(DerivedMesh *dm);
270
271 /* utility function to initialise a DerivedMesh for the desired number
272  * of vertices, edges and faces (doesn't allocate memory for them, just
273  * sets up the custom data layers)
274  */
275 void DM_init(DerivedMesh *dm, int numVerts, int numEdges, int numFaces);
276
277 /* utility function to initialise a DerivedMesh for the desired number
278  * of vertices, edges and faces, with a layer setup copied from source
279  */
280 void DM_from_template(DerivedMesh *dm, DerivedMesh *source,
281                       int numVerts, int numEdges, int numFaces);
282
283 /* utility function to release a DerivedMesh's layers
284  */
285 void DM_release(DerivedMesh *dm);
286
287 /* utility function to convert a DerivedMesh to a Mesh
288  */
289 void DM_to_mesh(DerivedMesh *dm, struct Mesh *me);
290
291 /* adds a vertex/edge/face custom data layer to a DerivedMesh, optionally
292  * backed by an external data array
293  * if layer != NULL, it is used as the layer data array, otherwise new memory
294  * is allocated
295  * the layer data will be freed by dm->release unless
296  * (flag & LAYERFLAG_NOFREE) is true
297  */
298 void DM_add_vert_layer(struct DerivedMesh *dm, int type, int flag,
299                        void *layer);
300 void DM_add_edge_layer(struct DerivedMesh *dm, int type, int flag,
301                        void *layer);
302 void DM_add_face_layer(struct DerivedMesh *dm, int type, int flag,
303                        void *layer);
304
305 /* custom data access functions
306  * return pointer to data from first layer which matches type
307  * if they return NULL for valid indices, data doesn't exist
308  * note these return pointers - any change modifies the internals of the mesh
309  */
310 void *DM_get_vert_data(struct DerivedMesh *dm, int index, int type);
311 void *DM_get_edge_data(struct DerivedMesh *dm, int index, int type);
312 void *DM_get_face_data(struct DerivedMesh *dm, int index, int type);
313
314 /* custom data layer access functions
315  * return pointer to first data layer which matches type (a flat array)
316  * if they return NULL, data doesn't exist
317  * note these return pointers - any change modifies the internals of the mesh
318  */
319 void *DM_get_vert_data_layer(struct DerivedMesh *dm, int type);
320 void *DM_get_edge_data_layer(struct DerivedMesh *dm, int type);
321 void *DM_get_face_data_layer(struct DerivedMesh *dm, int type);
322
323 /* custom data setting functions
324  * copy supplied data into first layer of type using layer's copy function
325  * (deep copy if appropriate)
326  */
327 void DM_set_vert_data(struct DerivedMesh *dm, int index, int type, void *data);
328 void DM_set_edge_data(struct DerivedMesh *dm, int index, int type, void *data);
329 void DM_set_face_data(struct DerivedMesh *dm, int index, int type, void *data);
330
331 /* custom data copy functions
332  * copy count elements from source_index in source to dest_index in dest
333  * these copy all layers for which the LAYERFLAG_NOCOPY flag is not set
334  */
335 void DM_copy_vert_data(struct DerivedMesh *source, struct DerivedMesh *dest,
336                        int source_index, int dest_index, int count);
337 void DM_copy_edge_data(struct DerivedMesh *source, struct DerivedMesh *dest,
338                        int source_index, int dest_index, int count);
339 void DM_copy_face_data(struct DerivedMesh *source, struct DerivedMesh *dest,
340                        int source_index, int dest_index, int count);
341
342 /* custom data free functions
343  * free count elements, starting at index
344  * they free all layers for which the LAYERFLAG_NOFREE flag is not set
345  */
346 void DM_free_vert_data(struct DerivedMesh *dm, int index, int count);
347 void DM_free_edge_data(struct DerivedMesh *dm, int index, int count);
348 void DM_free_face_data(struct DerivedMesh *dm, int index, int count);
349
350 /* interpolates vertex data from the vertices indexed by src_indices in the
351  * source mesh using the given weights and stores the result in the vertex
352  * indexed by dest_index in the dest mesh
353  */
354 void DM_interp_vert_data(struct DerivedMesh *source, struct DerivedMesh *dest,
355                          int *src_indices, float *weights,
356                          int count, int dest_index);
357
358 /* interpolates edge data from the edges indexed by src_indices in the
359  * source mesh using the given weights and stores the result in the edge indexed
360  * by dest_index in the dest mesh.
361  * if weights is NULL, all weights default to 1.
362  * if vert_weights is non-NULL, any per-vertex edge data is interpolated using
363  * vert_weights[i] multiplied by weights[i].
364  */
365 typedef float EdgeVertWeight[SUB_ELEMS_EDGE][SUB_ELEMS_EDGE];
366 void DM_interp_edge_data(struct DerivedMesh *source, struct DerivedMesh *dest,
367                          int *src_indices,
368                          float *weights, EdgeVertWeight *vert_weights,
369                          int count, int dest_index);
370
371 /* interpolates face data from the faces indexed by src_indices in the
372  * source mesh using the given weights and stores the result in the face indexed
373  * by dest_index in the dest mesh.
374  * if weights is NULL, all weights default to 1.
375  * if vert_weights is non-NULL, any per-vertex face data is interpolated using
376  * vert_weights[i] multiplied by weights[i].
377  */
378 typedef float FaceVertWeight[SUB_ELEMS_FACE][SUB_ELEMS_FACE];
379 void DM_interp_face_data(struct DerivedMesh *source, struct DerivedMesh *dest,
380                          int *src_indices,
381                          float *weights, FaceVertWeight *vert_weights,
382                          int count, int dest_index);
383
384     /* Simple function to get me->totvert amount of vertices/normals,
385        correctly deformed and subsurfered. Needed especially when vertexgroups are involved.
386        In use now by vertex/weigt paint and particles */
387 float *mesh_get_mapped_verts_nors(struct Object *ob);
388
389         /* Internal function, just temporarily exposed */
390 DerivedMesh *derivedmesh_from_displistmesh(struct DispListMesh *dlm, float (*vertexCos)[3]);
391
392 DerivedMesh *mesh_get_derived_final(struct Object *ob, int *needsFree_r);
393 DerivedMesh *mesh_get_derived_deform(struct Object *ob, int *needsFree_r);
394
395 DerivedMesh *mesh_create_derived_for_modifier(struct Object *ob, struct ModifierData *md);
396
397 DerivedMesh *mesh_create_derived_render(struct Object *ob);
398 DerivedMesh *mesh_create_derived_no_deform(struct Object *ob, float (*vertCos)[3]);
399 DerivedMesh *mesh_create_derived_no_deform_render(struct Object *ob, float (*vertCos)[3]);
400
401 DerivedMesh *editmesh_get_derived_base(void);
402 DerivedMesh *editmesh_get_derived_cage(int *needsFree_r);
403 DerivedMesh *editmesh_get_derived_cage_and_final(DerivedMesh **final_r, int *cageNeedsFree_r, int *finalNeedsFree_r);
404
405 #endif
406