Merge branch 'blender-v2.81-release'
[blender.git] / source / blender / makesdna / DNA_meshdata_types.h
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  *
16  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
17  * All rights reserved.
18  */
19
20 /** \file
21  * \ingroup DNA
22  */
23
24 #ifndef __DNA_MESHDATA_TYPES_H__
25 #define __DNA_MESHDATA_TYPES_H__
26
27 #include "DNA_customdata_types.h"
28 #include "DNA_listBase.h"
29
30 /*tessellation face, see MLoop/MPoly for the real face data*/
31 typedef struct MFace {
32   unsigned int v1, v2, v3, v4;
33   short mat_nr;
34   /** We keep edcode, for conversion to edges draw flags in old files. */
35   char edcode, flag;
36 } MFace;
37
38 typedef struct MEdge {
39   unsigned int v1, v2;
40   char crease, bweight;
41   short flag;
42 } MEdge;
43
44 typedef struct MDeformWeight {
45   int def_nr;
46   float weight;
47 } MDeformWeight;
48
49 typedef struct MDeformVert {
50   struct MDeformWeight *dw;
51   int totweight;
52   /** Flag only in use for weightpaint now. */
53   int flag;
54 } MDeformVert;
55
56 typedef struct MVert {
57   float co[3];
58   short no[3];
59   char flag, bweight;
60 } MVert;
61
62 /** Tessellation vertex color data.
63  * at the moment alpha is abused for vertex painting and not used for transparency,
64  * note that red and blue are swapped
65  */
66 typedef struct MCol {
67   unsigned char a, r, g, b;
68 } MCol;
69
70 /* new face structure, replaces MFace, which is now only used for storing tessellations.*/
71 typedef struct MPoly {
72   /* offset into loop array and number of loops in the face */
73   int loopstart;
74   /** Keep signed since we need to subtract when getting the previous loop. */
75   int totloop;
76   short mat_nr;
77   char flag, _pad;
78 } MPoly;
79
80 /* the e here is because we want to move away from relying on edge hashes.*/
81 typedef struct MLoop {
82   /** Vertex index. */
83   unsigned int v;
84   /** Edge index. */
85   unsigned int e;
86 } MLoop;
87
88 /**
89  * #MLoopTri's are lightweight triangulation data,
90  * for functionality that doesn't support ngons (#MPoly).
91  * This is cache data created from (#MPoly, #MLoop & #MVert arrays).
92  * There is no attempt to maintain this data's validity over time,
93  * any changes to the underlying mesh invalidate the #MLoopTri array,
94  * which will need to be re-calculated.
95  *
96  * Users normally access this via #BKE_mesh_runtime_looptri_ensure.
97  * In rare cases its calculated directly, with #BKE_mesh_recalc_looptri.
98  *
99  * Typical usage includes:
100  * - OpenGL drawing.
101  * - #BVHTree creation.
102  * - Physics/collision detection.
103  *
104  * Storing loop indices (instead of vertex indices) allows us to
105  * directly access UV's, vertex-colors as well as vertices.
106  * The index of the source polygon is stored as well,
107  * giving access to materials and polygon normals.
108  *
109  * \note This data is runtime only, never written to disk.
110  *
111  * Usage examples:
112  * \code{.c}
113  * // access original material.
114  * short mat_nr = mpoly[lt->poly].mat_nr;
115  *
116  * // access vertex locations.
117  * float *vtri_co[3] = {
118  *     mvert[mloop[lt->tri[0]].v].co,
119  *     mvert[mloop[lt->tri[1]].v].co,
120  *     mvert[mloop[lt->tri[2]].v].co,
121  * };
122  *
123  * // access UV coordinates (works for all loop data, vertex colors... etc).
124  * float *uvtri_co[3] = {
125  *     mloopuv[lt->tri[0]].uv,
126  *     mloopuv[lt->tri[1]].uv,
127  *     mloopuv[lt->tri[2]].uv,
128  * };
129  * \endcode
130  *
131  * #MLoopTri's are allocated in an array, where each polygon's #MLoopTri's are stored contiguously,
132  * the number of triangles for each polygon is guaranteed to be (#MPoly.totloop - 2),
133  * even for degenerate geometry. See #ME_POLY_TRI_TOT macro.
134  *
135  * It's also possible to perform a reverse lookup (find all #MLoopTri's for any given #MPoly).
136  *
137  * \code{.c}
138  * // loop over all looptri's for a given polygon: i
139  * MPoly *mp = &mpoly[i];
140  * MLoopTri *lt = &looptri[poly_to_tri_count(i, mp->loopstart)];
141  * int j, lt_tot = ME_POLY_TRI_TOT(mp);
142  *
143  * for (j = 0; j < lt_tot; j++, lt++) {
144  *     unsigned int vtri[3] = {
145  *         mloop[lt->tri[0]].v,
146  *         mloop[lt->tri[1]].v,
147  *         mloop[lt->tri[2]].v,
148  *     };
149  *     printf("tri %u %u %u\n", vtri[0], vtri[1], vtri[2]);
150  * };
151  * \endcode
152  *
153  * It may also be useful to check whether or not two vertices of a triangle
154  * 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->v2 == tri_edge[1])) ||
168  *         ((ed->v1 == tri_edge[1]) && (ed->v2 == tri_edge[0])))
169  *     {
170  *         printf("real edge found %u %u\n", tri_edge[0], tri_edge[1]);
171  *     }
172  * }
173  * \endcode
174  *
175  * See #BKE_mesh_looptri_get_real_edges for a utility that does this.
176  *
177  * \note A #MLoopTri may be in the middle of an ngon and not reference **any** edges.
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 MLoopUV {
190   float uv[2];
191   int flag;
192 } MLoopUV;
193
194 /*mloopuv->flag*/
195 enum {
196   MLOOPUV_EDGESEL = (1 << 0),
197   MLOOPUV_VERTSEL = (1 << 1),
198   MLOOPUV_PINNED = (1 << 2),
199 };
200
201 /**
202  * at the moment alpha is abused for vertex painting,
203  * otherwise it should _always_ be initialized to 255
204  * Mostly its not used for transparency...
205  * (except for blender-internal rendering, see [#34096]).
206  *
207  * \note red and blue are _not_ swapped, as they are with #MCol
208  */
209 typedef struct MLoopCol {
210   unsigned char r, g, b, a;
211 } MLoopCol;
212
213 #define MESH_MLOOPCOL_FROM_MCOL(_mloopcol, _mcol) \
214   { \
215     MLoopCol *mloopcol__tmp = _mloopcol; \
216     const MCol *mcol__tmp = _mcol; \
217     mloopcol__tmp->r = mcol__tmp->b; \
218     mloopcol__tmp->g = mcol__tmp->g; \
219     mloopcol__tmp->b = mcol__tmp->r; \
220     mloopcol__tmp->a = mcol__tmp->a; \
221   } \
222   (void)0
223
224 #define MESH_MLOOPCOL_TO_MCOL(_mloopcol, _mcol) \
225   { \
226     const MLoopCol *mloopcol__tmp = _mloopcol; \
227     MCol *mcol__tmp = _mcol; \
228     mcol__tmp->b = mloopcol__tmp->r; \
229     mcol__tmp->g = mloopcol__tmp->g; \
230     mcol__tmp->r = mloopcol__tmp->b; \
231     mcol__tmp->a = mloopcol__tmp->a; \
232   } \
233   (void)0
234
235 typedef struct MSelect {
236   int index;
237   /** ME_VSEL/ME_ESEL/ME_FSEL. */
238   int type;
239 } MSelect;
240
241 /*tessellation uv face data*/
242 typedef struct MTFace {
243   float uv[4][2];
244 } MTFace;
245
246 /*Custom Data Properties*/
247 typedef struct MFloatProperty {
248   float f;
249 } MFloatProperty;
250 typedef struct MIntProperty {
251   int i;
252 } MIntProperty;
253 typedef struct MStringProperty {
254   char s[255], s_len;
255 } MStringProperty;
256
257 typedef struct OrigSpaceFace {
258   float uv[4][2];
259 } OrigSpaceFace;
260
261 typedef struct OrigSpaceLoop {
262   float uv[2];
263 } OrigSpaceLoop;
264
265 typedef struct MDisps {
266   /* Strange bug in SDNA: if disps pointer comes first, it fails to see totdisp */
267   int totdisp;
268   int level;
269   float (*disps)[3];
270
271   /**
272    * Used for hiding parts of a multires mesh.
273    * Essentially the multires equivalent of MVert.flag's ME_HIDE bit.
274    *
275    * \note This is a bitmap, keep in sync with type used in BLI_bitmap.h
276    */
277   unsigned int *hidden;
278 } MDisps;
279
280 /** Multires structs kept for compatibility with old files. */
281 typedef struct MultiresCol {
282   float a, r, g, b;
283 } MultiresCol;
284
285 typedef struct MultiresColFace {
286   /* vertex colors */
287   MultiresCol col[4];
288 } MultiresColFace;
289
290 typedef struct MultiresFace {
291   unsigned int v[4];
292   unsigned int mid;
293   char flag, mat_nr, _pad[2];
294 } MultiresFace;
295
296 typedef struct MultiresEdge {
297   unsigned int v[2];
298   unsigned int mid;
299 } MultiresEdge;
300
301 typedef struct MultiresLevel {
302   struct MultiresLevel *next, *prev;
303
304   MultiresFace *faces;
305   MultiresColFace *colfaces;
306   MultiresEdge *edges;
307
308   unsigned int totvert, totface, totedge;
309   char _pad[4];
310
311   /* Kept for compatibility with even older files */
312   MVert *verts;
313 } MultiresLevel;
314
315 typedef struct Multires {
316   ListBase levels;
317   MVert *verts;
318
319   unsigned char level_count, current, newlvl, edgelvl, pinlvl, renderlvl;
320   unsigned char use_col, flag;
321
322   /* Special level 1 data that cannot be modified from other levels */
323   CustomData vdata;
324   CustomData fdata;
325   short *edge_flags;
326   char *edge_creases;
327 } Multires;
328
329 /* End Multires */
330
331 typedef struct MRecast {
332   int i;
333 } MRecast;
334
335 typedef struct GridPaintMask {
336   /* The data array contains gridsize*gridsize elements */
337   float *data;
338
339   /* The maximum multires level associated with this grid */
340   unsigned int level;
341
342   char _pad[4];
343 } GridPaintMask;
344
345 typedef enum eMVertSkinFlag {
346   /** Marks a vertex as the edge-graph root, used for calculating rotations for all connected
347    * edges (recursively). Also used to choose a root when generating an armature.
348    */
349   MVERT_SKIN_ROOT = 1,
350
351   /** Marks a branch vertex (vertex with more than two connected edges), so that it's neighbors
352    * are directly hulled together, rather than the default of generating intermediate frames.
353    */
354   MVERT_SKIN_LOOSE = 2,
355 } eMVertSkinFlag;
356
357 typedef struct MVertSkin {
358   /* Radii of the skin, define how big the generated frames are.
359    * Currently only the first two elements are used. */
360   float radius[3];
361
362   /* eMVertSkinFlag */
363   int flag;
364 } MVertSkin;
365
366 typedef struct FreestyleEdge {
367   char flag;
368   char _pad[3];
369 } FreestyleEdge;
370
371 /* FreestyleEdge->flag */
372 enum {
373   FREESTYLE_EDGE_MARK = 1,
374 };
375
376 typedef struct FreestyleFace {
377   char flag;
378   char _pad[3];
379 } FreestyleFace;
380
381 /* FreestyleFace->flag */
382 enum {
383   FREESTYLE_FACE_MARK = 1,
384 };
385
386 /* mvert->flag */
387 enum {
388   /*  SELECT              = (1 << 0), */
389   ME_VERT_TMP_TAG = (1 << 2),
390   ME_HIDE = (1 << 4),
391   ME_VERT_FACEDOT = (1 << 5),
392   /*  ME_VERT_MERGED      = (1 << 6), */
393   ME_VERT_PBVH_UPDATE = (1 << 7),
394 };
395
396 /* medge->flag */
397 enum {
398   /*  SELECT              = (1 << 0), */
399   ME_EDGEDRAW = (1 << 1),
400   ME_SEAM = (1 << 2),
401   /*  ME_HIDE             = (1 << 4), */
402   ME_EDGERENDER = (1 << 5),
403   ME_LOOSEEDGE = (1 << 7),
404   ME_EDGE_TMP_TAG = (1 << 8),
405   ME_SHARP = (1 << 9), /* only reason this flag remains a 'short' */
406 };
407
408 /* puno = vertexnormal (mface) */
409 enum {
410   ME_PROJXY = (1 << 4),
411   ME_PROJXZ = (1 << 5),
412   ME_PROJYZ = (1 << 6),
413 };
414
415 /* edcode (mface) */
416 enum {
417   ME_V1V2 = (1 << 0),
418   ME_V2V3 = (1 << 1),
419   ME_V3V1 = (1 << 2),
420   ME_V3V4 = ME_V3V1,
421   ME_V4V1 = (1 << 3),
422 };
423
424 /* flag (mface) */
425 enum {
426   ME_SMOOTH = (1 << 0),
427   ME_FACE_SEL = (1 << 1),
428   /*  ME_HIDE     = (1 << 4), */
429 };
430
431 #define ME_POLY_LOOP_PREV(mloop, mp, i) \
432   (&(mloop)[(mp)->loopstart + (((i) + (mp)->totloop - 1) % (mp)->totloop)])
433 #define ME_POLY_LOOP_NEXT(mloop, mp, i) (&(mloop)[(mp)->loopstart + (((i) + 1) % (mp)->totloop)])
434
435 /* number of tri's that make up this polygon once tessellated */
436 #define ME_POLY_TRI_TOT(mp) ((mp)->totloop - 2)
437
438 /**
439  * Check out-of-bounds material, note that this is nearly always prevented,
440  * yet its still possible in rare cases.
441  * So usage such as array lookup needs to check.
442  */
443 #define ME_MAT_NR_TEST(mat_nr, totmat) \
444   (CHECK_TYPE_ANY(mat_nr, short, const short), \
445    CHECK_TYPE_ANY(totmat, short, const short), \
446    (LIKELY(mat_nr < totmat) ? mat_nr : 0))
447
448 /* mselect->type */
449 enum {
450   ME_VSEL = 0,
451   ME_ESEL = 1,
452   ME_FSEL = 2,
453 };
454
455 #endif /* __DNA_MESHDATA_TYPES_H__ */