DNA_mesh_types.h

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2001-2002 NaN Holding BV. All rights reserved.
 *
 * SPDX-License-Identifier: GPL-2.0-or-later */

 
#pragma once
 
#include "DNA_ID.h"
#include "DNA_attribute_types.h"
#include "DNA_customdata_types.h"
#include "DNA_defs.h"
#include "DNA_session_uid_types.h"

#ifdef __cplusplus
 
#  include <optional>
 
#  include "BLI_math_vector_types.hh"
#  include "BLI_memory_counter_fwd.hh"
#  include "BLI_vector_set.hh"
 
namespace blender {
template<typename T> struct Bounds;
namespace offset_indices {
template<typename T> struct GroupedSpan;
template<typename T> class OffsetIndices;
}  // namespace offset_indices
using offset_indices::GroupedSpan;
using offset_indices::OffsetIndices;
template<typename T> class MutableSpan;
template<typename T> class Span;
namespace bke {
struct BVHTreeFromMesh;
struct MeshRuntime;
class AttributeAccessor;
class MutableAttributeAccessor;
struct LooseVertCache;
struct LooseEdgeCache;
enum class MeshNormalDomain : int8_t;
}  // namespace bke
}  // namespace blender
using MeshRuntimeHandle = blender::bke::MeshRuntime;
#else
typedef struct MeshRuntimeHandle MeshRuntimeHandle;
#endif
 
struct AnimData;
struct Key;
struct MCol;
struct MEdge;
struct MFace;
struct Material;
 
typedef struct Mesh {
#ifdef __cplusplus
  DNA_DEFINE_CXX_METHODS(Mesh)
  static constexpr ID_Type id_type = ID_ME;
#endif
 
  ID id;
  struct AnimData *adt;
 
  struct Key *key;

  struct Material **mat;

  int verts_num;
  int edges_num;
  int faces_num;
  int corners_num;

  int *face_offset_indices;

  struct AttributeStorage attribute_storage;
 
  CustomData vert_data;
  CustomData edge_data;
  CustomData face_data;
  CustomData corner_data;

  ListBase vertex_group_names;
  int vertex_group_active_index;

  int attributes_active_index;

  struct MSelect *mselect;

  int totselect;

  int act_face;

  struct Mesh *texcomesh;

  float texspace_location[3];
  float texspace_size[3];
  char texspace_flag;

  char editflag;
  uint16_t flag;
 
  float smoothresh_legacy DNA_DEPRECATED;

  float remesh_voxel_size;
  float remesh_voxel_adaptivity;
 
  int face_sets_color_seed;
  /* Stores the initial Face Set to be rendered white. This way the overlay can be enabled by
   * default and Face Sets can be used without affecting the color of the mesh. */
  int face_sets_color_default;

  char *active_color_attribute;
  char *default_color_attribute;

  char *active_uv_map_attribute;
  char *default_uv_map_attribute;

  char symmetry;

  char remesh_mode;

  short totcol;

  char cd_flag DNA_DEPRECATED;
  char subdiv DNA_DEPRECATED;
  char subdivr DNA_DEPRECATED;
  char subsurftype DNA_DEPRECATED;

  struct MPoly *mpoly DNA_DEPRECATED;
  struct MLoop *mloop DNA_DEPRECATED;

  struct MVert *mvert DNA_DEPRECATED;
  struct MEdge *medge DNA_DEPRECATED;
  struct MDeformVert *dvert DNA_DEPRECATED;
  struct MTFace *mtface DNA_DEPRECATED;
  struct TFace *tface DNA_DEPRECATED;
  struct MCol *mcol DNA_DEPRECATED;
  struct MFace *mface DNA_DEPRECATED;

  CustomData fdata_legacy;
  /* Deprecated size of #fdata. */
  int totface_legacy;
 
  char _pad1;
  int8_t radial_symmetry[3];

  MeshRuntimeHandle *runtime;
#ifdef __cplusplus
  blender::Span<blender::float3> vert_positions() const;
  blender::MutableSpan<blender::float3> vert_positions_for_write();
  blender::Span<blender::int2> edges() const;
  blender::MutableSpan<blender::int2> edges_for_write();
  blender::OffsetIndices<int> faces() const;
  blender::Span<int> face_offsets() const;
  blender::MutableSpan<int> face_offsets_for_write();

  blender::Span<int> corner_verts() const;
  blender::MutableSpan<int> corner_verts_for_write();

  blender::Span<int> corner_edges() const;
  blender::MutableSpan<int> corner_edges_for_write();
 
  blender::bke::AttributeAccessor attributes() const;
  blender::bke::MutableAttributeAccessor attributes_for_write();

  blender::Span<MDeformVert> deform_verts() const;
  blender::MutableSpan<MDeformVert> deform_verts_for_write();

  blender::Span<blender::int3> corner_tris() const;

  blender::Span<int> corner_tri_faces() const;

  std::optional<blender::Bounds<blender::float3>> bounds_min_max() const;

  void bounds_set_eager(const blender::Bounds<blender::float3> &bounds);

  std::optional<int> material_index_max() const;

  const blender::VectorSet<int> &material_indices_used() const;

  blender::Span<int> corner_to_face_map() const;
  blender::OffsetIndices<int> vert_to_face_map_offsets() const;
  blender::GroupedSpan<int> vert_to_corner_map() const;
  blender::GroupedSpan<int> vert_to_face_map() const;

  const blender::bke::LooseEdgeCache &loose_edges() const;
  const blender::bke::LooseVertCache &loose_verts() const;
  const blender::bke::LooseVertCache &verts_no_face() const;
  bool no_overlapping_topology() const;

  void tag_loose_edges_none() const;
  void tag_loose_verts_none() const;
  void tag_overlapping_none();

  blender::bke::MeshNormalDomain normals_domain(const bool support_sharp_face = false) const;
  blender::Span<blender::float3> face_normals() const;
  blender::Span<blender::float3> face_normals_true() const;
  blender::Span<blender::float3> vert_normals() const;
  blender::Span<blender::float3> vert_normals_true() const;
  blender::Span<blender::float3> corner_normals() const;
 
  blender::bke::BVHTreeFromMesh bvh_verts() const;
  blender::bke::BVHTreeFromMesh bvh_edges() const;
  blender::bke::BVHTreeFromMesh bvh_legacy_faces() const;
  blender::bke::BVHTreeFromMesh bvh_corner_tris() const;
  blender::bke::BVHTreeFromMesh bvh_corner_tris_no_hidden() const;
  blender::bke::BVHTreeFromMesh bvh_loose_verts() const;
  blender::bke::BVHTreeFromMesh bvh_loose_edges() const;
  blender::bke::BVHTreeFromMesh bvh_loose_no_hidden_verts() const;
  blender::bke::BVHTreeFromMesh bvh_loose_no_hidden_edges() const;
 
  void count_memory(blender::MemoryCounter &memory) const;

  void tag_positions_changed();
  void tag_positions_changed_uniformly();
  void tag_positions_changed_no_normals();
  void tag_sharpness_changed();
  void tag_custom_normals_changed();
  void tag_face_winding_changed();
  void tag_edges_split();
  void tag_topology_changed();
  void tag_visibility_changed();
  void tag_material_index_changed();
#endif
} Mesh;
 
/* deprecated by MTFace, only here for file reading */
#ifdef DNA_DEPRECATED_ALLOW
typedef struct TFace {
  DNA_DEFINE_CXX_METHODS(TFace)
 
  
  void *tpage;
  float uv[4][2];
  unsigned int col[4];
  char flag, transp;
  short mode, tile, unwrap;
} TFace;
#endif
 
/* **************** MESH ********************* */

enum {
  ME_TEXSPACE_FLAG_AUTO = 1 << 0,
  ME_TEXSPACE_FLAG_AUTO_EVALUATED = 1 << 1,
};

enum {
  ME_EDIT_MIRROR_VERTEX_GROUPS = 1 << 0,
  ME_EDIT_MIRROR_Y = 1 << 1, /* unused so far */
  ME_EDIT_MIRROR_Z = 1 << 2, /* unused so far */
 
  ME_EDIT_PAINT_FACE_SEL = 1 << 3,
  ME_EDIT_MIRROR_TOPO = 1 << 4,
  ME_EDIT_PAINT_VERT_SEL = 1 << 5,
};
 
/* Helper macro to see if vertex group X mirror is on. */
#define ME_USING_MIRROR_X_VERTEX_GROUPS(_me) \
  (((_me)->editflag & ME_EDIT_MIRROR_VERTEX_GROUPS) && ((_me)->symmetry & ME_SYMMETRY_X))
 
/* We can't have both flags enabled at once,
 * flags defined in DNA_scene_types.h */
#define ME_EDIT_PAINT_SEL_MODE(_me) \
  (((_me)->editflag & ME_EDIT_PAINT_FACE_SEL) ? SCE_SELECT_FACE : \
   ((_me)->editflag & ME_EDIT_PAINT_VERT_SEL) ? SCE_SELECT_VERTEX : \
                                                0)

enum {
  ME_FLAG_UNUSED_0 = 1 << 0,     /* cleared */
  ME_FLAG_UNUSED_1 = 1 << 1,     /* cleared */
  ME_FLAG_DEPRECATED_2 = 1 << 2, /* deprecated */
  ME_FLAG_UV_SELECT_SYNC_VALID = 1 << 3,
  ME_FLAG_UNUSED_4 = 1 << 4,     /* cleared */
  ME_AUTOSMOOTH_LEGACY = 1 << 5, /* deprecated */
  ME_FLAG_UNUSED_6 = 1 << 6,     /* cleared */
  ME_FLAG_UNUSED_7 = 1 << 7,     /* cleared */
  ME_REMESH_REPROJECT_ATTRIBUTES = 1 << 8,
  ME_DS_EXPAND = 1 << 9,
  ME_SCULPT_DYNAMIC_TOPOLOGY = 1 << 10,
  ME_NO_OVERLAPPING_TOPOLOGY = 1 << 11,
  ME_FLAG_UNUSED_8 = 1 << 12, /* deprecated */
  ME_REMESH_FIX_POLES = 1 << 13,
  ME_REMESH_REPROJECT_VOLUME = 1 << 14,
  ME_FLAG_UNUSED_9 = 1 << 15, /* deprecated */
};
 
#ifdef DNA_DEPRECATED_ALLOW
enum {
  ME_CDFLAG_VERT_BWEIGHT = 1 << 0,
  ME_CDFLAG_EDGE_BWEIGHT = 1 << 1,
  ME_CDFLAG_EDGE_CREASE = 1 << 2,
  ME_CDFLAG_VERT_CREASE = 1 << 3,
};
#endif

enum {
  REMESH_VOXEL = 0,
  REMESH_QUAD = 1,
};

typedef enum MeshSubdivType {
  ME_CC_SUBSURF = 0,
  ME_SIMPLE_SUBSURF = 1,
} MeshSubdivType;

typedef enum eMeshSymmetryType {
  ME_SYMMETRY_X = 1 << 0,
  ME_SYMMETRY_Y = 1 << 1,
  ME_SYMMETRY_Z = 1 << 2,
} eMeshSymmetryType;
 
#define MESH_MAX_VERTS 2000000000L