Fix build error on Windows 32 bit.
[blender-staging.git] / source / blender / makesdna / DNA_meshdata_types.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 /** \file DNA_meshdata_types.h
29  *  \ingroup DNA
30  */
31
32 #ifndef __DNA_MESHDATA_TYPES_H__
33 #define __DNA_MESHDATA_TYPES_H__
34
35 #include "DNA_customdata_types.h"
36 #include "DNA_listBase.h"
37
38 struct Image;
39
40 /*tessellation face, see MLoop/MPoly for the real face data*/
41 typedef struct MFace {
42         unsigned int v1, v2, v3, v4;
43         short mat_nr;
44         char edcode, flag;  /* we keep edcode, for conversion to edges draw flags in old files */
45 } MFace;
46
47 typedef struct MEdge {
48         unsigned int v1, v2;
49         char crease, bweight;
50         short flag;
51 } MEdge;
52
53 typedef struct MDeformWeight {
54         int def_nr;
55         float weight;
56 } MDeformWeight;
57
58 typedef struct MDeformVert {
59         struct MDeformWeight *dw;
60         int totweight;
61         int flag;  /* flag only in use for weightpaint now */
62 } MDeformVert;
63
64 typedef struct MVert {
65         float co[3];
66         short no[3];
67         char flag, bweight;
68 } MVert;
69
70 /* tessellation vertex color data.
71  * at the moment alpha is abused for vertex painting and not used for transparency, note that red and blue are swapped
72  */
73 typedef struct MCol {
74         unsigned char a, r, g, b;
75 } MCol;
76
77 /* new face structure, replaces MFace, which is now only used for storing tessellations.*/
78 typedef struct MPoly {
79         /* offset into loop array and number of loops in the face */
80         int loopstart;
81         int totloop;  /* keep signed since we need to subtract when getting the previous loop */
82         short mat_nr;
83         char flag, pad;
84 } MPoly;
85
86 /* the e here is because we want to move away from relying on edge hashes.*/
87 typedef struct MLoop {
88         unsigned int v;  /* vertex index */
89         unsigned int e;  /* edge index */
90 } MLoop;
91
92 /**
93  * #MLoopTri's are lightweight triangulation data, for functionality that doesn't support ngons (#MPoly).
94  * This is cache data created from (#MPoly, #MLoop & #MVert arrays).
95  * There is no attempt to maintain this data's validity over time, any changes to the underlying mesh
96  * invalidate the #MLoopTri array, which will need to be re-calculated.
97  *
98  * Users normally access this via #DerivedMesh.getLoopTriArray.
99  * In rare cases its calculated directly, with #BKE_mesh_recalc_looptri.
100  *
101  * Typical usage includes:
102  * - OpenGL drawing.
103  * - #BVHTree creation.
104  * - Physics/collision detection.
105  *
106  * Storing loop indices (instead of vertex indices) allows us to
107  * directly access UV's, vertex-colors as well as vertices.
108  * The index of the source polygon is stored as well, giving access to materials and polygon normals.
109  *
110  * \note This data is runtime only, never written to disk.
111  *
112  * Usage examples:
113  * \code{.c}
114  * // access original material.
115  * short mat_nr = mpoly[lt->poly].mat_nr;
116  *
117  * // access vertex locations.
118  * float *vtri_co[3] = {
119  *     mvert[mloop[lt->tri[0]].v].co,
120  *     mvert[mloop[lt->tri[1]].v].co,
121  *     mvert[mloop[lt->tri[2]].v].co,
122  * };
123  *
124  * // access UV coordinates (works for all loop data, vertex colors... etc).
125  * float *uvtri_co[3] = {
126  *     mloopuv[lt->tri[0]].uv,
127  *     mloopuv[lt->tri[1]].uv,
128  *     mloopuv[lt->tri[2]].uv,
129  * };
130  * \endcode
131  *
132  * #MLoopTri's are allocated in an array, where each polygon's #MLoopTri's are stored contiguously,
133  * the number of triangles for each polygon is guaranteed to be (#MPoly.totloop - 2),
134  * even for degenerate geometry. See #ME_POLY_TRI_TOT macro.
135  *
136  * It's also possible to perform a reverse lookup (find all #MLoopTri's for any given #MPoly).
137  *
138  * \code{.c}
139  * // loop over all looptri's for a given polygon: i
140  * MPoly *mp = &mpoly[i];
141  * MLoopTri *lt = &looptri[poly_to_tri_count(i, mp->loopstart)];
142  * int j, lt_tot = ME_POLY_TRI_TOT(mp);
143  *
144  * for (j = 0; j < lt_tot; j++, lt++) {
145  *     unsigned int vtri[3] = {
146  *         mloop[lt->tri[0]].v,
147  *         mloop[lt->tri[1]].v,
148  *         mloop[lt->tri[2]].v,
149  *     };
150  *     printf("tri %u %u %u\n", vtri[0], vtri[1], vtri[2]);
151  * };
152  * \endcode
153  *
154  * It may also be useful to check whether or not two vertices of a triangle form an edge in the underlying mesh.
155  *
156  * This can be done by checking the edge of the referenced loop (#MLoop.e),
157  * the winding of the #MLoopTri and the #MLoop's will always match,
158  * however the order of vertices in the edge is undefined.
159  *
160  * \code{.c}
161  * // print real edges from an MLoopTri: lt
162  * int j, j_next;
163  * for (j = 2, j_next = 0; j_next < 3; j = j_next++) {
164  *     MEdge *ed = &medge[mloop[lt->tri[j]].e];
165  *     unsigned int tri_edge[2]  = {mloop[lt->tri[j]].v, mloop[lt->tri[j_next]].v};
166  *
167  *     if (((ed->v1 == tri_edge[0]) && (ed->v1 == tri_edge[1])) ||
168  *         ((ed->v1 == tri_edge[1]) && (ed->v1 == tri_edge[0])))
169  *     {
170  *         printf("real edge found %u %u\n", tri_edge[0], tri_edge[1]);
171  *     }
172  * }
173  * \endcode
174  *
175  * \note A #MLoopTri may be in the middle of an ngon and not reference **any** edges.
176  */
177 #
178 #
179 typedef struct MLoopTri {
180         unsigned int tri[3];
181         unsigned int poly;
182 } MLoopTri;
183 #
184 #
185 typedef struct MVertTri {
186         unsigned int tri[3];
187 } MVertTri;
188
189
190 typedef struct MTexPoly {
191         struct Image *tpage;
192         char flag, transp;
193         short mode, tile, pad;
194 } MTexPoly;
195
196 /* can copy from/to MTexPoly/MTFace */
197 #define ME_MTEXFACE_CPY(dst, src)   \
198 {                                   \
199         (dst)->tpage  = (src)->tpage;   \
200         (dst)->flag   = (src)->flag;    \
201         (dst)->transp = (src)->transp;  \
202         (dst)->mode   = (src)->mode;    \
203         (dst)->tile   = (src)->tile;    \
204 } (void)0
205
206 typedef struct MLoopUV {
207         float uv[2];
208         int flag;
209 } MLoopUV;
210
211 /*mloopuv->flag*/
212 enum {
213         MLOOPUV_EDGESEL = (1 << 0),
214         MLOOPUV_VERTSEL = (1 << 1),
215         MLOOPUV_PINNED  = (1 << 2),
216 };
217
218 /**
219  * at the moment alpha is abused for vertex painting,
220  * otherwise it should _always_ be initialized to 255
221  * Mostly its not used for transparency...
222  * (except for blender-internal rendering, see [#34096]).
223  *
224  * \note red and blue are _not_ swapped, as they are with #MCol
225  */
226 typedef struct MLoopCol {
227         unsigned char r, g, b, a;
228 } MLoopCol;
229
230 #define MESH_MLOOPCOL_FROM_MCOL(_mloopcol, _mcol) \
231 {                                                 \
232         MLoopCol   *mloopcol__tmp = _mloopcol;        \
233         const MCol *mcol__tmp     = _mcol;            \
234         mloopcol__tmp->r = mcol__tmp->b;              \
235         mloopcol__tmp->g = mcol__tmp->g;              \
236         mloopcol__tmp->b = mcol__tmp->r;              \
237         mloopcol__tmp->a = mcol__tmp->a;              \
238 } (void)0
239
240
241 #define MESH_MLOOPCOL_TO_MCOL(_mloopcol, _mcol) \
242 {                                               \
243         const MLoopCol *mloopcol__tmp = _mloopcol;  \
244         MCol           *mcol__tmp     = _mcol;      \
245         mcol__tmp->b = mloopcol__tmp->r;            \
246         mcol__tmp->g = mloopcol__tmp->g;            \
247         mcol__tmp->r = mloopcol__tmp->b;            \
248         mcol__tmp->a = mloopcol__tmp->a;            \
249 } (void)0
250
251 typedef struct MSelect {
252         int index;
253         int type;  /* ME_VSEL/ME_ESEL/ME_FSEL */
254 } MSelect;
255
256 /*tessellation uv face data*/
257 typedef struct MTFace {
258         float uv[4][2];
259         struct Image *tpage;
260         char flag, transp;
261         short mode, tile, unwrap;
262 } MTFace;
263
264 /*Custom Data Properties*/
265 typedef struct MFloatProperty {
266         float f;
267 } MFloatProperty;
268 typedef struct MIntProperty {
269         int i;
270 } MIntProperty;
271 typedef struct MStringProperty {
272         char s[255], s_len;
273 } MStringProperty;
274
275 typedef struct OrigSpaceFace {
276         float uv[4][2];
277 } OrigSpaceFace;
278
279 typedef struct OrigSpaceLoop {
280         float uv[2];
281 } OrigSpaceLoop;
282
283 typedef struct MDisps {
284         /* Strange bug in SDNA: if disps pointer comes first, it fails to see totdisp */
285         int totdisp;
286         int level;
287         float (*disps)[3];
288
289         /* Used for hiding parts of a multires mesh. Essentially the multires equivalent of MVert.flag's ME_HIDE bit.
290          * NOTE: This is a bitmap, keep in sync with type used in BLI_bitmap.h
291          */
292         unsigned int *hidden;
293 } MDisps;
294
295 /** Multires structs kept for compatibility with old files **/
296 typedef struct MultiresCol {
297         float a, r, g, b;
298 } MultiresCol;
299
300 typedef struct MultiresColFace {
301         /* vertex colors */
302         MultiresCol col[4];
303 } MultiresColFace;
304
305 typedef struct MultiresFace {
306         unsigned int v[4];
307         unsigned int mid;
308         char flag, mat_nr, pad[2];
309 } MultiresFace;
310
311 typedef struct MultiresEdge {
312         unsigned int v[2];
313         unsigned int mid;
314 } MultiresEdge;
315
316 typedef struct MultiresLevel {
317         struct MultiresLevel *next, *prev;
318
319         MultiresFace *faces;
320         MultiresColFace *colfaces;
321         MultiresEdge *edges;
322
323         unsigned int totvert, totface, totedge, pad;
324
325         /* Kept for compatibility with even older files */
326         MVert *verts;
327 } MultiresLevel;
328
329 typedef struct Multires {
330         ListBase levels;
331         MVert *verts;
332
333         unsigned char level_count, current, newlvl, edgelvl, pinlvl, renderlvl;
334         unsigned char use_col, flag;
335
336         /* Special level 1 data that cannot be modified from other levels */
337         CustomData vdata;
338         CustomData fdata;
339         short *edge_flags;
340         char *edge_creases;
341 } Multires;
342
343 /** End Multires **/
344
345 typedef struct MRecast {
346         int i;
347 } MRecast;
348
349 typedef struct GridPaintMask {
350         /* The data array contains gridsize*gridsize elements */
351         float *data;
352
353         /* The maximum multires level associated with this grid */
354         unsigned int level;
355
356         int pad;
357 } GridPaintMask;
358
359 typedef enum eMVertSkinFlag {
360         /* Marks a vertex as the edge-graph root, used for calculating rotations for all connected edges (recursively).
361          * Also used to choose a root when generating an armature.
362          */
363         MVERT_SKIN_ROOT = 1,
364
365         /* Marks a branch vertex (vertex with more than two connected edges), so that it's neighbors are
366          * directly hulled together, rather than the default of generating intermediate frames.
367          */
368         MVERT_SKIN_LOOSE = 2,
369 } eMVertSkinFlag;
370
371 typedef struct MVertSkin {
372         /* Radii of the skin, define how big the generated frames are. Currently only the first two elements are used. */
373         float radius[3];
374
375         /* eMVertSkinFlag */
376         int flag;
377 } MVertSkin;
378
379 typedef struct FreestyleEdge {
380         char flag;
381         char pad[3];
382 } FreestyleEdge;
383
384 /* FreestyleEdge->flag */
385 enum {
386         FREESTYLE_EDGE_MARK = 1,
387 };
388
389 typedef struct FreestyleFace {
390         char flag;
391         char pad[3];
392 } FreestyleFace;
393
394 /* FreestyleFace->flag */
395 enum {
396         FREESTYLE_FACE_MARK = 1,
397 };
398
399 /* mvert->flag */
400 enum {
401 /*      SELECT              = (1 << 0), */
402         ME_VERT_TMP_TAG     = (1 << 2),
403         ME_HIDE             = (1 << 4),
404         ME_VERT_MERGED      = (1 << 6),
405         ME_VERT_PBVH_UPDATE = (1 << 7),
406 };
407
408 /* medge->flag */
409 enum {
410 /*      SELECT              = (1 << 0), */
411         ME_EDGEDRAW         = (1 << 1),
412         ME_SEAM             = (1 << 2),
413 /*      ME_HIDE             = (1 << 4), */
414         ME_EDGERENDER       = (1 << 5),
415         ME_LOOSEEDGE        = (1 << 7),
416         ME_EDGE_TMP_TAG     = (1 << 8),
417         ME_SHARP            = (1 << 9),  /* only reason this flag remains a 'short' */
418 };
419
420 /* puno = vertexnormal (mface) */
421 enum {
422         ME_PROJXY = (1 << 4),
423         ME_PROJXZ = (1 << 5),
424         ME_PROJYZ = (1 << 6),
425 };
426
427 /* edcode (mface) */
428 enum {
429         ME_V1V2 = (1 << 0),
430         ME_V2V3 = (1 << 1),
431         ME_V3V1 = (1 << 2),
432         ME_V3V4 = ME_V3V1,
433         ME_V4V1 = (1 << 3),
434 };
435
436 /* flag (mface) */
437 enum {
438         ME_SMOOTH   = (1 << 0),
439         ME_FACE_SEL = (1 << 1),
440 /*      ME_HIDE     = (1 << 4), */ 
441 };
442
443 #define ME_POLY_LOOP_PREV(mloop, mp, i)  (&(mloop)[(mp)->loopstart + (((i) + (mp)->totloop - 1) % (mp)->totloop)])
444 #define ME_POLY_LOOP_NEXT(mloop, mp, i)  (&(mloop)[(mp)->loopstart + (((i) + 1) % (mp)->totloop)])
445
446 /* number of tri's that make up this polygon once tessellated */
447 #define ME_POLY_TRI_TOT(mp) ((mp)->totloop - 2)
448
449 /**
450  * Check out-of-bounds material, note that this is nearly always prevented,
451  * yet its still possible in rare cases.
452  * So usage such as array lookup needs to check.
453  */
454 #define ME_MAT_NR_TEST(mat_nr, totmat) \
455         (CHECK_TYPE_ANY(mat_nr, short, const short), \
456          CHECK_TYPE_ANY(totmat, short, const short), \
457          (LIKELY(mat_nr < totmat) ? mat_nr : 0))
458
459 /* mselect->type */
460 enum {
461         ME_VSEL = 0,
462         ME_ESEL = 1,
463         ME_FSEL = 2,
464 };
465
466 /* mtface->flag */
467 enum {
468         // TF_SELECT = (1 << 0),  /* use MFace hide flag (after 2.43), should be able to reuse after 2.44 */
469         // TF_ACTIVE = (1 << 1),  /* deprecated! */
470         TF_SEL1   = (1 << 2),
471         TF_SEL2   = (1 << 3),
472         TF_SEL3   = (1 << 4),
473         TF_SEL4   = (1 << 5),
474 };
475
476 /* mtface->mode */
477 enum {
478         TF_DYNAMIC    = (1 << 0),
479         TF_ALPHASORT  = (1 << 1),
480         TF_TEX        = (1 << 2),
481         TF_SHAREDVERT = (1 << 3),
482         TF_LIGHT      = (1 << 4),
483
484         TF_CONVERTED  = (1 << 5),  /* tface converted to material */
485
486         TF_SHAREDCOL  = (1 << 6),
487         // TF_TILES      = (1 << 7),  /* deprecated */
488         TF_BILLBOARD  = (1 << 8),
489         TF_TWOSIDE    = (1 << 9),
490         TF_INVISIBLE  = (1 << 10),
491
492         TF_OBCOL      = (1 << 11),
493         TF_BILLBOARD2 = (1 << 12),  /* with Z axis constraint */
494         TF_SHADOW     = (1 << 13),
495         TF_BMFONT     = (1 << 14),
496 };
497
498 /* mtface->transp, values 1-4 are used as flags in the GL, WARNING, TF_SUB cant work with this */
499 enum {
500         TF_SOLID = 0,
501         TF_ADD   = (1 << 0),
502         TF_ALPHA = (1 << 1),
503         TF_CLIP  = (1 << 2),  /* clipmap alpha/binary alpha all or nothing! */
504
505         TF_SUB   = 3,  /* sub is not available in the user interface anymore */
506 };
507
508 /* mtface->unwrap */
509 enum {
510         TF_DEPRECATED1 = (1 << 0),
511         TF_DEPRECATED2 = (1 << 1),
512         TF_DEPRECATED3 = (1 << 2),
513         TF_DEPRECATED4 = (1 << 3),
514         TF_PIN1        = (1 << 4),
515         TF_PIN2        = (1 << 5),
516         TF_PIN3        = (1 << 6),
517         TF_PIN4        = (1 << 7),
518 };
519
520 #endif  /* __DNA_MESHDATA_TYPES_H__ */