bmesh_class.hh

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2023 Blender Authors
 *
 * SPDX-License-Identifier: GPL-2.0-or-later */
 
#pragma once
 
#include "BLI_assert.h"
 
/* disable holes for now,
 * these are ifdef'd because they use more memory and can't be saved in DNA currently */
// #define USE_BMESH_HOLES
 
struct BMEdge;
struct BMFace;
struct BMLoop;
struct BMVert;
struct BMesh;
 
struct MLoopNorSpaceArray;
 
struct BLI_mempool;
 
/* NOTE: it is very important for BMHeader to start with two
 * pointers. this is a requirement of mempool's method of
 * iteration.
 *
 * hrm. it doesn't but still works ok, remove the comment above? - campbell.
 */
 
// #pragma GCC diagnostic error "-Wpadded"
 
typedef struct BMHeader {
  void *data;
 
  int index;
 
  char htype;
  char hflag;
 
  char api_flag;
  // char _pad;
} BMHeader;
 
BLI_STATIC_ASSERT((sizeof(BMHeader) <= 16), "BMHeader size has grown!");
 
/* NOTE: need some way to specify custom locations for custom data layers.  so we can
 * make them point directly into structs.  and some way to make it only happen to the
 * active layer, and properly update when switching active layers. */
 
typedef struct BMVert {
  BMHeader head;
 
  float co[3]; /* vertex coordinates */
  float no[3]; /* vertex normal */
 
  struct BMEdge *e;
} BMVert;
 
typedef struct BMVert_OFlag {
  BMVert base;
  struct BMFlagLayer *oflags;
} BMVert_OFlag;
 
/* disk link structure, only used by edges */
typedef struct BMDiskLink {
  struct BMEdge *next, *prev;
} BMDiskLink;
 
typedef struct BMEdge {
  BMHeader head;
 
  BMVert *v1, *v2;
 
  struct BMLoop *l;
 
  BMDiskLink v1_disk_link, v2_disk_link;
} BMEdge;
 
typedef struct BMEdge_OFlag {
  BMEdge base;
  struct BMFlagLayer *oflags;
} BMEdge_OFlag;
 
typedef struct BMLoop {
  BMHeader head;
  /* notice no flags layer */
 
  struct BMVert *v;
 
  struct BMEdge *e;
  struct BMFace *f;
 
  struct BMLoop *radial_next, *radial_prev;
 
  struct BMLoop *next, *prev;
} BMLoop;
 
/* can cast BMFace/BMEdge/BMVert, but NOT BMLoop, since these don't have a flag layer */
typedef struct BMElemF {
  BMHeader head;
} BMElemF;
 
/* can cast anything to this, including BMLoop */
typedef struct BMElem {
  BMHeader head;
} BMElem;
 
#ifdef USE_BMESH_HOLES
/* eventually, this structure will be used for supporting holes in faces */
typedef struct BMLoopList {
  struct BMLoopList *next, *prev;
  struct BMLoop *first, *last;
} BMLoopList;
#endif
 
typedef struct BMFace {
  BMHeader head;
 
#ifdef USE_BMESH_HOLES
  int totbounds; /* Total boundaries, is one plus the number of holes in the face. */
  ListBase loops;
#else
  BMLoop *l_first;
#endif
  int len;
  float no[3];
  short mat_nr;
  //  short _pad[3];
} BMFace;
 
typedef struct BMFace_OFlag {
  BMFace base;
  struct BMFlagLayer *oflags;
} BMFace_OFlag;
 
typedef struct BMFlagLayer {
  short f; /* flags */
} BMFlagLayer;
 
// #pragma GCC diagnostic ignored "-Wpadded"
 
typedef struct BMesh {
  int totvert, totedge, totloop, totface;
  int totvertsel, totedgesel, totfacesel;
 
  char elem_index_dirty;
 
  char elem_table_dirty;
 
  /* element pools */
  struct BLI_mempool *vpool, *epool, *lpool, *fpool;
 
  /* mempool lookup tables (optional)
   * index tables, to map indices to elements via
   * BM_mesh_elem_table_ensure and associated functions.  don't
   * touch this or read it directly.\
   * Use BM_mesh_elem_table_ensure(), BM_vert/edge/face_at_index() */
  BMVert **vtable;
  BMEdge **etable;
  BMFace **ftable;
 
  /* size of allocated tables */
  int vtable_tot;
  int etable_tot;
  int ftable_tot;
 
  /* Operator API stuff (must be all null or all allocated). */
  struct BLI_mempool *vtoolflagpool, *etoolflagpool, *ftoolflagpool;
 
  uint use_toolflags : 1;
 
  int toolflag_index;
 
  CustomData vdata, edata, ldata, pdata;
 
#ifdef USE_BMESH_HOLES
  struct BLI_mempool *looplistpool;
#endif
 
  struct MLoopNorSpaceArray *lnor_spacearr;
  char spacearr_dirty;
 
  /* Should be copy of scene select mode. */
  /* Stored in #BMEditMesh too, this is a bit confusing,
   * make sure they're in sync!
   * Only use when the edit mesh can't be accessed - campbell */
  short selectmode;
 
  /* ID of the shape key this bmesh came from */
  int shapenr;
 
  int totflags;
  ListBase selected;
 
  BMFace *act_face;
 
  ListBase errorstack;
 
  void *py_handle;
} BMesh;
 
enum {
  BM_VERT = 1,
  BM_EDGE = 2,
  BM_LOOP = 4,
  BM_FACE = 8,
};
 
typedef struct BMLoopNorEditData {
  int loop_index;
  BMLoop *loop;
  float niloc[3];
  float nloc[3];
  float *loc;
  short *clnors_data;
} BMLoopNorEditData;
 
typedef struct BMLoopNorEditDataArray {
  BMLoopNorEditData *lnor_editdata;
  BMLoopNorEditData **lidx_to_lnor_editdata;
 
  int cd_custom_normal_offset;
  int totloop;
} BMLoopNorEditDataArray;
 
#define BM_ALL (BM_VERT | BM_EDGE | BM_LOOP | BM_FACE)
#define BM_ALL_NOLOOP (BM_VERT | BM_EDGE | BM_FACE)
 
enum {
  BM_SPACEARR_DIRTY = 1 << 0,
  BM_SPACEARR_DIRTY_ALL = 1 << 1,
  BM_SPACEARR_BMO_SET = 1 << 2,
};
 
/* args for _Generic */
#define _BM_GENERIC_TYPE_ELEM_NONCONST \
  void *, BMVert *, BMEdge *, BMLoop *, BMFace *, BMVert_OFlag *, BMEdge_OFlag *, BMFace_OFlag *, \
      BMElem *, BMElemF *, BMHeader *
 
#define _BM_GENERIC_TYPE_ELEM_CONST \
  const void *, const BMVert *, const BMEdge *, const BMLoop *, const BMFace *, \
      const BMVert_OFlag *, const BMEdge_OFlag *, const BMFace_OFlag *, const BMElem *, \
      const BMElemF *, const BMHeader *
 
#define BM_CHECK_TYPE_ELEM_CONST(ele) CHECK_TYPE_ANY(ele, _BM_GENERIC_TYPES_CONST)
 
#define BM_CHECK_TYPE_ELEM_NONCONST(ele) CHECK_TYPE_ANY(ele, _BM_GENERIC_TYPE_ELEM_NONCONST)
 
#define BM_CHECK_TYPE_ELEM(ele) \
  CHECK_TYPE_ANY(ele, _BM_GENERIC_TYPE_ELEM_NONCONST, _BM_GENERIC_TYPE_ELEM_CONST)
 
/* vert */
#define _BM_GENERIC_TYPE_VERT_NONCONST BMVert *, BMVert_OFlag *
#define _BM_GENERIC_TYPE_VERT_CONST const BMVert *, const BMVert_OFlag *
#define BM_CHECK_TYPE_VERT_CONST(ele) CHECK_TYPE_ANY(ele, _BM_GENERIC_TYPE_VERT_CONST)
#define BM_CHECK_TYPE_VERT_NONCONST(ele) CHECK_TYPE_ANY(ele, _BM_GENERIC_TYPE_ELEM_NONCONST)
#define BM_CHECK_TYPE_VERT(ele) \
  CHECK_TYPE_ANY(ele, _BM_GENERIC_TYPE_VERT_NONCONST, _BM_GENERIC_TYPE_VERT_CONST)
/* edge */
#define _BM_GENERIC_TYPE_EDGE_NONCONST BMEdge *, BMEdge_OFlag *
#define _BM_GENERIC_TYPE_EDGE_CONST const BMEdge *, const BMEdge_OFlag *
#define BM_CHECK_TYPE_EDGE_CONST(ele) CHECK_TYPE_ANY(ele, _BM_GENERIC_TYPE_EDGE_CONST)
#define BM_CHECK_TYPE_EDGE_NONCONST(ele) CHECK_TYPE_ANY(ele, _BM_GENERIC_TYPE_ELEM_NONCONST)
#define BM_CHECK_TYPE_EDGE(ele) \
  CHECK_TYPE_ANY(ele, _BM_GENERIC_TYPE_EDGE_NONCONST, _BM_GENERIC_TYPE_EDGE_CONST)
/* face */
#define _BM_GENERIC_TYPE_FACE_NONCONST BMFace *, BMFace_OFlag *
#define _BM_GENERIC_TYPE_FACE_CONST const BMFace *, const BMFace_OFlag *
#define BM_CHECK_TYPE_FACE_CONST(ele) CHECK_TYPE_ANY(ele, _BM_GENERIC_TYPE_FACE_CONST)
#define BM_CHECK_TYPE_FACE_NONCONST(ele) CHECK_TYPE_ANY(ele, _BM_GENERIC_TYPE_ELEM_NONCONST)
#define BM_CHECK_TYPE_FACE(ele) \
  CHECK_TYPE_ANY(ele, _BM_GENERIC_TYPE_FACE_NONCONST, _BM_GENERIC_TYPE_FACE_CONST)
 
/* Assignment from a void* to a typed pointer is not allowed in C++,
 * casting the LHS to void works fine though.
 */
#define BM_CHECK_TYPE_ELEM_ASSIGN(ele) (BM_CHECK_TYPE_ELEM(ele)), *((void **)&ele)
 
enum {
  BM_ELEM_SELECT = (1 << 0),
  BM_ELEM_HIDDEN = (1 << 1),
  BM_ELEM_SEAM = (1 << 2),
  BM_ELEM_SMOOTH = (1 << 3),
  BM_ELEM_TAG = (1 << 4),
 
  BM_ELEM_DRAW = (1 << 5), /* edge display */
 
  BM_ELEM_TAG_ALT = (1 << 6),
 
  BM_ELEM_INTERNAL_TAG = (1 << 7),
};
 
struct BPy_BMGeneric;
extern void bpy_bm_generic_invalidate(struct BPy_BMGeneric *self);
 
typedef bool (*BMElemFilterFunc)(const BMElem *, void *user_data);
typedef bool (*BMVertFilterFunc)(const BMVert *, void *user_data);
typedef bool (*BMEdgeFilterFunc)(const BMEdge *, void *user_data);
typedef bool (*BMFaceFilterFunc)(const BMFace *, void *user_data);
typedef bool (*BMLoopFilterFunc)(const BMLoop *, void *user_data);
typedef bool (*BMLoopPairFilterFunc)(const BMLoop *, const BMLoop *, void *user_data);
 
/* defines */
#define BM_ELEM_CD_SET_INT(ele, offset, f) \
  { \
    CHECK_TYPE_NONCONST(ele); \
    BLI_assert(offset != -1); \
    *((int *)((char *)(ele)->head.data + (offset))) = (f); \
  } \
  (void)0
 
#define BM_ELEM_CD_GET_INT(ele, offset) \
  (BLI_assert(offset != -1), *((int *)((char *)(ele)->head.data + (offset))))
 
#define BM_ELEM_CD_SET_BOOL(ele, offset, f) \
  { \
    CHECK_TYPE_NONCONST(ele); \
    BLI_assert(offset != -1); \
    *((bool *)((char *)(ele)->head.data + (offset))) = (f); \
  } \
  (void)0
 
#define BM_ELEM_CD_GET_BOOL(ele, offset) \
  (BLI_assert(offset != -1), *((bool *)((char *)(ele)->head.data + (offset))))
 
#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L)
#  define BM_ELEM_CD_GET_BOOL_P(ele, offset) \
    (BLI_assert(offset != -1), \
     _Generic(ele, \
     GENERIC_TYPE_ANY((bool *)POINTER_OFFSET((ele)->head.data, offset), \
                      _BM_GENERIC_TYPE_ELEM_NONCONST), \
     GENERIC_TYPE_ANY((const bool *)POINTER_OFFSET((ele)->head.data, offset), \
                      _BM_GENERIC_TYPE_ELEM_CONST)))
#else
#  define BM_ELEM_CD_GET_BOOL_P(ele, offset) \
    (BLI_assert(offset != -1), (bool *)((char *)(ele)->head.data + (offset)))
#endif
 
#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L)
#  define BM_ELEM_CD_GET_VOID_P(ele, offset) \
    (BLI_assert(offset != -1), \
     _Generic(ele, \
     GENERIC_TYPE_ANY(POINTER_OFFSET((ele)->head.data, offset), _BM_GENERIC_TYPE_ELEM_NONCONST), \
     GENERIC_TYPE_ANY((const void *)POINTER_OFFSET((ele)->head.data, offset), \
                      _BM_GENERIC_TYPE_ELEM_CONST)))
#else
#  define BM_ELEM_CD_GET_VOID_P(ele, offset) \
    (BLI_assert(offset != -1), (void *)((char *)(ele)->head.data + (offset)))
#endif
 
#define BM_ELEM_CD_SET_FLOAT(ele, offset, f) \
  { \
    CHECK_TYPE_NONCONST(ele); \
    BLI_assert(offset != -1); \
    *((float *)((char *)(ele)->head.data + (offset))) = (f); \
  } \
  (void)0
 
#define BM_ELEM_CD_GET_FLOAT(ele, offset) \
  (BLI_assert(offset != -1), *((float *)((char *)(ele)->head.data + (offset))))
 
#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L)
 
#  define BM_ELEM_CD_GET_FLOAT_P(ele, offset) \
    (BLI_assert(offset != -1), \
     _Generic(ele, \
     GENERIC_TYPE_ANY((float *)POINTER_OFFSET((ele)->head.data, offset), \
                      _BM_GENERIC_TYPE_ELEM_NONCONST), \
     GENERIC_TYPE_ANY((const float *)POINTER_OFFSET((ele)->head.data, offset), \
                      _BM_GENERIC_TYPE_ELEM_CONST)))
 
#  define BM_ELEM_CD_GET_FLOAT2_P(ele, offset) \
    (BLI_assert(offset != -1), \
     _Generic(ele, \
     GENERIC_TYPE_ANY((float(*)[2])POINTER_OFFSET((ele)->head.data, offset), \
                      _BM_GENERIC_TYPE_ELEM_NONCONST), \
     GENERIC_TYPE_ANY((const float(*)[2])POINTER_OFFSET((ele)->head.data, offset), \
                      _BM_GENERIC_TYPE_ELEM_CONST)))
 
#  define BM_ELEM_CD_GET_FLOAT3_P(ele, offset) \
    (BLI_assert(offset != -1), \
     _Generic(ele, \
     GENERIC_TYPE_ANY((float(*)[3])POINTER_OFFSET((ele)->head.data, offset), \
                      _BM_GENERIC_TYPE_ELEM_NONCONST), \
     GENERIC_TYPE_ANY((const float(*)[3])POINTER_OFFSET((ele)->head.data, offset), \
                      _BM_GENERIC_TYPE_ELEM_CONST)))
 
#else
 
#  define BM_ELEM_CD_GET_FLOAT_P(ele, offset) \
    (BLI_assert(offset != -1), (float *)((char *)(ele)->head.data + (offset)))
 
#  define BM_ELEM_CD_GET_FLOAT2_P(ele, offset) \
    (BLI_assert(offset != -1), (float(*)[2])((char *)(ele)->head.data + (offset)))
 
#  define BM_ELEM_CD_GET_FLOAT3_P(ele, offset) \
    (BLI_assert(offset != -1), (float(*)[3])((char *)(ele)->head.data + (offset)))
 
#endif
 
#define BM_ELEM_CD_SET_FLOAT2(ele, offset, f) \
  { \
    CHECK_TYPE_NONCONST(ele); \
    BLI_assert(offset != -1); \
    ((float *)((char *)(ele)->head.data + (offset)))[0] = (f)[0]; \
    ((float *)((char *)(ele)->head.data + (offset)))[1] = (f)[1]; \
  } \
  (void)0
 
#define BM_ELEM_CD_SET_FLOAT3(ele, offset, f) \
  { \
    CHECK_TYPE_NONCONST(ele); \
    BLI_assert(offset != -1); \
    ((float *)((char *)(ele)->head.data + (offset)))[0] = (f)[0]; \
    ((float *)((char *)(ele)->head.data + (offset)))[1] = (f)[1]; \
    ((float *)((char *)(ele)->head.data + (offset)))[2] = (f)[2]; \
  } \
  (void)0
 
#define BM_ELEM_CD_GET_FLOAT_AS_UCHAR(ele, offset) \
  (BLI_assert(offset != -1), (uchar)(BM_ELEM_CD_GET_FLOAT(ele, offset) * 255.0f))
 
/* Forward declarations. */
 
#ifdef USE_BMESH_HOLES
#  define BM_FACE_FIRST_LOOP(p) (((BMLoopList *)((p)->loops.first))->first)
#else
#  define BM_FACE_FIRST_LOOP(p) ((p)->l_first)
#endif
 
#define BM_DISK_EDGE_NEXT(e, v) \
  (CHECK_TYPE_INLINE(e, BMEdge *), \
   CHECK_TYPE_INLINE(v, BMVert *), \
   BLI_assert(BM_vert_in_edge(e, v)), \
   (((&e->v1_disk_link)[v == e->v2]).next))
#define BM_DISK_EDGE_PREV(e, v) \
  (CHECK_TYPE_INLINE(e, BMEdge *), \
   CHECK_TYPE_INLINE(v, BMVert *), \
   BLI_assert(BM_vert_in_edge(e, v)), \
   (((&e->v1_disk_link)[v == e->v2]).prev))
 
#define BM_DEFAULT_NGON_STACK_SIZE 32
#define BM_DEFAULT_ITER_STACK_SIZE 16
 
/* avoid inf loop, this value is arbitrary
 * but should not error on valid cases */
#define BM_LOOP_RADIAL_MAX 10000
#define BM_NGON_MAX 100000
 
/* Minimum number of elements before using threading. */
#define BM_THREAD_LIMIT 10000