70 return elem_id[v_index] == elem;
171 visited_verts[neighbor_vertex_index].set();
205 if (!visited_verts[neighbor_vertex_index] && neighbor_v != diagonal_v &&
209 visited_verts[neighbor_vertex_index].set(
true);
235 BMIter iter, iter_a, iter_b;
256 bool any_tagged =
false;
284 if (initial_vertex_pole !=
nullptr) {
291 BMFace *f, *init_face =
nullptr;
301 if (init_face !=
nullptr) {
310 bool valid_tag_found =
false;
323 valid_tag_found =
true;
338 return valid_tag_found;
349 if (!visited_verts[i]) {
353 visited_verts[i] =
true;
354 elem_id[i] = current_id;
360 BMVert *current_v, *neighbor_v;
366 if (!visited_verts[neighbor_index]) {
367 visited_verts[neighbor_index] =
true;
368 elem_id[neighbor_index] = current_id;
377 MEM_delete(visited_verts);
407 "dissolve_verts verts=%hv use_face_split=%b use_boundary_tear=%b",
424 "dissolve_verts verts=%hv use_face_split=%b use_boundary_tear=%b",
456 bool valid_tag_found =
true;
465 for (
int id = 0;
id < tot_ids;
id++) {
468 valid_tag_found =
false;
475 if (valid_tag_found) {
480 return valid_tag_found;
490 if (edge ==
nullptr) {
491 (*r_next_vertex) =
v;
527 if (edge_x != test_edge) {
528 if (test_edge->
v1 != initial_vertex && test_edge->
v2 == initial_vertex) {
531 if (test_edge->
v2 != initial_vertex && test_edge->
v1 == initial_vertex) {
543 float (*face_grid)[3],
MDisps *mdisp,
int face_grid_size,
int orig_grid_size,
int loop)
549 const int grid_offset = orig_grid_size - 1;
550 origin[0] = grid_offset;
551 origin[1] = grid_offset;
588 for (
int y = 0;
y < orig_grid_size;
y++) {
589 for (
int x = 0;
x < orig_grid_size;
x++) {
590 const int remap_x = origin[1] + (step_x[1] *
x) + (step_y[1] *
y);
591 const int remap_y = origin[0] + (step_x[0] *
x) + (step_y[0] *
y);
593 const int final_index = remap_x + remap_y * face_grid_size;
604 float (*face_grid)[3],
609 const int grid_it = face_grid_size - 1;
610 for (
int y = 0;
y < face_grid_size;
y++) {
611 for (
int x = 0;
x < face_grid_size;
x++) {
612 const int remap_x = (grid_it * gunsub_x) +
x;
613 const int remap_y = (grid_it * gunsub_y) +
y;
615 const int remap_index_y = grid->
grid_size - remap_x - 1;
616 const int remap_index_x = grid->
grid_size - remap_y - 1;
617 const int grid_index = remap_index_x + (remap_index_y * grid->
grid_size);
636 Mesh *original_mesh = context->original_mesh;
638 const Span<int> corner_verts = original_mesh->corner_verts();
646 for (
int i = 0; i < face.
size(); i++) {
647 const int loop_index = face[i];
648 if (corner_verts[loop_index] == corner_vertex_index) {
655 const int grid_size =
CCG_grid_size(context->num_original_levels);
656 const int face_grid_size =
CCG_grid_size(context->num_original_levels + 1);
657 const int face_grid_area = face_grid_size * face_grid_size;
660 for (
int i = 0; i < face.
size(); i++) {
661 const int loop_index = face[i];
662 MDisps *mdisp = &context->original_mdisp[loop_index];
663 int quad_loop = i - loop_offset;
667 if (quad_loop >= 4) {
677 MEM_delete(face_grid);
686 const int remap_index_y = grid->
grid_size - 1 - grid_x;
687 const int remap_index_x = grid->
grid_size - 1 - grid_y;
689 const int grid_index = remap_index_x + (remap_index_y * grid->
grid_size);
713 const int grid_size =
CCG_grid_size(context->num_new_levels);
718 size_t(unsubdiv_grid_size) *
size_t(unsubdiv_grid_size),
"grids coordinates");
724 initial_vertex = initial_edge_x->
v1;
727 initial_vertex = initial_edge_x->
v2;
735 edge_temp = initial_edge_x;
736 initial_edge_x = initial_edge_y;
737 initial_edge_y = edge_temp;
740 BMVert *current_vertex_x = initial_vertex;
741 BMEdge *edge_x = initial_edge_x;
743 BMVert *current_vertex_y = initial_vertex;
744 BMEdge *edge_y = initial_edge_y;
745 BMEdge *prev_edge_y = initial_edge_y;
747 BMFace *current_face = f1;
750 const bool has_original_grid_data = context->num_original_levels > 0;
761 const int grid_iteration_max_steps = grid_size - (has_original_grid_data ? 1 : 0);
765 for (
const int grid_y :
IndexRange(grid_iteration_max_steps)) {
767 grid_face = current_face;
769 for (
const int grid_x :
IndexRange(grid_iteration_max_steps)) {
770 if (has_original_grid_data ==
false) {
773 if (current_vertex_x) {
779 edge_x =
edge_step(current_vertex_x, edge_x, ¤t_vertex_x);
784 if (current_vertex_x && grid_face) {
785 store_grid_data(context, grid, current_vertex_x, grid_face, grid_x, grid_y);
790 edge_x =
edge_step(current_vertex_x, edge_x, ¤t_vertex_x);
791 grid_face = edge_x ?
face_step(edge_x, grid_face) :
nullptr;
795 edge_y =
edge_step(current_vertex_y, edge_y, ¤t_vertex_y);
796 current_vertex_x = current_vertex_y;
810 current_face = edge_x ?
face_step(edge_x, current_face) :
nullptr;
812 prev_edge_y = edge_y;
836 if (vert_visit[v_index] == visit_id) [[unlikely]] {
839 vert_visit[v_index] = visit_id;
867 initial_vertex = initial_edge_x->
v1;
870 initial_vertex = initial_edge_x->
v2;
876 BMVert *current_vertex_x = initial_vertex;
877 BMEdge *edge_x = initial_edge_x;
879 BMVert *current_vertex_y = initial_vertex;
880 BMEdge *edge_y = initial_edge_y;
886 current_vertex_x, edge_x, vert_visit, ++(*visit_id));
887 if (corner_x ==
nullptr) [[unlikely]] {
892 current_vertex_y, edge_y, vert_visit, ++(*visit_id));
893 if (corner_y ==
nullptr) [[unlikely]] {
897 *r_corner_x = corner_x;
898 *r_corner_y = corner_y;
919static const char lname[] =
"l_remap_index";
920static const char vname[] =
"v_remap_index";
952 Mesh *original_mesh = context->original_mesh;
954 Mesh *base_mesh = context->base_mesh;
969 context->base_to_orig_vmap = *attributes.
lookup<
int>(
vname);
972 for (
int i = 0; i < base_mesh->
verts_num; i++) {
973 int vert_basemesh_index = context->base_to_orig_vmap[i];
978 context->loop_to_face_map = original_mesh->corner_to_face_map();
993 const int v_first = corner_verts[face.
start()];
994 if ((loop == (face.
start() + (face.
size() - 1))) && v_first == v_x) {
998 int next_l_index = loop + 1;
999 if (next_l_index < face.
start() + face.
size()) {
1000 const int v_next = corner_verts[next_l_index];
1001 if (v_next == v_x) {
1012 Mesh *original_mesh = context->original_mesh;
1013 Mesh *base_mesh = context->base_mesh;
1015 BMesh *bm_original_mesh = context->bm_original_mesh;
1033 context->base_to_orig_vmap = *attributes.
lookup<
int>(
vname);
1034 for (
int i = 0; i < base_mesh->
verts_num; i++) {
1035 base_to_orig_vmap[i] = context->base_to_orig_vmap[i];
1040 for (
int i = 0; i < original_mesh->
verts_num; i++) {
1041 orig_to_base_vmap[i] = -1;
1044 for (
int i = 0; i < base_mesh->
verts_num; i++) {
1045 const int orig_vertex_index = context->base_to_orig_vmap[i];
1046 orig_to_base_vmap[orig_vertex_index] = i;
1054 BMIter iter, iter_a, iter_b;
1065 const Span<int> corner_verts = base_mesh->corner_verts();
1079 BMVert *corner_x, *corner_y;
1081 l->
f,
l->
e, vert_visit, &visit_id, &corner_x, &corner_y))
1090 if (corner_x_index < 0 || corner_y_index < 0) {
1112 faces, corner_verts, base_mesh_face_index, base_mesh_loop_index, corner_x_index);
1116 if (grid->
grid_co !=
nullptr) [[unlikely]] {
1130 context,
l->
f,
l->
e, !flip_grid, grid))
1141 MEM_delete(vert_visit);
1142 MEM_delete(orig_to_base_vmap);
1143 MEM_delete(base_to_orig_vmap);
1151 if (context->bm_original_mesh !=
nullptr) {
1157 Mesh *original_mesh,
1160 context->original_mesh = original_mesh;
1161 context->num_new_levels = 0;
1162 context->num_total_levels = 0;
1163 context->num_original_levels = mmd->
totlvl;
1169 Mesh *original_mesh = context->original_mesh;
1176 context->num_new_levels = 0;
1177 int num_levels_left = context->max_new_levels;
1179 context->num_new_levels++;
1184 if (context->num_new_levels == 0) {
1191 context->num_total_levels = context->num_new_levels + context->num_original_levels;
1204 BM_mesh_bm_to_me(
nullptr, bm_base_mesh, context->base_mesh, &bm_to_me_params);
1218 for (
int i = 0; i < context->num_grids; i++) {
1219 if (context->base_mesh_grids[i].grid_size > 0) {
1220 MEM_SAFE_DELETE(context->base_mesh_grids[i].grid_co);
1223 MEM_SAFE_DELETE(context->base_mesh_grids);
1246 for (
int i = 0; i < totloop; i++) {
1249 if (mdisps[i].disps) {
1250 MEM_delete(mdisps[i].disps);
1253 for (
int j = 0; j < totdisp; j++) {
1254 if (context->base_mesh_grids[i].grid_co) {
1255 copy_v3_v3(disps[j], context->base_mesh_grids[i].grid_co[j]);
1259 mdisps[i].
disps = disps;
1268 bool switch_view_to_lower_level,
1311 Mesh *base_mesh = id_cast<Mesh *>(
object->data);
1319 if (switch_view_to_lower_level) {
1342 return rebuild_subdvis;
1351 "%d grid(s) with unexpected topology found, "
1352 "multi-res data will be incomplete",
CustomData interface, see also DNA_customdata_types.h.
Object is a sort of wrapper for general info.
Read Blender memory allocation and freeing.
#define BLI_assert_msg(a, msg)
#define BM_ELEM_CD_GET_INT(ele, offset)
#define BM_elem_index_get(ele)
#define BM_elem_flag_set(ele, hflag, val)
#define BM_elem_flag_test(ele, hflag)
#define BM_ITER_ELEM(ele, iter, data, itype)
#define BM_ITER_MESH(ele, iter, bm, itype)
#define BMALLOC_TEMPLATE_FROM_ME(...)
#define BMO_FLAG_DEFAULTS
#define BM_vert_edge_count_is_equal(v, n)
#define BM_vert_edge_count_is_over(v, n)
constexpr int64_t size() const
constexpr IndexRange()=default
constexpr int64_t start() const
GAttributeReader lookup(const StringRef name) const
bool remove(const StringRef name)
GSpanAttributeWriter lookup_or_add_for_write_only_span(StringRef name, AttrDomain domain, AttrType data_type)
void fill_index_range(MutableSpan< T > span, const T start=0)
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
void multires_reshape_assign_final_coords_from_mdisps(const MultiresReshapeContext *reshape_context)
static BMesh * get_bmesh_from_mesh(Mesh *mesh)
static bool is_vertex_pole_three(BMVert *v)
void BLI_gsqueue_push(GSQueue *queue, const void *item)
void BM_mesh_elem_hflag_enable_all(BMesh *bm, const char htype, const char hflag, const bool respecthide)
void multires_reshape_store_original_grids(MultiresReshapeContext *reshape_context)
static BMVert * unsubdivide_walk_to_tagged_vert(BMVert *v, BMEdge *edge, int *vert_visit, const int visit_id)
static void multires_unsubdivide_add_original_index_datalayers(Mesh *mesh)
static bool multires_unsubdivide_extract_single_grid_from_face_edge(MultiresUnsubdivideContext *context, BMFace *f1, BMEdge *e1, bool flip_grid, MultiresUnsubdivideGrid *grid)
bool BM_edge_in_face(const BMEdge *e, const BMFace *f)
static void store_grid_data(MultiresUnsubdivideContext *context, MultiresUnsubdivideGrid *grid, BMVert *v, BMFace *f, int grid_x, int grid_y)
static void unsubdivide_build_base_mesh_from_tags(BMesh *bm)
void BM_mesh_free(BMesh *bm)
BMesh Free Mesh.
static void multires_unsubdivide_prepare_original_bmesh_for_extract(MultiresUnsubdivideContext *context)
MINLINE void copy_v3_v3(float r[3], const float a[3])
static void unsubdivide_face_center_vertex_tag(BMesh *bm, BMVert *initial_vertex)
bool multires_unsubdivide_to_basemesh(MultiresUnsubdivideContext *context, MultiresUnsubdivideInfo &info)
bool CustomData_free_layers(CustomData *data, eCustomDataType type)
ATTR_WARN_UNUSED_RESULT const BMLoop * l
void multires_unsubdivide_context_free(MultiresUnsubdivideContext *context)
void BM_mesh_elem_table_ensure(BMesh *bm, const char htype)
bool CustomData_has_layer(const CustomData *data, eCustomDataType type)
bool BM_vert_is_wire(const BMVert *v)
void multiresModifier_unsubdivide_report_if_needed(const MultiresUnsubdivideInfo &info, ReportList *reports)
void BKE_mesh_nomain_to_mesh(Mesh *mesh_src, Mesh *mesh_dst, Object *ob, bool process_shape_keys=true)
void BM_mesh_elem_hflag_disable_all(BMesh *bm, const char htype, const char hflag, const bool respecthide)
ATTR_WARN_UNUSED_RESULT const BMVert * v
static bool unsubdivide_is_all_quads(BMesh *bm)
bool BM_vert_is_boundary(const BMVert *v)
static void multires_unsubdivide_extract_grids(MultiresUnsubdivideContext *context, MultiresUnsubdivideInfo &info)
BLI_INLINE BMVert * BM_edge_other_vert(BMEdge *e, const BMVert *v) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
static void write_loop_in_face_grid(float(*face_grid)[3], MDisps *mdisp, int face_grid_size, int orig_grid_size, int loop)
void BLI_gsqueue_pop(GSQueue *queue, void *r_item)
static const char vname[]
void BM_mesh_bm_from_me(BMesh *bm, const Mesh *mesh, const BMeshFromMeshParams *params)
Mesh -> BMesh.
void BLI_gsqueue_free(GSQueue *queue)
static bool multires_unsubdivide_get_grid_corners_on_base_mesh(BMFace *f1, BMEdge *e1, int *vert_visit, int *visit_id, BMVert **r_corner_x, BMVert **r_corner_y)
GSQueue * BLI_gsqueue_new(size_t elem_size)
static BMVert * unsubdivide_find_any_pole(BMesh *bm, int *elem_id, int elem)
static bool is_vertex_pole(BMVert *v)
int CustomData_get_offset_named(const CustomData *data, eCustomDataType type, StringRef name)
ATTR_WARN_UNUSED_RESULT const BMLoop * l_b
bool multires_reshape_context_create_from_base_mesh(MultiresReshapeContext *reshape_context, Depsgraph *depsgraph, Object *object, MultiresModifierData *mmd)
bool BM_vert_in_face(BMVert *v, BMFace *f)
static bool multires_unsubdivide_flip_grid_x_axis(const OffsetIndices< int > faces, const Span< int > corner_verts, int face_index, int loop, int v_x)
static const char lname[]
static bool multires_unsubdivide_single_level(BMesh *bm)
bool BMO_op_callf(BMesh *bm, int flag, const char *fmt,...)
static BMEdge * get_initial_edge_y(BMFace *f, BMEdge *edge_x, BMVert *initial_vertex)
void multires_force_sculpt_rebuild(Object *object)
static void write_face_grid_in_unsubdivide_grid(MultiresUnsubdivideGrid *grid, float(*face_grid)[3], int face_grid_size, int gunsub_x, int gunsub_y)
BLI_INLINE BMVert * BM_vert_at_index(BMesh *bm, const int index)
static bool unsubdivide_is_center_vertex_tag_valid(BMesh *bm, int *elem_id, int elem)
static void multires_unsubdivide_private_extract_data_free(MultiresUnsubdivideContext *context)
static void multires_create_grids_in_unsubdivided_base_mesh(MultiresUnsubdivideContext *context, Mesh *base_mesh)
BMEdge * BM_edge_exists(BMVert *v_a, BMVert *v_b)
bool BM_edge_loop_pair(BMEdge *e, BMLoop **r_la, BMLoop **r_lb)
int pow_i(int base, int exp)
bool BM_edge_share_quad_check(BMEdge *e1, BMEdge *e2)
void BKE_reportf(ReportList *reports, eReportType type, const char *format,...) ATTR_PRINTF_FORMAT(3
bool multires_reshape_context_create_from_object(MultiresReshapeContext *reshape_context, Depsgraph *depsgraph, Object *object, MultiresModifierData *mmd)
void multires_reshape_context_free(MultiresReshapeContext *reshape_context)
bool BLI_gsqueue_is_empty(const GSQueue *queue)
static bool unsubdivide_tag_disconnected_mesh_element(BMesh *bm, int *elem_id, int elem)
void multires_reshape_object_grids_to_tangent_displacement(const MultiresReshapeContext *reshape_context)
static int unsubdivide_init_elem_ids(BMesh *bm, int *elem_id)
static BMEdge * edge_step(BMVert *v, BMEdge *edge, BMVert **r_next_vertex)
static void multires_unsubdivide_free_original_datalayers(Mesh *mesh)
Mesh * BKE_mesh_new_nomain_from_template(const Mesh *me_src, int verts_num, int edges_num, int faces_num, int corners_num)
int CCG_grid_size(const int level)
void BM_mesh_bm_to_me(Main *bmain, BMesh *bm, Mesh *mesh, const BMeshToMeshParams *params)
void BM_mesh_elem_table_init(BMesh *bm, const char htype)
static void store_vertex_data(MultiresUnsubdivideGrid *grid, BMVert *v, int grid_x, int grid_y)
int multiresModifier_rebuild_subdiv(Depsgraph *depsgraph, Object *object, MultiresModifierData *mmd, int rebuild_limit, bool switch_view_to_lower_level, MultiresUnsubdivideInfo &info)
BMesh * BM_mesh_create(const BMAllocTemplate *allocsize, const BMeshCreateParams *params)
BMesh Make Mesh.
static bool is_vertex_in_id(BMVert *v, const int *elem_id, int elem)
void multires_unsubdivide_context_init(MultiresUnsubdivideContext *context, Mesh *original_mesh, MultiresModifierData *mmd)
static bool is_vertex_diagonal(BMVert *from_v, BMVert *to_v)
void * MEM_new_array_zeroed(size_t len, size_t size, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1
void * CustomData_add_layer(CustomData *data, eCustomDataType type, eCDAllocType alloctype, int totelem)
static BMFace * face_step(BMEdge *edge, BMFace *f)
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
int unsupported_grid_count
MutableVArraySpan< T > span