Merge branch 'master' into blender2.8
[blender.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 //typedef struct MTexPoly {
190 //      void *pad;
191 //} MTexPoly;
192
193 typedef struct MLoopUV {
194         float uv[2];
195         int flag;
196 } MLoopUV;
197
198 /*mloopuv->flag*/
199 enum {
200         MLOOPUV_EDGESEL = (1 << 0),
201         MLOOPUV_VERTSEL = (1 << 1),
202         MLOOPUV_PINNED  = (1 << 2),
203 };
204
205 /**
206  * at the moment alpha is abused for vertex painting,
207  * otherwise it should _always_ be initialized to 255
208  * Mostly its not used for transparency...
209  * (except for blender-internal rendering, see [#34096]).
210  *
211  * \note red and blue are _not_ swapped, as they are with #MCol
212  */
213 typedef struct MLoopCol {
214         unsigned char r, g, b, a;
215 } MLoopCol;
216
217 #define MESH_MLOOPCOL_FROM_MCOL(_mloopcol, _mcol) \
218 {                                                 \
219         MLoopCol   *mloopcol__tmp = _mloopcol;        \
220         const MCol *mcol__tmp     = _mcol;            \
221         mloopcol__tmp->r = mcol__tmp->b;              \
222         mloopcol__tmp->g = mcol__tmp->g;              \
223         mloopcol__tmp->b = mcol__tmp->r;              \
224         mloopcol__tmp->a = mcol__tmp->a;              \
225 } (void)0
226
227
228 #define MESH_MLOOPCOL_TO_MCOL(_mloopcol, _mcol) \
229 {                                               \
230         const MLoopCol *mloopcol__tmp = _mloopcol;  \
231         MCol           *mcol__tmp     = _mcol;      \
232         mcol__tmp->b = mloopcol__tmp->r;            \
233         mcol__tmp->g = mloopcol__tmp->g;            \
234         mcol__tmp->r = mloopcol__tmp->b;            \
235         mcol__tmp->a = mloopcol__tmp->a;            \
236 } (void)0
237
238 typedef struct MSelect {
239         int index;
240         int type;  /* ME_VSEL/ME_ESEL/ME_FSEL */
241 } MSelect;
242
243 /*tessellation uv face data*/
244 typedef struct MTFace {
245         float uv[4][2];
246 } MTFace;
247
248 /*Custom Data Properties*/
249 typedef struct MFloatProperty {
250         float f;
251 } MFloatProperty;
252 typedef struct MIntProperty {
253         int i;
254 } MIntProperty;
255 typedef struct MStringProperty {
256         char s[255], s_len;
257 } MStringProperty;
258
259 typedef struct OrigSpaceFace {
260         float uv[4][2];
261 } OrigSpaceFace;
262
263 typedef struct OrigSpaceLoop {
264         float uv[2];
265 } OrigSpaceLoop;
266
267 typedef struct MDisps {
268         /* Strange bug in SDNA: if disps pointer comes first, it fails to see totdisp */
269         int totdisp;
270         int level;
271         float (*disps)[3];
272
273         /* Used for hiding parts of a multires mesh. Essentially the multires equivalent of MVert.flag's ME_HIDE bit.
274          * NOTE: This is a bitmap, keep in sync with type used in BLI_bitmap.h
275          */
276         unsigned int *hidden;
277 } MDisps;
278
279 /** Multires structs kept for compatibility with old files **/
280 typedef struct MultiresCol {
281         float a, r, g, b;
282 } MultiresCol;
283
284 typedef struct MultiresColFace {
285         /* vertex colors */
286         MultiresCol col[4];
287 } MultiresColFace;
288
289 typedef struct MultiresFace {
290         unsigned int v[4];
291         unsigned int mid;
292         char flag, mat_nr, pad[2];
293 } MultiresFace;
294
295 typedef struct MultiresEdge {
296         unsigned int v[2];
297         unsigned int mid;
298 } MultiresEdge;
299
300 typedef struct MultiresLevel {
301         struct MultiresLevel *next, *prev;
302
303         MultiresFace *faces;
304         MultiresColFace *colfaces;
305         MultiresEdge *edges;
306
307         unsigned int totvert, totface, totedge, pad;
308
309         /* Kept for compatibility with even older files */
310         MVert *verts;
311 } MultiresLevel;
312
313 typedef struct Multires {
314         ListBase levels;
315         MVert *verts;
316
317         unsigned char level_count, current, newlvl, edgelvl, pinlvl, renderlvl;
318         unsigned char use_col, flag;
319
320         /* Special level 1 data that cannot be modified from other levels */
321         CustomData vdata;
322         CustomData fdata;
323         short *edge_flags;
324         char *edge_creases;
325 } Multires;
326
327 /** End Multires **/
328
329 typedef struct MRecast {
330         int i;
331 } MRecast;
332
333 typedef struct GridPaintMask {
334         /* The data array contains gridsize*gridsize elements */
335         float *data;
336
337         /* The maximum multires level associated with this grid */
338         unsigned int level;
339
340         int pad;
341 } GridPaintMask;
342
343 typedef enum MVertSkinFlag {
344         /* Marks a vertex as the edge-graph root, used for calculating rotations for all connected edges (recursively).
345          * Also used to choose a root when generating an armature.
346          */
347         MVERT_SKIN_ROOT = 1,
348
349         /* Marks a branch vertex (vertex with more than two connected edges), so that it's neighbors are
350          * directly hulled together, rather than the default of generating intermediate frames.
351          */
352         MVERT_SKIN_LOOSE = 2,
353 } MVertSkinFlag;
354
355 typedef struct MVertSkin {
356         /* Radii of the skin, define how big the generated frames are. Currently only the first two elements are used. */
357         float radius[3];
358
359         /* MVertSkinFlag */
360         int flag;
361 } MVertSkin;
362
363 typedef struct FreestyleEdge {
364         char flag;
365         char pad[3];
366 } FreestyleEdge;
367
368 /* FreestyleEdge->flag */
369 enum {
370         FREESTYLE_EDGE_MARK = 1,
371 };
372
373 typedef struct FreestyleFace {
374         char flag;
375         char pad[3];
376 } FreestyleFace;
377
378 /* FreestyleFace->flag */
379 enum {
380         FREESTYLE_FACE_MARK = 1,
381 };
382
383 /* mvert->flag */
384 enum {
385 /*      SELECT              = (1 << 0), */
386         ME_VERT_TMP_TAG     = (1 << 2),
387         ME_HIDE             = (1 << 4),
388         ME_VERT_MERGED      = (1 << 6),
389         ME_VERT_PBVH_UPDATE = (1 << 7),
390 };
391
392 /* medge->flag */
393 enum {
394 /*      SELECT              = (1 << 0), */
395         ME_EDGEDRAW         = (1 << 1),
396         ME_SEAM             = (1 << 2),
397 /*      ME_HIDE             = (1 << 4), */
398         ME_EDGERENDER       = (1 << 5),
399         ME_LOOSEEDGE        = (1 << 7),
400         ME_EDGE_TMP_TAG     = (1 << 8),
401         ME_SHARP            = (1 << 9),  /* only reason this flag remains a 'short' */
402 };
403
404 /* puno = vertexnormal (mface) */
405 enum {
406         ME_PROJXY = (1 << 4),
407         ME_PROJXZ = (1 << 5),
408         ME_PROJYZ = (1 << 6),
409 };
410
411 /* edcode (mface) */
412 enum {
413         ME_V1V2 = (1 << 0),
414         ME_V2V3 = (1 << 1),
415         ME_V3V1 = (1 << 2),
416         ME_V3V4 = ME_V3V1,
417         ME_V4V1 = (1 << 3),
418 };
419
420 /* flag (mface) */
421 enum {
422         ME_SMOOTH   = (1 << 0),
423         ME_FACE_SEL = (1 << 1),
424 /*      ME_HIDE     = (1 << 4), */ 
425 };
426
427 #define ME_POLY_LOOP_PREV(mloop, mp, i)  (&(mloop)[(mp)->loopstart + (((i) + (mp)->totloop - 1) % (mp)->totloop)])
428 #define ME_POLY_LOOP_NEXT(mloop, mp, i)  (&(mloop)[(mp)->loopstart + (((i) + 1) % (mp)->totloop)])
429
430 /* number of tri's that make up this polygon once tessellated */
431 #define ME_POLY_TRI_TOT(mp) ((mp)->totloop - 2)
432
433 /**
434  * Check out-of-bounds material, note that this is nearly always prevented,
435  * yet its still possible in rare cases.
436  * So usage such as array lookup needs to check.
437  */
438 #define ME_MAT_NR_TEST(mat_nr, totmat) \
439         (CHECK_TYPE_ANY(mat_nr, short, const short), \
440          CHECK_TYPE_ANY(totmat, short, const short), \
441          (LIKELY(mat_nr < totmat) ? mat_nr : 0))
442
443 /* mselect->type */
444 enum {
445         ME_VSEL = 0,
446         ME_ESEL = 1,
447         ME_FSEL = 2,
448 };
449
450 #endif  /* __DNA_MESHDATA_TYPES_H__ */