BKE_mesh_mapping.hh

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 "BLI_array.hh"
#include "BLI_math_vector_types.hh"
#include "BLI_offset_indices.hh"
 
struct BMLoop;
struct MemArena;
 
/* UvVertMap */
#define STD_UV_CONNECT_LIMIT 0.0001f
 
struct UvMapVert {
  UvMapVert *next;
  unsigned int face_index;
  unsigned short loop_of_face_index;
  bool separate;
};
 
struct UvVertMap {
  UvMapVert **vert;
  UvMapVert *buf;
};
 
struct UvElement {
  UvElement *next;
  BMLoop *l;
  unsigned short loop_of_face_index;
  bool separate;
  unsigned char flag;
  unsigned int island;
};
 
struct UvElementMap {
  UvElement *storage;
  int total_uvs;
  int total_unique_uvs;
 
  UvElement **vertex;
 
  UvElement **head_table;
 
  int *unique_index_table;
 
  int total_islands;
  int *island_indices;
  int *island_total_uvs;
  int *island_total_unique_uvs;
};
 
/* Connectivity data */
struct MeshElemMap {
  int *indices;
  int count;
};
 
/* mapping */
 
UvVertMap *BKE_mesh_uv_vert_map_create(blender::OffsetIndices<int> faces,
                                       const bool *hide_poly,
                                       const bool *select_poly,
                                       const int *corner_verts,
                                       const float (*mloopuv)[2],
                                       unsigned int totvert,
                                       const float limit[2],
                                       bool selected,
                                       bool use_winding);
 
UvMapVert *BKE_mesh_uv_vert_map_get_vert(UvVertMap *vmap, unsigned int v);
void BKE_mesh_uv_vert_map_free(UvVertMap *vmap);
 
void BKE_mesh_vert_corner_tri_map_create(MeshElemMap **r_map,
                                         int **r_mem,
                                         int totvert,
                                         const blender::int3 *corner_tris,
                                         int tris_num,
                                         const int *corner_verts,
                                         int corners_num);
void BKE_mesh_origindex_map_create(
    MeshElemMap **r_map, int **r_mem, int totsource, const int *final_origindex, int totfinal);
void BKE_mesh_origindex_map_create_corner_tri(MeshElemMap **r_map,
                                              int **r_mem,
                                              blender::OffsetIndices<int> faces,
                                              const int *corner_tri_faces,
                                              int corner_tris_num);
 
/* islands */
 
/* Loop islands data helpers. */
enum {
  MISLAND_TYPE_NONE = 0,
  MISLAND_TYPE_VERT = 1,
  MISLAND_TYPE_EDGE = 2,
  MISLAND_TYPE_POLY = 3,
  MISLAND_TYPE_LOOP = 4,
};
 
struct MeshIslandStore {
  short item_type;     /* MISLAND_TYPE_... */
  short island_type;   /* MISLAND_TYPE_... */
  short innercut_type; /* MISLAND_TYPE_... */
 
  int items_to_islands_num;
  int *items_to_islands; /* map the item to the island index */
 
  int islands_num;
  size_t islands_num_alloc;
  MeshElemMap **islands;   /* Array of pointers, one item per island. */
  MeshElemMap **innercuts; /* Array of pointers, one item per island. */
 
  MemArena *mem; /* Memory arena, internal use only. */
};
 
void BKE_mesh_loop_islands_init(MeshIslandStore *island_store,
                                short item_type,
                                int items_num,
                                short island_type,
                                short innercut_type);
void BKE_mesh_loop_islands_clear(MeshIslandStore *island_store);
void BKE_mesh_loop_islands_free(MeshIslandStore *island_store);
void BKE_mesh_loop_islands_add(MeshIslandStore *island_store,
                               int item_num,
                               const int *items_indices,
                               int num_island_items,
                               int *island_item_indices,
                               int num_innercut_items,
                               int *innercut_item_indices);
 
using MeshRemapIslandsCalc = bool (*)(const float (*vert_positions)[3],
                                      int totvert,
                                      const blender::int2 *edges,
                                      int totedge,
                                      const bool *uv_seams,
                                      blender::OffsetIndices<int> faces,
                                      const int *corner_verts,
                                      const int *corner_edges,
                                      int corners_num,
                                      MeshIslandStore *r_island_store);
 
/* Above vert/UV mapping stuff does not do what we need here, but does things we do not need here.
 * So better keep them separated for now, I think. */
 
bool BKE_mesh_calc_islands_loop_face_edgeseam(const float (*vert_positions)[3],
                                              int totvert,
                                              const blender::int2 *edges,
                                              int totedge,
                                              const bool *uv_seams,
                                              blender::OffsetIndices<int> faces,
                                              const int *corner_verts,
                                              const int *corner_edges,
                                              int corners_num,
                                              MeshIslandStore *r_island_store);
 
bool BKE_mesh_calc_islands_loop_face_uvmap(float (*vert_positions)[3],
                                           int totvert,
                                           blender::int2 *edges,
                                           int totedge,
                                           const bool *uv_seams,
                                           blender::OffsetIndices<int> faces,
                                           const int *corner_verts,
                                           const int *corner_edges,
                                           int corners_num,
                                           const float (*luvs)[2],
                                           MeshIslandStore *r_island_store);
 
int *BKE_mesh_calc_smoothgroups(int edges_num,
                                blender::OffsetIndices<int> faces,
                                blender::Span<int> corner_edges,
                                blender::Span<bool> sharp_edges,
                                blender::Span<bool> sharp_faces,
                                int *r_totgroup,
                                bool use_bitflags);
 
/* Use on corner_tri vertex values. */
#define BKE_MESH_TESSTRI_VINDEX_ORDER(_tri, _v) \
  ((CHECK_TYPE_ANY( \
        _tri, unsigned int *, int *, int[3], const unsigned int *, const int *, const int[3]), \
    CHECK_TYPE_ANY(_v, unsigned int, const unsigned int, int, const int)), \
   (((_tri)[0] == _v) ? 0 : \
    ((_tri)[1] == _v) ? 1 : \
    ((_tri)[2] == _v) ? 2 : \
                        -1))
 
namespace blender::bke::mesh {
 
Array<int> build_corner_to_face_map(OffsetIndices<int> faces);
 
GroupedSpan<int> build_vert_to_edge_map(Span<int2> edges,
                                        int verts_num,
                                        Array<int> &r_offsets,
                                        Array<int> &r_indices);
 
void build_vert_to_face_indices(OffsetIndices<int> faces,
                                Span<int> corner_verts,
                                OffsetIndices<int> offsets,
                                MutableSpan<int> face_indices);
GroupedSpan<int> build_vert_to_face_map(OffsetIndices<int> faces,
                                        Span<int> corner_verts,
                                        int verts_num,
                                        Array<int> &r_offsets,
                                        Array<int> &r_indices);
 
Array<int> build_vert_to_corner_indices(Span<int> corner_verts, OffsetIndices<int> offsets);
GroupedSpan<int> build_vert_to_corner_map(Span<int> corner_verts,
                                          int verts_num,
                                          Array<int> &r_offsets,
                                          Array<int> &r_indices);
 
GroupedSpan<int> build_edge_to_corner_map(Span<int> corner_edges,
                                          int edges_num,
                                          Array<int> &r_offsets,
                                          Array<int> &r_indices);
 
GroupedSpan<int> build_edge_to_face_map(OffsetIndices<int> faces,
                                        Span<int> corner_edges,
                                        int edges_num,
                                        Array<int> &r_offsets,
                                        Array<int> &r_indices);
 
}  // namespace blender::bke::mesh