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"
#include "BLI_sys_types.h"
 
#include "DNA_customdata_types.h"
#include "DNA_listBase.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;
 
// #pragma GCC diagnostic push
// #pragma GCC diagnostic error "-Wpadded"

struct BMHeader {
 
  /* NOTE: it its essential the #BMHeader is at least the size of two pointers.
   * This is a requirement of mempool's method of iteration.
   *
   * Even though there is only a single pointer, the struct will be padded to two. */

  void *data;

  int index;

  char htype;
  char hflag;

  char api_flag;
  // char _pad;
};
 
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. */
 
struct BMVert {
  BMHeader head;
  float co[3];
  float no[3];

  struct BMEdge *e;
};
 
struct BMVert_OFlag {
  BMVert base;
  struct BMFlagLayer *oflags;
};

struct BMDiskLink {
  struct BMEdge *next, *prev;
};
 
struct BMEdge {
  BMHeader head;

  BMVert *v1, *v2;

  struct BMLoop *l;

  BMDiskLink v1_disk_link, v2_disk_link;
};
 
struct BMEdge_OFlag {
  BMEdge base;
  struct BMFlagLayer *oflags;
};
 
struct BMLoop {
  BMHeader head;
  /* Notice no #BMFlagLayer, making this different from other elements. */

  struct BMVert *v;

  struct BMEdge *e;
  struct BMFace *f;

  struct BMLoop *radial_next, *radial_prev;

  struct BMLoop *next, *prev;
};

struct BMElemF {
  BMHeader head;
};

struct BMElem {
  BMHeader head;
};
 
#ifdef USE_BMESH_HOLES
struct BMLoopList {
  struct BMLoopList *next, *prev;
  struct BMLoop *first, *last;
};
#endif
 
struct BMFace {
  BMHeader head;
 
#ifdef USE_BMESH_HOLES
  int totbounds;
  ListBase loops;
#else
  BMLoop *l_first;
#endif
  int len;
  float no[3];
  short mat_nr;
  //  short _pad[3];
};
 
struct BMFace_OFlag {
  BMFace base;
  struct BMFlagLayer *oflags;
};
 
struct BMFlagLayer {
  short f; /* flags */
};
 
// #pragma GCC diagnostic pop
 
struct BMesh {
  int totvert, totedge, totloop, totface;
  int totvertsel, totedgesel, totfacesel;

  char elem_index_dirty;

  char elem_table_dirty;

  struct BLI_mempool *vpool, *epool, *lpool, *fpool;
 
  /* #BLI_mempool lookup tables (optional).
   * 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;

  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;

  short selectmode;

  int shapenr;
 
  int totflags;
  ListBase selected;

  BMFace *act_face;

  ListBase errorstack;

  void *py_handle;
};

enum {
  BM_VERT = 1,
  BM_EDGE = 2,
  BM_LOOP = 4,
  BM_FACE = 8,
};
 
struct BMLoopNorEditData {
  int loop_index;
  BMLoop *loop;
  float niloc[3];
  float nloc[3];
  float *loc;
  short *clnors_data;
};
 
struct BMLoopNorEditDataArray {
  BMLoopNorEditData *lnor_editdata;
  BMLoopNorEditData **lidx_to_lnor_editdata;
 
  int cd_custom_normal_offset;
  int totloop;
};
 
#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)

#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);
 
using BMElemFilterFunc = bool (*)(const BMElem *, void *user_data);
using BMVertFilterFunc = bool (*)(const BMVert *, void *user_data);
using BMEdgeFilterFunc = bool (*)(const BMEdge *, void *user_data);
using BMFaceFilterFunc = bool (*)(const BMFace *, void *user_data);
using BMLoopFilterFunc = bool (*)(const BMLoop *, void *user_data);
using BMLoopPairFilterFunc = bool (*)(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

#define BM_LOOP_RADIAL_MAX 10000
#define BM_NGON_MAX 100000

#define BM_THREAD_LIMIT 10000