DNA_meshdata_types.h

Go to the documentation of this file.

/*
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
 * All rights reserved.
 */
 
#pragma once
 
#include "DNA_customdata_types.h"
#include "DNA_listBase.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
/* -------------------------------------------------------------------- */
typedef struct MVert {
  float co[3];
  short no[3];
  char flag, bweight;
} MVert;
 
enum {
  /*  SELECT = (1 << 0), */
  ME_VERT_TMP_TAG = (1 << 2),
  ME_HIDE = (1 << 4),
  ME_VERT_FACEDOT = (1 << 5),
  /*  ME_VERT_MERGED = (1 << 6), */
  ME_VERT_PBVH_UPDATE = (1 << 7),
};
 
typedef struct MEdge {
  unsigned int v1, v2;
  char crease, bweight;
  short flag;
} MEdge;
 
enum {
  /*  SELECT = (1 << 0), */
  ME_EDGEDRAW = (1 << 1),
  ME_SEAM = (1 << 2),
  /*  ME_HIDE = (1 << 4), */
  ME_EDGERENDER = (1 << 5),
  ME_LOOSEEDGE = (1 << 7),
  ME_EDGE_TMP_TAG = (1 << 8),
  ME_SHARP = (1 << 9), /* only reason this flag remains a 'short' */
};
 
typedef struct MPoly {
  int loopstart;
  int totloop;
  short mat_nr;
  char flag, _pad;
} MPoly;
 
enum {
  ME_SMOOTH = (1 << 0),
  ME_FACE_SEL = (1 << 1),
  /* ME_HIDE = (1 << 4), */
};
 
typedef struct MLoop {
  unsigned int v;
  unsigned int e;
} MLoop;
 
/* -------------------------------------------------------------------- */
typedef struct MSelect {
  int index;
  int type;
} MSelect;
 
enum {
  ME_VSEL = 0,
  ME_ESEL = 1,
  ME_FSEL = 2,
};
 
/* -------------------------------------------------------------------- */
typedef struct MLoopTri {
  unsigned int tri[3];
  unsigned int poly;
} MLoopTri;
#
#
typedef struct MVertTri {
  unsigned int tri[3];
} MVertTri;
 
/* -------------------------------------------------------------------- */
typedef struct MFloatProperty {
  float f;
} MFloatProperty;
typedef struct MIntProperty {
  int i;
} MIntProperty;
typedef struct MStringProperty {
  char s[255], s_len;
} MStringProperty;
typedef struct MBoolProperty {
  uint8_t b;
} MBoolProperty;
 
/* -------------------------------------------------------------------- */
typedef struct MDeformWeight {
  unsigned int def_nr;
  float weight;
} MDeformWeight;
 
typedef struct MDeformVert {
  struct MDeformWeight *dw;
  int totweight;
  int flag;
} MDeformVert;
 
typedef struct MVertSkin {
  float radius[3];
 
  int flag;
} MVertSkin;
 
typedef enum eMVertSkinFlag {
  MVERT_SKIN_ROOT = 1,
 
  MVERT_SKIN_LOOSE = 2,
} eMVertSkinFlag;
 
/* -------------------------------------------------------------------- */
typedef struct MLoopUV {
  float uv[2];
  int flag;
} MLoopUV;
 
enum {
  /* MLOOPUV_DEPRECATED = (1 << 0), MLOOPUV_EDGESEL removed */
  MLOOPUV_VERTSEL = (1 << 1),
  MLOOPUV_PINNED = (1 << 2),
};
 
typedef struct MLoopCol {
  unsigned char r, g, b, a;
} MLoopCol;
 
typedef struct MPropCol {
  float color[4];
} MPropCol;
 
typedef struct MDisps {
  /* Strange bug in SDNA: if disps pointer comes first, it fails to see totdisp */
  int totdisp;
  int level;
  float (*disps)[3];
 
  unsigned int *hidden;
} MDisps;
 
typedef struct GridPaintMask {
  float *data;
 
  unsigned int level;
 
  char _pad[4];
} GridPaintMask;
 
/* -------------------------------------------------------------------- */
#
#
typedef struct OrigSpaceFace {
  float uv[4][2];
} OrigSpaceFace;
 
#
#
typedef struct OrigSpaceLoop {
  float uv[2];
} OrigSpaceLoop;
 
/* -------------------------------------------------------------------- */
typedef struct FreestyleEdge {
  char flag;
} FreestyleEdge;
 
enum {
  FREESTYLE_EDGE_MARK = 1,
};
 
typedef struct FreestyleFace {
  char flag;
} FreestyleFace;
 
enum {
  FREESTYLE_FACE_MARK = 1,
};
 
/* -------------------------------------------------------------------- */
#define ME_POLY_LOOP_PREV(mloop, mp, i) \
  (&(mloop)[(mp)->loopstart + (((i) + (mp)->totloop - 1) % (mp)->totloop)])
#define ME_POLY_LOOP_NEXT(mloop, mp, i) (&(mloop)[(mp)->loopstart + (((i) + 1) % (mp)->totloop)])
 
#define ME_POLY_TRI_TOT(mp) ((mp)->totloop - 2)
 
#define ME_MAT_NR_TEST(mat_nr, totmat) \
  (CHECK_TYPE_ANY(mat_nr, short, const short), \
   CHECK_TYPE_ANY(totmat, short, const short), \
   (LIKELY(mat_nr < totmat) ? mat_nr : 0))
 
/* -------------------------------------------------------------------- */
typedef struct MFace {
  unsigned int v1, v2, v3, v4;
  short mat_nr;
  char edcode, flag;
} MFace;
 
enum {
  ME_V1V2 = (1 << 0),
  ME_V2V3 = (1 << 1),
  ME_V3V1 = (1 << 2),
  ME_V3V4 = ME_V3V1,
  ME_V4V1 = (1 << 3),
};
 
typedef struct MTFace {
  float uv[4][2];
} MTFace;
 
typedef struct MCol {
  unsigned char a, r, g, b;
} MCol;
 
#define MESH_MLOOPCOL_FROM_MCOL(_mloopcol, _mcol) \
  { \
    MLoopCol *mloopcol__tmp = _mloopcol; \
    const MCol *mcol__tmp = _mcol; \
    mloopcol__tmp->r = mcol__tmp->b; \
    mloopcol__tmp->g = mcol__tmp->g; \
    mloopcol__tmp->b = mcol__tmp->r; \
    mloopcol__tmp->a = mcol__tmp->a; \
  } \
  (void)0
 
#define MESH_MLOOPCOL_TO_MCOL(_mloopcol, _mcol) \
  { \
    const MLoopCol *mloopcol__tmp = _mloopcol; \
    MCol *mcol__tmp = _mcol; \
    mcol__tmp->b = mloopcol__tmp->r; \
    mcol__tmp->g = mloopcol__tmp->g; \
    mcol__tmp->r = mloopcol__tmp->b; \
    mcol__tmp->a = mloopcol__tmp->a; \
  } \
  (void)0
 
typedef struct MRecast {
  int i;
} MRecast;
 
#ifdef __cplusplus
}
#endif