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