Commit: 2b209317073359e4b03cf069a788ee5b5eff8a7a Author: Joseph Eagar Date: Thu Sep 2 00:02:20 2021 -0700 Branches: temp_bmesh_multires https://developer.blender.org/rB2b209317073359e4b03cf069a788ee5b5eff8a7a
Merge branch 'master' into temp_bmesh_multires =================================================================== =================================================================== diff --cc source/blender/blenkernel/intern/collection.c index d7ffcab9f19,2d172f23428..d088d4a4ed2 --- a/source/blender/blenkernel/intern/collection.c +++ b/source/blender/blenkernel/intern/collection.c @@@ -689,11 -688,11 +688,14 @@@ static Collection *collection_duplicate Collection *BKE_collection_duplicate(Main *bmain, Collection *parent, Collection *collection, - const uint duplicate_flags_in, //it's not const!! - joeedh - const uint duplicate_options) - eDupli_ID_Flags duplicate_flags, - eLibIDDuplicateFlags duplicate_options) ++ const uint duplicate_flags_in, // it's not const!! - joeedh ++ const uint duplicate_options_in) // not const! { ++ uint duplicate_flags = duplicate_flags_in; ++ uint duplicate_options = duplicate_options_in; ++ const bool is_subprocess = (duplicate_options & LIB_ID_DUPLICATE_IS_SUBPROCESS) != 0; - uint duplicate_flags = duplicate_flags_in; + const bool is_root_id = (duplicate_options & LIB_ID_DUPLICATE_IS_ROOT_ID) != 0; if (!is_subprocess) { BKE_main_id_newptr_and_tag_clear(bmain); diff --cc source/blender/blenkernel/intern/dyntopo.c index 1f9c0dd290d,00000000000..65411abb552 mode 100644,000000..100644 --- a/source/blender/blenkernel/intern/dyntopo.c +++ b/source/blender/blenkernel/intern/dyntopo.c @@@ -1,4945 -1,0 +1,4939 @@@ +#include "MEM_guardedalloc.h" + +#include "DNA_customdata_types.h" +#include "DNA_mesh_types.h" +#include "DNA_meshdata_types.h" +#include "DNA_modifier_types.h" + +#include "BLI_alloca.h" +#include "BLI_array.h" +#include "BLI_bitmap.h" +#include "BLI_buffer.h" +#include "BLI_compiler_attrs.h" +#include "BLI_compiler_compat.h" +#include "BLI_ghash.h" +#include "BLI_heap.h" +#include "BLI_heap_simple.h" +#include "BLI_linklist.h" +#include "BLI_math.h" +#include "BLI_memarena.h" +#include "BLI_rand.h" +#include "BLI_task.h" +#include "BLI_utildefines.h" +#include "PIL_time.h" +#include "atomic_ops.h" + +#include "BKE_customdata.h" +#include "BKE_dyntopo.h" +#include "BKE_pbvh.h" + +#include "bmesh.h" +#include "pbvh_intern.h" + +#include <stdio.h> + +#define DYNVERT_VALENCE_TEMP (1 << 14) + +#define USE_NEW_SPLIT +#define DYNVERT_SMOOTH_BOUNDARY (DYNVERT_BOUNDARY | DYNVERT_FSET_BOUNDARY | DYNVERT_SHARP_BOUNDARY) +#define DYNVERT_ALL_BOUNDARY \ + (DYNVERT_BOUNDARY | DYNVERT_FSET_BOUNDARY | DYNVERT_SHARP_BOUNDARY | DYNVERT_SEAM_BOUNDARY) +#define DYNVERT_SMOOTH_CORNER (DYNVERT_CORNER | DYNVERT_FSET_CORNER | DYNVERT_SHARP_CORNER) +#define DYNVERT_ALL_CORNER \ + (DYNVERT_CORNER | DYNVERT_FSET_CORNER | DYNVERT_SHARP_CORNER | DYNVERT_SEAM_CORNER) + +#define DYNTOPO_MAX_ITER 4096 + +#define DYNTOPO_USE_HEAP + +#ifndef DYNTOPO_USE_HEAP +/* don't add edges into the queue multiple times */ +# define USE_EDGEQUEUE_TAG +#endif + +/* Avoid skinny faces */ +#define USE_EDGEQUEUE_EVEN_SUBDIV + +/* How much longer we need to be to consider for subdividing + * (avoids subdividing faces which are only *slightly* skinny) */ +#define EVEN_EDGELEN_THRESHOLD 1.2f +/* How much the limit increases per recursion + * (avoids performing subdivisions too far away). */ +#define EVEN_GENERATION_SCALE 1.1f + +/* recursion depth to start applying front face test */ +#define DEPTH_START_LIMIT 5 + +//#define FANCY_EDGE_WEIGHTS <= too slow +//#define SKINNY_EDGE_FIX + +/* slightly relax geometry by this factor along surface tangents + to improve convergence of remesher */ +#define DYNTOPO_SAFE_SMOOTH_FAC 0.05f + +#define DYNTOPO_SAFE_SMOOTH_SUBD_ONLY_FAC 0.75f + +#ifdef USE_EDGEQUEUE_EVEN_SUBDIV +# include "BKE_global.h" +#endif + +/* Support for only operating on front-faces */ +#define USE_EDGEQUEUE_FRONTFACE + +/** + * Ensure we don't have dirty tags for the edge queue, and that they are left cleared. + * (slow, even for debug mode, so leave disabled for now). + */ +#if defined(USE_EDGEQUEUE_TAG) && 0 +# if !defined(NDEBUG) +# define USE_EDGEQUEUE_TAG_VERIFY +# endif +#endif + +// #define USE_VERIFY + +#define DYNTOPO_MASK(cd_mask_offset, v) BM_ELEM_CD_GET_FLOAT(v, cd_mask_offset) + +#ifdef USE_VERIFY +static void pbvh_bmesh_verify(PBVH *pbvh); +#endif + +/* -------------------------------------------------------------------- */ +/** \name BMesh Utility API + * + * Use some local functions which assume triangles. + * \{ */ + +/** + * Typically using BM_LOOPS_OF_VERT and BM_FACES_OF_VERT iterators are fine, + * however this is an area where performance matters so do it in-line. + * + * Take care since 'break' won't works as expected within these macros! + */ + +#define BM_DISK_EDGE(e, v) (&((&(e)->v1_disk_link)[(v) == (e)->v2])) + +#define BM_LOOPS_OF_VERT_ITER_BEGIN(l_iter_radial_, v_) \ + { \ + struct { \ + BMVert *v; \ + BMEdge *e_iter, *e_first; \ + BMLoop *l_iter_radial; \ + } _iter; \ + _iter.v = v_; \ + if (_iter.v->e) { \ + _iter.e_iter = _iter.e_first = _iter.v->e; \ + do { \ + if (_iter.e_iter->l) { \ + _iter.l_iter_radial = _iter.e_iter->l; \ + do { \ + if (_iter.l_iter_radial->v == _iter.v) { \ + l_iter_radial_ = _iter.l_iter_radial; + +#define BM_LOOPS_OF_VERT_ITER_END \ + } \ + } \ + while ((_iter.l_iter_radial = _iter.l_iter_radial->radial_next) != _iter.e_iter->l) \ + ; \ + } \ + } \ + while ((_iter.e_iter = BM_DISK_EDGE_NEXT(_iter.e_iter, _iter.v)) != _iter.e_first) \ + ; \ + } \ + } \ + ((void)0) + +#define BM_FACES_OF_VERT_ITER_BEGIN(f_iter_, v_) \ + { \ + BMLoop *l_iter_radial_; \ + BM_LOOPS_OF_VERT_ITER_BEGIN (l_iter_radial_, v_) { \ + f_iter_ = l_iter_radial_->f; + +#define BM_FACES_OF_VERT_ITER_END \ + } \ + BM_LOOPS_OF_VERT_ITER_END; \ + } \ + ((void)0) + +struct EdgeQueueContext; + +static bool check_face_is_tri(PBVH *pbvh, BMFace *f); +static bool check_vert_fan_are_tris(PBVH *pbvh, BMVert *v); +static void pbvh_split_edges(struct EdgeQueueContext *eq_ctx, + PBVH *pbvh, + BMesh *bm, + BMEdge **edges, + int totedge, + bool ignore_isolated_edges); +void bm_log_message(const char *fmt, ...); +void pbvh_bmesh_check_nodes_simple(PBVH *pbvh); +static void edge_queue_create_local(struct EdgeQueueContext *eq_ctx, + PBVH *pbvh, + const float center[3], + const float view_normal[3], + float radius, + const bool use_frontface, + const bool use_projected, + bool is_collapse); + +//#define CHECKMESH +//#define TEST_INVALID_NORMALS + +#ifndef CHECKMESH +# define fix_mesh(bm) +# define validate_vert(bm, v, autofix, check_manifold) true +# define validate_edge(bm, e, autofix, check_manifold) true +# define validate_face(bm, f, autofix, check_manifold) true +# define validate_vert_faces(bm, v, autofix, check_manifold) true +# define check_face_is_manifold(bm, f) true +#else + +# define CHECKMESH_ATTR ATTR_NO_OPT + +CHECKMESH_ATTR static void _debugprint(const char *fmt, ...) +{ + va_list args; + va_start(args, fmt); + vprintf(fmt, args); + va_end(args); +} + +void bmesh_disk_edge_append(BMEdge *e, BMVert *v); +void bmesh_radial_loop_append(BMEdge *e, BMLoop *l); + +CHECKMESH_ATTR static bool check_face_is_manifold(BMesh *bm, BMFace *f) +{ + BMLoop *l = f->l_first; + + do { + if (l->radial_next != l && l->radial_next->radial_next != l) { + _debugprint("non-manifold edge in loop\n"); + return false; + } + +# ifdef TEST_INVALID_NORMALS + if (l != l->radial_next && l->v == l->radial_next->v) { + _debugprint("invalid normals\n"); + return false; + } +# endif + } while ((l = l->next) != f->l_first); + + return true; +} + +CHECKMESH_ATTR +static void fix_mesh(BMesh *bm) +{ + BMIter iter; + BMVert *v; + BMEdge *e; + BMFace *f; + + _debugprint("fixing mesh. . .\n"); + + BM_ITER_MESH (v, &iter, bm, BM_VERTS_OF_MESH) { + v->e = NULL; + } + + BM_ITER_MESH (e, &iter, bm, BM_EDGES_OF_MESH) { + e->v1_disk_link.next = e->v1_disk_link.prev = NULL; + e->v2_disk_link.next = e->v2_disk_link.prev = NULL; + } + + // rebuild disk cycles + BM_ITER_MESH (e, &iter, bm, BM_EDGES_OF_MESH) { + e->l = NULL; + + bmesh_disk_edge_append(e, e->v1); + bmesh_disk_edge_append(e, e->v2); + } + + BM_ITER_MESH (f, &iter, bm, BM_FACES_OF_MESH) { + BMLoop *l = f->l_first; + + do { + l->e = BM_edge_exists(l->v, l->next->v); + + bmesh_radial_loop_append(l->e, l); + } while ((l = l->next) != f->l_first); + } + _debugprint("done fixing mesh.\n"); +} + +CHECKMESH_ATTR +static bool validate_vert(BMesh *bm, BMVert *v, bool autofix, bool check_manifold) +{ + if (v->head.htype != BM_VERT) { + _debugprint("bad vertex\n"); + return false; + } + + BMEdge *e = v->e; + int i = 0; + + if (!e) { + return true; + } + + do { + if (e->v1 != v && e->v2 != v) { + _debugprint("edge does not contain v\n"); + goto error; + } + + if (e->l) { + int j = 0; + + BMLoop *l = e->l; + do { + if (l->e->v1 != v && l->e->v2 != v) { + _debugprint("loop's edges doesn't contain v\n"); + goto error; + } + + if (l->v != v && l->next->v != v) { + _debugprint("loop and loop->next don't contain v\n"); + goto error; + } + + j++; + if (j > 1000) { + _debugprint("corrupted radial cycle\n"); + goto error; + } + + if @@ Diff output truncated at 10240 characters. @@ _______________________________________________ Bf-blender-cvs mailing list Bf-blender-cvs@blender.org List details, subscription details or unsubscribe: https://lists.blender.org/mailman/listinfo/bf-blender-cvs