Fix accendental copy/paste errors after last commit
[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 #pragma once
25
26 #include "DNA_customdata_types.h"
27 #include "DNA_listBase.h"
28
29 #ifdef __cplusplus
30 extern "C" {
31 #endif
32
33 /* -------------------------------------------------------------------- */
34 /** \name Geometry Elements
35  * \{ */
36
37 /**
38  * Mesh Vertices.
39  *
40  * Typically accessed from #Mesh.mvert
41  */
42 typedef struct MVert {
43   float co[3];
44   /**
45    * Cache the normal, can always be recalculated from surrounding faces.
46    * See #CD_CUSTOMLOOPNORMAL for custom normals.
47    */
48   short no[3];
49   char flag, bweight;
50 } MVert;
51
52 /** #MVert.flag */
53 enum {
54   /*  SELECT = (1 << 0), */
55   ME_VERT_TMP_TAG = (1 << 2),
56   ME_HIDE = (1 << 4),
57   ME_VERT_FACEDOT = (1 << 5),
58   /*  ME_VERT_MERGED = (1 << 6), */
59   ME_VERT_PBVH_UPDATE = (1 << 7),
60 };
61
62 /**
63  * Mesh Edges.
64  *
65  * Typically accessed from #Mesh.medge
66  */
67 typedef struct MEdge {
68   /** Un-ordered vertex indices (cannot match). */
69   unsigned int v1, v2;
70   char crease, bweight;
71   short flag;
72 } MEdge;
73
74 /** #MEdge.flag */
75 enum {
76   /*  SELECT = (1 << 0), */
77   ME_EDGEDRAW = (1 << 1),
78   ME_SEAM = (1 << 2),
79   /*  ME_HIDE = (1 << 4), */
80   ME_EDGERENDER = (1 << 5),
81   ME_LOOSEEDGE = (1 << 7),
82   ME_EDGE_TMP_TAG = (1 << 8),
83   ME_SHARP = (1 << 9), /* only reason this flag remains a 'short' */
84 };
85
86 /**
87  * Mesh Faces
88  * This only stores the polygon size & flags, the vertex & edge indices are stored in the #MLoop.
89  *
90  * Typically accessed from #Mesh.mpoly.
91  */
92 typedef struct MPoly {
93   /** Offset into loop array and number of loops in the face. */
94   int loopstart;
95   /** Keep signed since we need to subtract when getting the previous loop. */
96   int totloop;
97   short mat_nr;
98   char flag, _pad;
99 } MPoly;
100
101 /** #MPoly.flag */
102 enum {
103   ME_SMOOTH = (1 << 0),
104   ME_FACE_SEL = (1 << 1),
105   /* ME_HIDE = (1 << 4), */
106 };
107
108 /**
109  * Mesh Loops.
110  * Each loop represents the corner of a polygon (#MPoly).
111  *
112  * Typically accessed from #Mesh.mloop.
113  */
114 typedef struct MLoop {
115   /** Vertex index. */
116   unsigned int v;
117   /**
118    * Edge index.
119    *
120    * \note The e here is because we want to move away from relying on edge hashes.
121    */
122   unsigned int e;
123 } MLoop;
124
125 /** \} */
126
127 /* -------------------------------------------------------------------- */
128 /** \name Ordered Selection Storage
129  * \{ */
130
131 /**
132  * Optionally store the order of selected elements.
133  * This wont always be set since only some selection operations have an order.
134  *
135  * Typically accessed from #Mesh.mselect
136  */
137 typedef struct MSelect {
138   /** Index in the vertex, edge or polygon array. */
139   int index;
140   /** #ME_VSEL, #ME_ESEL, #ME_FSEL. */
141   int type;
142 } MSelect;
143
144 /** #MSelect.type */
145 enum {
146   ME_VSEL = 0,
147   ME_ESEL = 1,
148   ME_FSEL = 2,
149 };
150
151 /** \} */
152
153 /* -------------------------------------------------------------------- */
154 /** \name Loop Tesselation Runtime Data
155  * \{ */
156
157 /**
158  * #MLoopTri's are lightweight triangulation data,
159  * for functionality that doesn't support ngons (#MPoly).
160  * This is cache data created from (#MPoly, #MLoop & #MVert arrays).
161  * There is no attempt to maintain this data's validity over time,
162  * any changes to the underlying mesh invalidate the #MLoopTri array,
163  * which will need to be re-calculated.
164  *
165  * Users normally access this via #BKE_mesh_runtime_looptri_ensure.
166  * In rare cases its calculated directly, with #BKE_mesh_recalc_looptri.
167  *
168  * Typical usage includes:
169  * - OpenGL drawing.
170  * - #BVHTree creation.
171  * - Physics/collision detection.
172  *
173  * Storing loop indices (instead of vertex indices) allows us to
174  * directly access UV's, vertex-colors as well as vertices.
175  * The index of the source polygon is stored as well,
176  * giving access to materials and polygon normals.
177  *
178  * \note This data is runtime only, never written to disk.
179  *
180  * Usage examples:
181  * \code{.c}
182  * // access original material.
183  * short mat_nr = mpoly[lt->poly].mat_nr;
184  *
185  * // access vertex locations.
186  * float *vtri_co[3] = {
187  *     mvert[mloop[lt->tri[0]].v].co,
188  *     mvert[mloop[lt->tri[1]].v].co,
189  *     mvert[mloop[lt->tri[2]].v].co,
190  * };
191  *
192  * // access UV coordinates (works for all loop data, vertex colors... etc).
193  * float *uvtri_co[3] = {
194  *     mloopuv[lt->tri[0]].uv,
195  *     mloopuv[lt->tri[1]].uv,
196  *     mloopuv[lt->tri[2]].uv,
197  * };
198  * \endcode
199  *
200  * #MLoopTri's are allocated in an array, where each polygon's #MLoopTri's are stored contiguously,
201  * the number of triangles for each polygon is guaranteed to be (#MPoly.totloop - 2),
202  * even for degenerate geometry. See #ME_POLY_TRI_TOT macro.
203  *
204  * It's also possible to perform a reverse lookup (find all #MLoopTri's for any given #MPoly).
205  *
206  * \code{.c}
207  * // loop over all looptri's for a given polygon: i
208  * MPoly *mp = &mpoly[i];
209  * MLoopTri *lt = &looptri[poly_to_tri_count(i, mp->loopstart)];
210  * int j, lt_tot = ME_POLY_TRI_TOT(mp);
211  *
212  * for (j = 0; j < lt_tot; j++, lt++) {
213  *     unsigned int vtri[3] = {
214  *         mloop[lt->tri[0]].v,
215  *         mloop[lt->tri[1]].v,
216  *         mloop[lt->tri[2]].v,
217  *     };
218  *     printf("tri %u %u %u\n", vtri[0], vtri[1], vtri[2]);
219  * };
220  * \endcode
221  *
222  * It may also be useful to check whether or not two vertices of a triangle
223  * form an edge in the underlying mesh.
224  *
225  * This can be done by checking the edge of the referenced loop (#MLoop.e),
226  * the winding of the #MLoopTri and the #MLoop's will always match,
227  * however the order of vertices in the edge is undefined.
228  *
229  * \code{.c}
230  * // print real edges from an MLoopTri: lt
231  * int j, j_next;
232  * for (j = 2, j_next = 0; j_next < 3; j = j_next++) {
233  *     MEdge *ed = &medge[mloop[lt->tri[j]].e];
234  *     unsigned int tri_edge[2]  = {mloop[lt->tri[j]].v, mloop[lt->tri[j_next]].v};
235  *
236  *     if (((ed->v1 == tri_edge[0]) && (ed->v2 == tri_edge[1])) ||
237  *         ((ed->v1 == tri_edge[1]) && (ed->v2 == tri_edge[0])))
238  *     {
239  *         printf("real edge found %u %u\n", tri_edge[0], tri_edge[1]);
240  *     }
241  * }
242  * \endcode
243  *
244  * See #BKE_mesh_looptri_get_real_edges for a utility that does this.
245  *
246  * \note A #MLoopTri may be in the middle of an ngon and not reference **any** edges.
247  */
248 typedef struct MLoopTri {
249   unsigned int tri[3];
250   unsigned int poly;
251 } MLoopTri;
252 #
253 #
254 typedef struct MVertTri {
255   unsigned int tri[3];
256 } MVertTri;
257
258 /** \} */
259
260 /* -------------------------------------------------------------------- */
261 /** \name Custom Data (Generic)
262  * \{ */
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 /** \} */
276
277 /* -------------------------------------------------------------------- */
278 /** \name Custom Data (Vertex)
279  * \{ */
280
281 /**
282  * Vertex group index and weight for #MDeformVert.dw
283  */
284 typedef struct MDeformWeight {
285   /** The index for the vertex group, must *always* be unique when in an array. */
286   unsigned int def_nr;
287   /** Weight between 0.0 and 1.0. */
288   float weight;
289 } MDeformWeight;
290
291 typedef struct MDeformVert {
292   struct MDeformWeight *dw;
293   int totweight;
294   /** Flag is only in use as a run-time tag at the moment. */
295   int flag;
296 } MDeformVert;
297
298 typedef struct MVertSkin {
299   /**
300    * Radii of the skin, define how big the generated frames are.
301    * Currently only the first two elements are used.
302    */
303   float radius[3];
304
305   /** #eMVertSkinFlag */
306   int flag;
307 } MVertSkin;
308
309 typedef enum eMVertSkinFlag {
310   /** Marks a vertex as the edge-graph root, used for calculating rotations for all connected
311    * edges (recursively). Also used to choose a root when generating an armature.
312    */
313   MVERT_SKIN_ROOT = 1,
314
315   /** Marks a branch vertex (vertex with more than two connected edges), so that its neighbors
316    * are directly hulled together, rather than the default of generating intermediate frames.
317    */
318   MVERT_SKIN_LOOSE = 2,
319 } eMVertSkinFlag;
320
321 /** \} */
322
323 /* -------------------------------------------------------------------- */
324 /** \name Custom Data (Loop)
325  * \{ */
326
327 /**
328  * UV coordinate for a polygon face & flag for selection & other options.
329  */
330 typedef struct MLoopUV {
331   float uv[2];
332   int flag;
333 } MLoopUV;
334
335 /** #MLoopUV.flag */
336 enum {
337   /* MLOOPUV_DEPRECATED = (1 << 0), MLOOPUV_EDGESEL removed */
338   MLOOPUV_VERTSEL = (1 << 1),
339   MLOOPUV_PINNED = (1 << 2),
340 };
341
342 /**
343  * \note While alpha is not currently in the 3D Viewport,
344  * this may eventually be added back, keep this value set to 255.
345  */
346 typedef struct MLoopCol {
347   unsigned char r, g, b, a;
348 } MLoopCol;
349
350 typedef struct MPropCol {
351   float color[4];
352 } MPropCol;
353
354 /** Multi-Resolution loop data. */
355 typedef struct MDisps {
356   /* Strange bug in SDNA: if disps pointer comes first, it fails to see totdisp */
357   int totdisp;
358   int level;
359   float (*disps)[3];
360
361   /**
362    * Used for hiding parts of a multires mesh.
363    * Essentially the multires equivalent of #MVert.flag's ME_HIDE bit.
364    *
365    * \note This is a bitmap, keep in sync with type used in BLI_bitmap.h
366    */
367   unsigned int *hidden;
368 } MDisps;
369
370 /** Multi-Resolution grid loop data. */
371 typedef struct GridPaintMask {
372   /**
373    * The data array contains `grid_size * grid_size` elements.
374    * Where `grid_size = (1 << (level - 1)) + 1`.
375    */
376   float *data;
377
378   /** The maximum multires level associated with this grid. */
379   unsigned int level;
380
381   char _pad[4];
382 } GridPaintMask;
383
384 /** \} */
385
386 /* -------------------------------------------------------------------- */
387 /** \name Custom Data (Original Space for Poly, Face)
388  * \{ */
389
390 /**
391  * Original space within a face (similar to UV coordinates),
392  * however they are used to determine the original position in a face.
393  *
394  * Unlike UV's these are not user editable and always start out using a fixed 0-1 range.
395  * Currently only used for particle placement.
396  */
397 #
398 #
399 typedef struct OrigSpaceFace {
400   float uv[4][2];
401 } OrigSpaceFace;
402
403 #
404 #
405 typedef struct OrigSpaceLoop {
406   float uv[2];
407 } OrigSpaceLoop;
408
409 /** \} */
410
411 /* -------------------------------------------------------------------- */
412 /** \name Custom Data (FreeStyle for Edge, Face)
413  * \{ */
414
415 typedef struct FreestyleEdge {
416   char flag;
417   char _pad[3];
418 } FreestyleEdge;
419
420 /** #FreestyleEdge.flag */
421 enum {
422   FREESTYLE_EDGE_MARK = 1,
423 };
424
425 typedef struct FreestyleFace {
426   char flag;
427   char _pad[3];
428 } FreestyleFace;
429
430 /** #FreestyleFace.flag */
431 enum {
432   FREESTYLE_FACE_MARK = 1,
433 };
434
435 /** \} */
436
437 /* -------------------------------------------------------------------- */
438 /** \name Utility Macros
439  * \{ */
440
441 #define ME_POLY_LOOP_PREV(mloop, mp, i) \
442   (&(mloop)[(mp)->loopstart + (((i) + (mp)->totloop - 1) % (mp)->totloop)])
443 #define ME_POLY_LOOP_NEXT(mloop, mp, i) (&(mloop)[(mp)->loopstart + (((i) + 1) % (mp)->totloop)])
444
445 /** Number of tri's that make up this polygon once tessellated. */
446 #define ME_POLY_TRI_TOT(mp) ((mp)->totloop - 2)
447
448 /**
449  * Check out-of-bounds material, note that this is nearly always prevented,
450  * yet its still possible in rare cases.
451  * So usage such as array lookup needs to check.
452  */
453 #define ME_MAT_NR_TEST(mat_nr, totmat) \
454   (CHECK_TYPE_ANY(mat_nr, short, const short), \
455    CHECK_TYPE_ANY(totmat, short, const short), \
456    (LIKELY(mat_nr < totmat) ? mat_nr : 0))
457
458 /** \} */
459
460 /* -------------------------------------------------------------------- */
461 /** \name Deprecated Structs
462  * \{ */
463
464 /**
465  * Used in Blender pre 2.63, See #MLoop, #MPoly for face data stored in the blend file.
466  * Use for reading old files and in a handful of cases which should be removed eventually.
467  */
468 typedef struct MFace {
469   unsigned int v1, v2, v3, v4;
470   short mat_nr;
471   /** We keep edcode, for conversion to edges draw flags in old files. */
472   char edcode, flag;
473 } MFace;
474
475 /** #MFace.edcode */
476 enum {
477   ME_V1V2 = (1 << 0),
478   ME_V2V3 = (1 << 1),
479   ME_V3V1 = (1 << 2),
480   ME_V3V4 = ME_V3V1,
481   ME_V4V1 = (1 << 3),
482 };
483
484 /** Tessellation uv face data. */
485 typedef struct MTFace {
486   float uv[4][2];
487 } MTFace;
488
489 /**
490  * Tessellation vertex color data.
491  *
492  * \note The red and blue are swapped for historical reasons.
493  */
494 typedef struct MCol {
495   unsigned char a, r, g, b;
496 } MCol;
497
498 #define MESH_MLOOPCOL_FROM_MCOL(_mloopcol, _mcol) \
499   { \
500     MLoopCol *mloopcol__tmp = _mloopcol; \
501     const MCol *mcol__tmp = _mcol; \
502     mloopcol__tmp->r = mcol__tmp->b; \
503     mloopcol__tmp->g = mcol__tmp->g; \
504     mloopcol__tmp->b = mcol__tmp->r; \
505     mloopcol__tmp->a = mcol__tmp->a; \
506   } \
507   (void)0
508
509 #define MESH_MLOOPCOL_TO_MCOL(_mloopcol, _mcol) \
510   { \
511     const MLoopCol *mloopcol__tmp = _mloopcol; \
512     MCol *mcol__tmp = _mcol; \
513     mcol__tmp->b = mloopcol__tmp->r; \
514     mcol__tmp->g = mloopcol__tmp->g; \
515     mcol__tmp->r = mloopcol__tmp->b; \
516     mcol__tmp->a = mloopcol__tmp->a; \
517   } \
518   (void)0
519
520 /** Old game engine recast navigation data, while unused 2.7x files may contain this. */
521 typedef struct MRecast {
522   int i;
523 } MRecast;
524
525 /** \} */
526
527 #ifdef __cplusplus
528 }
529 #endif