-> Fix for last few commits
[blender.git] / source / blender / blenkernel / BKE_bmesh.h
1 /**
2  * BKE_bmesh.h    jan 2007
3  *
4  *      BMesh modeler structure and functions.
5  *
6  * $Id: BKE_bmesh.h,v 1.00 2007/01/17 17:42:01 Briggs Exp $
7  *
8  * ***** BEGIN GPL LICENSE BLOCK *****
9  *
10  * This program is free software; you can redistribute it and/or
11  * modify it under the terms of the GNU General Public License
12  * as published by the Free Software Foundation; either version 2
13  * of the License, or (at your option) any later version. The Blender
14  * Foundation also sells licenses for use in proprietary software under
15  * the Blender License.  See http://www.blender.org/BL/ for information
16  * about this.  
17  *
18  * This program is distributed in the hope that it will be useful,
19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
21  * GNU General Public License for more details.
22  *
23  * You should have received a copy of the GNU General Public License
24  * along with this program; if not, write to the Free Software Foundation,
25  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
26  *
27  * The Original Code is Copyright (C) 2004 Blender Foundation.
28  * All rights reserved.
29  *
30  * The Original Code is: all of this file.
31  *
32  * Contributor(s): Geoffrey Bantle.
33  *
34  * ***** END GPL LICENSE BLOCK *****
35  */
36
37 #ifndef BKE_BMESH_H
38 #define BKE_BMESH_H
39
40 #include "DNA_listBase.h"
41 #include "BLI_ghash.h"
42 #include "BLI_memarena.h"
43 #include "DNA_customdata_types.h"
44 #include "DNA_image_types.h"
45 #include "BLI_editVert.h"
46 #include "BKE_DerivedMesh.h"
47 #include "transform.h"
48
49 /*forward declerations*/
50 struct BME_Vert;
51 struct BME_Edge;
52 struct BME_Poly;
53 struct BME_Loop;
54
55
56 /*structure for fast memory allocation/frees*/
57 typedef struct BME_mempool{
58         struct ListBase chunks;
59         int esize, csize, pchunk;               /*size of elements and chunks in bytes and number of elements per chunk*/
60         struct BME_freenode     *free;          /*free element list. Interleaved into chunk datas.*/
61 }BME_mempool;
62
63 /*Custom Data Types and defines
64         Eventual plan is to move almost everything to custom data and let caller
65         decide when making the mesh what layers they want to store in the mesh
66
67         This stuff should probably go in a seperate file....
68 */
69 typedef struct BME_CustomDataLayer {
70         int type;                                       /* type of data in layer */
71         int offset;                                     /* offset of layer in block */
72         int active;                                     /* offset of active layer*/
73         char name[32];                                  /* layer name */
74 } BME_CustomDataLayer;
75
76 typedef struct BME_CustomData {
77         BME_CustomDataLayer *layers;    /*Custom Data Layers*/
78         BME_mempool *pool;                              /*pool for alloc of blocks*/
79         int totlayer, totsize;          /*total layers and total size in bytes of each block*/
80 } BME_CustomData;
81
82 #define BME_CD_FACETEX          1               /*Image texture/texface*/
83 #define BME_CD_LOOPTEX          2               /*UV coordinates*/
84 #define BME_CD_LOOPCOL          3               /*Vcolors*/
85 #define BME_CD_DEFORMVERT       4               /*Vertex Group/Weights*/
86 #define BME_CD_NUMTYPES         5
87
88 typedef struct BME_DeformWeight {
89         int                             def_nr;
90         float                   weight;
91 } BME_DeformWeight;
92
93 typedef struct BME_DeformVert {
94         struct BME_DeformWeight *dw;
95         int totweight;
96 } BME_DeformVert;
97
98 typedef struct BME_facetex{
99         struct Image *tpage;
100         char flag, transp;
101         short mode, tile, unwrap;
102 }BME_facetex;
103
104 typedef struct BME_looptex{
105         float u, v;
106 }BME_looptex;
107
108 typedef struct BME_loopcol{
109         char r, g, b, a;
110 }BME_loopcol;
111
112 /*Notes on further structure Cleanup:
113         -Remove the tflags, they belong in custom data layers
114         -Remove the eflags completely, they are mostly not used
115         -Remove the selection/vis/bevel weight flag/values ect and move them to custom data
116         -Remove EID member and move to custom data
117         -Add a radial cycle length, disk cycle length and loop cycle lenght attributes to custom data and have eulers maintain/use them if present.
118         -Move data such as vertex coordinates/normals to custom data and leave pointers in structures to active layer data.
119         -Remove BME_CycleNode structure?
120 */
121 typedef struct BME_CycleNode{
122         struct BME_CycleNode *next, *prev;
123         void *data;
124 } BME_CycleNode;
125
126 typedef struct BME_Mesh
127 {
128         ListBase verts, edges, polys;
129         /*memory pools used for storing mesh elements*/
130         struct BME_mempool *vpool;
131         struct BME_mempool *epool;
132         struct BME_mempool *ppool;
133         struct BME_mempool *lpool;
134         /*some scratch arrays used by eulers*/
135         struct BME_Vert **vtar;
136         struct BME_Edge **edar;
137         struct BME_Loop **lpar;
138         struct BME_Poly **plar;
139         int vtarlen, edarlen, lparlen, plarlen;
140         int totvert, totedge, totpoly, totloop;                         /*record keeping*/
141         int nextv, nexte, nextp, nextl;                                         /*Next element ID for verts/edges/faces/loops. Never reused*/
142         struct BME_CustomData vdata, edata, pdata, ldata;       /*Custom Data Layer information*/
143 } BME_Mesh;
144
145 typedef struct BME_Vert
146 {
147         struct BME_Vert *next, *prev;
148         int     EID;
149         float co[3];                                                                    
150         float no[3];                                                                    
151         struct BME_Edge *edge;                                                  /*first edge in the disk cycle for this vertex*/
152         void *data;                                                                             /*custom vertex data*/
153         int eflag1, eflag2;                                                             /*reserved for use by eulers*/
154         int tflag1, tflag2;                                                             /*reserved for use by tools*/
155         unsigned short flag, h;
156         float bweight;
157 } BME_Vert;
158
159 typedef struct BME_Edge
160 {
161         struct BME_Edge *next, *prev;
162         int EID;
163         struct BME_Vert *v1, *v2;                                               /*note that order of vertex pointers means nothing to eulers*/
164         struct BME_CycleNode d1, d2;                                    /*disk cycle nodes for v1 and v2 respectivley*/
165         struct BME_Loop *loop;                                                  /*first BME_Loop in the radial cycle around this edge*/
166         void *data;                                                                             /*custom edge data*/
167         int eflag1, eflag2;                                                             /*reserved for use by eulers*/
168         int tflag1, tflag2;                                                             /*reserved for use by tools*/
169         unsigned short flag, h;
170         float crease, bweight;
171 } BME_Edge;
172
173 typedef struct BME_Loop 
174 {       
175         struct BME_Loop *next, *prev;                                   /*circularly linked list around face*/
176         int EID;
177         struct BME_CycleNode radial;                                    /*circularly linked list used to find faces around an edge*/
178         struct BME_Vert *v;                                                             /*vertex that this loop starts at.*/
179         struct BME_Edge *e;                                                             /*edge this loop belongs to*/
180         struct BME_Poly *f;                                                             /*face this loop belongs to*/   
181         void *data;                                                                             /*custom per face vertex data*/
182         int eflag1, eflag2;                                                             /*reserved for use by eulers*/
183         int tflag1, tflag2;                                                             /*reserved for use by tools*/
184         unsigned short flag, h;
185 } BME_Loop;
186
187 typedef struct BME_Poly
188 {
189         struct BME_Poly *next, *prev;
190         int EID;
191         struct BME_Loop *loopbase;                                              /*First editloop around Polygon.*/
192         unsigned int len;                                                               /*total length of the face. Eulers should preserve this data*/
193         void *data;                                                                             /*custom face data*/
194         int eflag1, eflag2;                                                             /*reserved for use by eulers*/
195         int tflag1, tflag2;                                                             /*reserved for use by tools*/
196         unsigned short flag, h, mat_nr;
197 } BME_Poly;
198
199 //*EDGE UTILITIES*/
200 int BME_verts_in_edge(struct BME_Vert *v1, struct BME_Vert *v2, struct BME_Edge *e);
201 int BME_vert_in_edge(struct BME_Edge *e, BME_Vert *v);
202 struct BME_Vert *BME_edge_getothervert(struct BME_Edge *e, struct BME_Vert *v);
203
204 /*GENERAL CYCLE*/
205 int BME_cycle_length(void *h);
206
207 /*DISK CYCLE*/
208 struct BME_Edge *BME_disk_nextedge(struct BME_Edge *e, struct BME_Vert *v); 
209 struct BME_CycleNode *BME_disk_getpointer(struct BME_Edge *e, struct BME_Vert *v);
210 struct BME_Edge *BME_disk_next_edgeflag(struct BME_Edge *e, struct BME_Vert *v, int eflag, int tflag);
211 int BME_disk_count_edgeflag(struct BME_Vert *v, int eflag, int tflag);
212
213 /*RADIAL CYCLE*/
214 struct BME_Loop *BME_radial_nextloop(struct BME_Loop *l);
215 int BME_radial_find_face(struct BME_Edge *e,struct BME_Poly *f);
216
217 /*LOOP CYCLE*/
218 struct BME_Loop *BME_loop_find_loop(struct BME_Poly *f, struct BME_Vert *v);
219
220 /*MESH CREATION/DESTRUCTION*/
221 struct BME_Mesh *BME_make_mesh(int valloc, int ealloc, int lalloc, int palloc);
222 void BME_free_mesh(struct BME_Mesh *bm);
223 /*FULL MESH VALIDATION*/
224 int BME_validate_mesh(struct BME_Mesh *bm, int halt);
225 /*ENTER/EXIT MODELLING LOOP*/
226 int BME_model_begin(struct BME_Mesh *bm);
227 void BME_model_end(struct BME_Mesh *bm);
228
229 /*MESH CONSTRUCTION API.*/
230 /*MAKE*/
231 struct BME_Vert *BME_MV(struct BME_Mesh *bm, float *vec);
232 struct BME_Edge *BME_ME(struct BME_Mesh *bm, struct BME_Vert *v1, struct BME_Vert *v2);
233 struct BME_Poly *BME_MF(struct BME_Mesh *bm, struct BME_Vert *v1, struct BME_Vert *v2, struct BME_Edge **elist, int len);
234 /*KILL*/
235 int BME_KV(struct BME_Mesh *bm, struct BME_Vert *v);
236 int BME_KE(struct BME_Mesh *bm, struct BME_Edge *e);
237 int BME_KF(struct BME_Mesh *bm, struct BME_Poly *bply);
238 /*SPLIT*/
239 struct BME_Vert *BME_SEMV(struct BME_Mesh *bm, struct BME_Vert *tv, struct BME_Edge *e, struct BME_Edge **re);
240 struct BME_Poly *BME_SFME(struct BME_Mesh *bm, struct BME_Poly *f, struct BME_Vert *v1, struct BME_Vert *v2, struct BME_Loop **rl);
241 /*JOIN*/
242 int BME_JEKV(struct BME_Mesh *bm, struct BME_Edge *ke, struct BME_Vert *kv);
243 struct BME_Poly *BME_JFKE(struct BME_Mesh *bm, struct BME_Poly *f1, struct BME_Poly *f2,struct BME_Edge *e); /*no reason to return BME_Poly pointer?*/
244 /*NORMAL FLIP(Is its own inverse)*/
245 int BME_loop_reverse(struct BME_Mesh *bm, struct BME_Poly *f);
246
247 /* bevel tool defines */
248 /* element flags */
249 #define BME_BEVEL_ORIG                  1
250 #define BME_BEVEL_BEVEL                 (1<<1)
251 #define BME_BEVEL_NONMAN                (1<<2)
252 #define BME_BEVEL_WIRE                  (1<<3)
253
254 /* tool options */
255 #define BME_BEVEL_SELECT                1
256 #define BME_BEVEL_VERT                  (1<<1)
257 #define BME_BEVEL_RADIUS                (1<<2)
258 #define BME_BEVEL_ANGLE                 (1<<3)
259 #define BME_BEVEL_WEIGHT                (1<<4)
260 //~ #define BME_BEVEL_EWEIGHT           (1<<4)
261 //~ #define BME_BEVEL_VWEIGHT           (1<<5)
262 #define BME_BEVEL_PERCENT               (1<<6)
263 #define BME_BEVEL_EMIN                  (1<<7)
264 #define BME_BEVEL_EMAX                  (1<<8)
265 #define BME_BEVEL_RUNNING               (1<<9)
266 #define BME_BEVEL_RES                   (1<<10)
267
268 typedef struct BME_TransData {
269         BME_Mesh *bm; /* the bmesh the vert belongs to */
270         BME_Vert *v;  /* pointer to the vert this tdata applies to */
271         float co[3];  /* the original coordinate */
272         float org[3]; /* the origin */
273         float vec[3]; /* a directional vector; always, always normalize! */
274         void *loc;    /* a pointer to the data to transform (likely the vert's cos) */
275         float factor; /* primary scaling factor; also accumulates number of weighted edges for beveling tool */
276         float weight; /* another scaling factor; used primarily for propogating vertex weights to transforms; */
277                       /* weight is also used across recursive bevels to help with the math */
278         float maxfactor; /* the unscaled, original factor (used only by "edge verts" in recursive beveling) */
279         float *max;   /* the maximum distance this vert can be transformed; negative is infinite
280                        * it points to the "parent" maxfactor (where maxfactor makes little sense)
281                        * where the max limit is stored (limits are stored per-corner) */
282 } BME_TransData;
283
284 typedef struct BME_TransData_Head {
285         GHash *gh;       /* the hash structure for element lookup */
286         MemArena *ma;    /* the memory "pool" we will be drawing individual elements from */
287         int len;
288 } BME_TransData_Head;
289
290 typedef struct BME_Glob { /* stored in Global G for Transform() purposes */
291         BME_Mesh *bm;
292         BME_TransData_Head *td;
293         struct TransInfo *Trans; /* a pointer to the global Trans struct */
294         int imval[2]; /* for restoring original mouse co when initTransform() is called multiple times */
295         int options;
296         int res;
297 } BME_Glob;
298
299 struct BME_TransData *BME_get_transdata(struct BME_TransData_Head *td, struct BME_Vert *v);
300 void BME_free_transdata(struct BME_TransData_Head *td);
301 float *BME_bevel_calc_polynormal(struct BME_Poly *f, struct BME_TransData_Head *td);
302 struct BME_Mesh *BME_bevel(struct BME_Mesh *bm, float value, int res, int options, int defgrp_index, float angle, BME_TransData_Head **rtd);
303
304 /*CONVERSION FUNCTIONS*/
305 struct BME_Mesh *BME_editmesh_to_bmesh(EditMesh *em, struct BME_Mesh *bm);
306 struct EditMesh *BME_bmesh_to_editmesh(struct BME_Mesh *bm, BME_TransData_Head *td);
307 struct BME_Mesh *BME_derivedmesh_to_bmesh(struct DerivedMesh *dm, struct BME_Mesh *bm);
308 struct DerivedMesh *BME_bmesh_to_derivedmesh(struct BME_Mesh *bm, struct DerivedMesh *dm);
309 #endif