blender
/
blender
136
404
Fork 586
Code Issues 6.2k Pull Requests 752 Projects 19 Wiki Activity

Sculpt: fix nasty radius symmetry bug 

* Brush radius wasn't being calculated correctly if symmetry was on.
* Unnessed SCULPT_run_commandlist, it now calls
  do_symmetrical_brush_actions instead of the reverse.
* Renamed MDynTopoVert to MSculptVert.  Old name didn't
  make sense given that all three PBVH types now use it.
  Mercifully it's never saved in files, and even if it
  somehow was saved the CD file loading code checks for
  that.
This commit is contained in:
Joseph Eagar 2021-10-06 13:35:22 -07:00
parent 88efbf7d1e
commit 313c6811c3
20 changed files with 1020 additions and 970 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
source/blender/blenkernel/BKE_paint.h
View File

@ -37,7 +37,7 @@ extern "C" {
#endif
struct SculptCustomLayer;
struct MDynTopoVert;
struct MSculptVert;
struct BMFace;
struct BMesh;
struct BlendDataReader;
@ -628,7 +628,7 @@ typedef struct SculptSession {
/* BMesh for dynamic topology sculpting */
struct BMesh *bm;
int cd_dyn_vert;
int cd_sculpt_vert;
int cd_vert_node_offset;
int cd_face_node_offset;
int cd_vcol_offset;
@ -771,7 +771,7 @@ typedef struct SculptSession {
int stroke_id, boundary_symmetry;
bool fast_draw; // hides facesets/masks and forces smooth to save GPU bandwidth
struct MDynTopoVert *mdyntopo_verts; // for non-bmesh
struct MSculptVert *mdyntopo_verts; // for non-bmesh
int mdyntopo_verts_size;
/*list of up to date custom layer references,

24
source/blender/blenkernel/BKE_pbvh.h
View File

@ -130,7 +130,7 @@ struct GPU_PBVH_Buffers;
struct IsectRayPrecalc;
struct MLoop;
struct MLoopTri;
struct MDynTopoVert;
struct MSculptVert;
struct MPoly;
struct MVert;
struct Mesh;
@ -283,7 +283,7 @@ void BKE_pbvh_build_mesh(PBVH *pbvh,
const struct MPoly *mpoly,
const struct MLoop *mloop,
struct MVert *verts,
struct MDynTopoVert *mdyntopo_verts,
struct MSculptVert *mdyntopo_verts,
int totvert,
struct CustomData *vdata,
struct CustomData *ldata,
@ -305,13 +305,13 @@ void BKE_pbvh_build_bmesh(PBVH *pbvh,
struct BMLog *log,
const int cd_vert_node_offset,
const int cd_face_node_offset,
const int cd_dyn_vert,
const int cd_sculpt_vert,
const int cd_face_areas,
bool fast_draw);
void BKE_pbvh_update_offsets(PBVH *pbvh,
const int cd_vert_node_offset,
const int cd_face_node_offset,
const int cd_dyn_vert,
const int cd_sculpt_vert,
const int cd_face_areas);
void BKE_pbvh_free(PBVH *pbvh);
@ -500,7 +500,7 @@ void BKE_pbvh_check_tri_areas(PBVH *pbvh, PBVHNode *node);
// updates boundaries and valences for whole mesh
void BKE_pbvh_bmesh_on_mesh_change(PBVH *pbvh);
bool BKE_pbvh_bmesh_check_valence(PBVH *pbvh, SculptVertRef vertex);
void BKE_pbvh_bmesh_update_valence(int cd_dyn_vert, SculptVertRef vertex);
void BKE_pbvh_bmesh_update_valence(int cd_sculpt_vert, SculptVertRef vertex);
void BKE_pbvh_bmesh_update_all_valence(PBVH *pbvh);
void BKE_pbvh_bmesh_flag_all_disk_sort(PBVH *pbvh);
bool BKE_pbvh_bmesh_mark_update_valence(PBVH *pbvh, SculptVertRef vertex);
@ -626,7 +626,7 @@ typedef struct PBVHVertexIter {
struct TableGSet *bm_unique_verts, *bm_other_verts;
struct CustomData *bm_vdata;
int cd_dyn_vert;
int cd_sculpt_vert;
int cd_vert_mask_offset;
int cd_vcol_offset;
@ -642,7 +642,7 @@ typedef struct PBVHVertexIter {
bool visible;
} PBVHVertexIter;
#define BKE_PBVH_DYNVERT(cd_dyn_vert, v) ((MDynTopoVert *)BM_ELEM_CD_GET_VOID_P(v, cd_dyn_vert))
#define BKE_PBVH_SCULPTVERT(cd_sculpt_vert, v) ((MSculptVert *)BM_ELEM_CD_GET_VOID_P(v, cd_sculpt_vert))
void pbvh_vertex_iter_init(PBVH *pbvh, PBVHNode *node, PBVHVertexIter *vi, int mode);
@ -833,7 +833,7 @@ PBVHNode *BKE_pbvh_node_from_face_bmesh(PBVH *pbvh, struct BMFace *f);
PBVHNode *BKE_pbvh_node_from_index(PBVH *pbvh, int node_i);
struct BMesh *BKE_pbvh_reorder_bmesh(PBVH *pbvh);
void BKE_pbvh_update_vert_boundary(int cd_dyn_vert,
void BKE_pbvh_update_vert_boundary(int cd_sculpt_vert,
int cd_faceset_offset,
int cd_vert_node_offset,
int cd_face_node_offset,
@ -947,20 +947,20 @@ void BKE_pbvh_update_vert_boundary_faces(int *face_sets,
struct MEdge *medge,
struct MLoop *mloop,
struct MPoly *mpoly,
struct MDynTopoVert *mdyntopo_verts,
struct MSculptVert *mdyntopo_verts,
struct MeshElemMap *pmap,
SculptVertRef vertex);
void BKE_pbvh_update_vert_boundary_grids(PBVH *pbvh,
struct SubdivCCG *subdiv_ccg,
SculptVertRef vertex);
void BKE_pbvh_set_mdyntopo_verts(PBVH *pbvh, struct MDynTopoVert *mdyntopoverts);
void BKE_pbvh_set_mdyntopo_verts(PBVH *pbvh, struct MSculptVert *mdyntopoverts);
#if 0
# include "DNA_meshdata_types.h"
ATTR_NO_OPT static void MV_ADD_FLAG(MDynTopoVert *mv, int flag)
ATTR_NO_OPT static void MV_ADD_FLAG(MSculptVert *mv, int flag)
{
if (flag & DYNVERT_NEED_BOUNDARY) {
if (flag & SCULPTVERT_NEED_BOUNDARY) {
flag |= flag;
}

10
source/blender/blenkernel/intern/customdata.c
View File

@ -1504,14 +1504,14 @@ static bool layerValidate_propfloat2(void *data, const uint totitems, const bool
static void layerDynTopoVert_copy(const void *source, void *dest, int count)
{
memcpy(dest, source, count * sizeof(MDynTopoVert));
memcpy(dest, source, count * sizeof(MSculptVert));
}
static void layerDynTopoVert_interp(
const void **sources, const float *weights, const float *sub_weights, int count, void *dest)
{
float co[3], no[3], origmask, color[4];
MDynTopoVert *mv = (MDynTopoVert *)dest;
MSculptVert *mv = (MSculptVert *)dest;
// float totweight = 0.0f;
if (count == 0) {
@ -1525,7 +1525,7 @@ static void layerDynTopoVert_interp(
zero_v4(color);
for (int i = 0; i < count; i++) {
MDynTopoVert *mv2 = (MDynTopoVert *)sources[i];
MSculptVert *mv2 = (MSculptVert *)sources[i];
float w;
if (i == 0) { // copy flag from first source
@ -1977,8 +1977,8 @@ static const LayerTypeInfo LAYERTYPEINFO[CD_NUMTYPES] = {
NULL,
layerDefault_mesh_id},
/* 53 CD_DYNTOPO_VERT */
{sizeof(MDynTopoVert),
"MDynTopoVert",
{sizeof(MSculptVert),
"MSculptVert",
1,
NULL, // flag singleton layer
layerDynTopoVert_copy,

337
source/blender/blenkernel/intern/dyntopo.c
View File

@ -36,15 +36,18 @@
//#define DYNTOPO_REPORT
#define DYNVERT_VALENCE_TEMP DYNVERT_SPLIT_TEMP
#define SCULPTVERT_VALENCE_TEMP SCULPTVERT_SPLIT_TEMP
#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 SCULPTVERT_SMOOTH_BOUNDARY \
(SCULPTVERT_BOUNDARY | SCULPTVERT_FSET_BOUNDARY | SCULPTVERT_SHARP_BOUNDARY)
#define SCULPTVERT_ALL_BOUNDARY \
(SCULPTVERT_BOUNDARY | SCULPTVERT_FSET_BOUNDARY | SCULPTVERT_SHARP_BOUNDARY | \
SCULPTVERT_SEAM_BOUNDARY)
#define SCULPTVERT_SMOOTH_CORNER \
(SCULPTVERT_CORNER | SCULPTVERT_FSET_CORNER | SCULPTVERT_SHARP_CORNER)
#define SCULPTVERT_ALL_CORNER \
(SCULPTVERT_CORNER | SCULPTVERT_FSET_CORNER | SCULPTVERT_SHARP_CORNER | SCULPTVERT_SEAM_CORNER)
#define DYNTOPO_MAX_ITER 4096
@ -198,11 +201,11 @@ static void fix_mesh(PBVH *pbvh, BMesh *bm)
BM_ITER_MESH (v, &iter, bm, BM_VERTS_OF_MESH) {
v->e = NULL;
MDynTopoVert *mv = BKE_PBVH_DYNVERT(pbvh->cd_dyn_vert, v);
MSculptVert *mv = BKE_PBVH_SCULPTVERT(pbvh->cd_sculpt_vert, v);
MV_ADD_FLAG(mv,
DYNVERT_NEED_VALENCE | DYNVERT_NEED_BOUNDARY | DYNVERT_NEED_DISK_SORT |
DYNVERT_NEED_TRIANGULATE);
SCULPTVERT_NEED_VALENCE | SCULPTVERT_NEED_BOUNDARY | SCULPTVERT_NEED_DISK_SORT |
SCULPTVERT_NEED_TRIANGULATE);
}
BM_ITER_MESH (e, &iter, bm, BM_EDGES_OF_MESH) {
@ -567,7 +570,7 @@ BLI_INLINE void surface_smooth_v_safe(PBVH *pbvh, BMVert *v, float fac)
float tan[3];
float tot = 0.0;
MDynTopoVert *mv1 = BKE_PBVH_DYNVERT(pbvh->cd_dyn_vert, v);
MSculptVert *mv1 = BKE_PBVH_SCULPTVERT(pbvh->cd_sculpt_vert, v);
if (mv1->stroke_id != pbvh->stroke_id) {
copy_v3_v3(origco1, v->co);
@ -590,17 +593,17 @@ BLI_INLINE void surface_smooth_v_safe(PBVH *pbvh, BMVert *v, float fac)
return;
}
if (mv1->flag & DYNVERT_NEED_BOUNDARY) {
if (mv1->flag & SCULPTVERT_NEED_BOUNDARY) {
return; // can't update boundary in thread
}
// pbvh_check_vert_boundary(pbvh, v);
const int cd_dyn_vert = pbvh->cd_dyn_vert;
const int cd_sculpt_vert = pbvh->cd_sculpt_vert;
const bool bound1 = mv1->flag & DYNVERT_SMOOTH_BOUNDARY;
const bool bound1 = mv1->flag & SCULPTVERT_SMOOTH_BOUNDARY;
if (mv1->flag & DYNVERT_SMOOTH_CORNER) {
if (mv1->flag & SCULPTVERT_SMOOTH_CORNER) {
return;
}
@ -610,8 +613,8 @@ BLI_INLINE void surface_smooth_v_safe(PBVH *pbvh, BMVert *v, float fac)
// can't check for boundary here, thread
pbvh_check_vert_boundary(pbvh, v2);
MDynTopoVert *mv2 = BKE_PBVH_DYNVERT(cd_dyn_vert, v2);
const bool bound2 = mv2->flag & DYNVERT_SMOOTH_BOUNDARY;
MSculptVert *mv2 = BKE_PBVH_SCULPTVERT(cd_sculpt_vert, v2);
const bool bound2 = mv2->flag & SCULPTVERT_SMOOTH_BOUNDARY;
if (bound1 && !bound2) {
continue;
@ -803,9 +806,9 @@ static BMVert *pbvh_bmesh_vert_create(PBVH *pbvh,
/* avoid initializing customdata because its quite involved */
BMVert *v = BM_vert_create(pbvh->bm, co, NULL, BM_CREATE_NOP);
MDynTopoVert *mv = BKE_PBVH_DYNVERT(pbvh->cd_dyn_vert, v);
MSculptVert *mv = BKE_PBVH_SCULPTVERT(pbvh->cd_sculpt_vert, v);
MV_ADD_FLAG(mv, DYNVERT_NEED_BOUNDARY | DYNVERT_NEED_DISK_SORT | DYNVERT_NEED_VALENCE);
MV_ADD_FLAG(mv, SCULPTVERT_NEED_BOUNDARY | SCULPTVERT_NEED_DISK_SORT | SCULPTVERT_NEED_VALENCE);
if (v_example) {
v->head.hflag = v_example->head.hflag;
@ -816,10 +819,10 @@ static BMVert *pbvh_bmesh_vert_create(PBVH *pbvh,
/* This value is logged below */
copy_v3_v3(v->no, no);
// keep MDynTopoVert copied from v_example as-is
// keep MSculptVert copied from v_example as-is
}
else {
MDynTopoVert *mv = BKE_PBVH_DYNVERT(pbvh->cd_dyn_vert, v);
MSculptVert *mv = BKE_PBVH_SCULPTVERT(pbvh->cd_sculpt_vert, v);
copy_v3_v3(mv->origco, co);
copy_v3_v3(mv->origno, no);
@ -925,8 +928,9 @@ static BMFace *pbvh_bmesh_face_create(PBVH *pbvh,
PBVH_UpdateOtherVerts;
}
MDynTopoVert *mv = BKE_PBVH_DYNVERT(pbvh->cd_dyn_vert, l->v);
MV_ADD_FLAG(mv, DYNVERT_NEED_DISK_SORT | DYNVERT_NEED_BOUNDARY | DYNVERT_NEED_VALENCE);
MSculptVert *mv = BKE_PBVH_SCULPTVERT(pbvh->cd_sculpt_vert, l->v);
MV_ADD_FLAG(mv,
SCULPTVERT_NEED_DISK_SORT | SCULPTVERT_NEED_BOUNDARY | SCULPTVERT_NEED_VALENCE);
l = l->next;
} while (l != f->l_first);
@ -935,8 +939,9 @@ static BMFace *pbvh_bmesh_face_create(PBVH *pbvh,
BMLoop *l = f->l_first;
do {
MDynTopoVert *mv = BKE_PBVH_DYNVERT(pbvh->cd_dyn_vert, l->v);
MV_ADD_FLAG(mv, DYNVERT_NEED_DISK_SORT | DYNVERT_NEED_BOUNDARY | DYNVERT_NEED_VALENCE);
MSculptVert *mv = BKE_PBVH_SCULPTVERT(pbvh->cd_sculpt_vert, l->v);
MV_ADD_FLAG(mv,
SCULPTVERT_NEED_DISK_SORT | SCULPTVERT_NEED_BOUNDARY | SCULPTVERT_NEED_VALENCE);
} while ((l = l->next) != f->l_first);
}
@ -978,8 +983,9 @@ BMVert *BKE_pbvh_vert_create_bmesh(
v = BM_vert_create(pbvh->bm, co, v_example, BM_CREATE_NOP);
BM_ELEM_CD_SET_INT(v, pbvh->cd_vert_node_offset, DYNTOPO_NODE_NONE);
MDynTopoVert *mv = BM_ELEM_CD_GET_VOID_P(v, pbvh->cd_dyn_vert);
MV_ADD_FLAG(mv, DYNVERT_NEED_VALENCE | DYNVERT_NEED_DISK_SORT | DYNVERT_NEED_BOUNDARY);
MSculptVert *mv = BM_ELEM_CD_GET_VOID_P(v, pbvh->cd_sculpt_vert);
MV_ADD_FLAG(mv,
SCULPTVERT_NEED_VALENCE | SCULPTVERT_NEED_DISK_SORT | SCULPTVERT_NEED_BOUNDARY);
copy_v3_v3(mv->origco, co);
@ -1372,7 +1378,7 @@ typedef struct EdgeQueueContext {
BMesh *bm;
DyntopoMaskCB mask_cb;
void *mask_cb_data;
int cd_dyn_vert;
int cd_sculpt_vert;
int cd_vert_mask_offset;
int cd_vert_node_offset;
int cd_face_node_offset;
@ -1389,14 +1395,14 @@ typedef struct EdgeQueueContext {
static void edge_queue_insert_val34_vert(EdgeQueueContext *eq_ctx, BMVert *v)
{
MDynTopoVert *mv = BKE_PBVH_DYNVERT(eq_ctx->cd_dyn_vert, v);
MSculptVert *mv = BKE_PBVH_SCULPTVERT(eq_ctx->cd_sculpt_vert, v);
// prevent double adding
if (mv->flag & DYNVERT_VALENCE_TEMP) {
if (mv->flag & SCULPTVERT_VALENCE_TEMP) {
return;
}
mv->flag |= DYNVERT_VALENCE_TEMP;
mv->flag |= SCULPTVERT_VALENCE_TEMP;
eq_ctx->val34_verts_tot++;
@ -1436,8 +1442,8 @@ BLI_INLINE float calc_weighted_edge_split(EdgeQueueContext *eq_ctx, BMVert *v1,
#ifdef FANCY_EDGE_WEIGHTS
float l = len_squared_v3v3(v1->co, v2->co);
// float val = (float)BM_vert_edge_count(v1) + (float)BM_vert_edge_count(v2);
MDynTopoVert *mv1 = BKE_PBVH_DYNVERT(eq_ctx->cd_dyn_vert, v1);
MDynTopoVert *mv2 = BKE_PBVH_DYNVERT(eq_ctx->cd_dyn_vert, v2);
MSculptVert *mv1 = BKE_PBVH_SCULPTVERT(eq_ctx->cd_sculpt_vert, v1);
MSculptVert *mv2 = BKE_PBVH_SCULPTVERT(eq_ctx->cd_sculpt_vert, v2);
float val = (float)(mv1->valence + mv2->valence) * 0.5f;
val -= 6.0f;
@ -1464,8 +1470,8 @@ BLI_INLINE float calc_weighted_edge_collapse(EdgeQueueContext *eq_ctx, BMVert *v
#ifdef FANCY_EDGE_WEIGHTS
float l = len_squared_v3v3(v1->co, v2->co);
// float val = (float)BM_vert_edge_count(v1) + (float)BM_vert_edge_count(v2);
MDynTopoVert *mv1 = BKE_PBVH_DYNVERT(eq_ctx->cd_dyn_vert, v1);
MDynTopoVert *mv2 = BKE_PBVH_DYNVERT(eq_ctx->cd_dyn_vert, v2);
MSculptVert *mv1 = BKE_PBVH_SCULPTVERT(eq_ctx->cd_sculpt_vert, v1);
MSculptVert *mv2 = BKE_PBVH_SCULPTVERT(eq_ctx->cd_sculpt_vert, v2);
float val = (float)(mv1->valence + mv2->valence) * 0.5f;
val -= 6.0f;
@ -2000,7 +2006,7 @@ static void long_edge_queue_task_cb(void *__restrict userdata,
BMFace *f, **faces = NULL;
BLI_array_declare(faces);
const int cd_dyn_vert = tdata->pbvh->cd_dyn_vert;
const int cd_sculpt_vert = tdata->pbvh->cd_sculpt_vert;
bool do_smooth = eq_ctx->surface_smooth_fac > 0.0f;
#if 1
@ -2049,7 +2055,7 @@ static void long_edge_queue_task_cb(void *__restrict userdata,
BMLoop *l_first = BM_FACE_FIRST_LOOP(f);
BMLoop *l_iter = l_first;
do {
MDynTopoVert *mv = BKE_PBVH_DYNVERT(eq_ctx->cd_dyn_vert, l_iter->v);
MSculptVert *mv = BKE_PBVH_SCULPTVERT(eq_ctx->cd_sculpt_vert, l_iter->v);
/*
If valence is not up to date, just add it to the list;
@ -2057,7 +2063,7 @@ static void long_edge_queue_task_cb(void *__restrict userdata,
Can't update valence in a thread after all.
*/
if (mv->valence < 5 || (mv->flag & DYNVERT_NEED_VALENCE)) {
if (mv->valence < 5 || (mv->flag & SCULPTVERT_NEED_VALENCE)) {
BLI_array_append(val34, l_iter->v);
}
@ -2456,7 +2462,8 @@ static bool destroy_nonmanifold_fins(PBVH *pbvh, BMEdge *e_root)
BM_face_kill(pbvh->bm, f);
}
const int mupdateflag = DYNVERT_NEED_BOUNDARY | DYNVERT_NEED_DISK_SORT | DYNVERT_NEED_VALENCE;
const int mupdateflag = SCULPTVERT_NEED_BOUNDARY | SCULPTVERT_NEED_DISK_SORT |
SCULPTVERT_NEED_VALENCE;
for (int i = 0; i < BLI_array_len(es); i++) {
BMEdge *e = es[i];
@ -2477,7 +2484,7 @@ static bool destroy_nonmanifold_fins(PBVH *pbvh, BMEdge *e_root)
BM_vert_kill(pbvh->bm, v);
}
else {
MDynTopoVert *mv = BKE_PBVH_DYNVERT(pbvh->cd_dyn_vert, v);
MSculptVert *mv = BKE_PBVH_SCULPTVERT(pbvh->cd_sculpt_vert, v);
mv->flag |= mupdateflag;
}
}
@ -2518,9 +2525,9 @@ static bool check_for_fins(PBVH *pbvh, BMVert *v)
static bool check_vert_fan_are_tris(PBVH *pbvh, BMVert *v)
{
MDynTopoVert *mv = BKE_PBVH_DYNVERT(pbvh->cd_dyn_vert, v);
MSculptVert *mv = BKE_PBVH_SCULPTVERT(pbvh->cd_sculpt_vert, v);
if (!(mv->flag & DYNVERT_NEED_TRIANGULATE)) {
if (!(mv->flag & SCULPTVERT_NEED_TRIANGULATE)) {
return true;
}
@ -2542,14 +2549,15 @@ static bool check_vert_fan_are_tris(PBVH *pbvh, BMVert *v)
BMLoop *l = f->l_first;
do {
MDynTopoVert *mv_l = BKE_PBVH_DYNVERT(pbvh->cd_dyn_vert, l->v);
MSculptVert *mv_l = BKE_PBVH_SCULPTVERT(pbvh->cd_sculpt_vert, l->v);
MV_ADD_FLAG(mv_l, DYNVERT_NEED_BOUNDARY | DYNVERT_NEED_VALENCE | DYNVERT_NEED_DISK_SORT);
MV_ADD_FLAG(mv_l,
SCULPTVERT_NEED_BOUNDARY | SCULPTVERT_NEED_VALENCE | SCULPTVERT_NEED_DISK_SORT);
} while ((l = l->next) != f->l_first);
BLI_array_append(fs, f);
}
mv->flag &= ~DYNVERT_NEED_TRIANGULATE;
mv->flag &= ~SCULPTVERT_NEED_TRIANGULATE;
for (int i = 0; i < BLI_array_len(fs); i++) {
check_face_is_tri(pbvh, fs[i]);
@ -2676,21 +2684,21 @@ static void long_edge_queue_create(EdgeQueueContext *eq_ctx,
BLI_parallel_range_settings_defaults(&settings);
BLI_task_parallel_range(0, count, tdata, long_edge_queue_task_cb, &settings);
const int cd_dyn_vert = pbvh->cd_dyn_vert;
const int cd_sculpt_vert = pbvh->cd_sculpt_vert;
for (int i = 0; i < count; i++) {
EdgeQueueThreadData *td = tdata + i;
for (int j = 0; j < td->val34_verts_tot; j++) {
BMVert *v = td->val34_verts[j];
MDynTopoVert *mv = BKE_PBVH_DYNVERT(cd_dyn_vert, v);
MSculptVert *mv = BKE_PBVH_SCULPTVERT(cd_sculpt_vert, v);
if (bm_elem_is_free((BMElem *)v, BM_VERT)) {
continue;
}
if (mv->flag & DYNVERT_NEED_VALENCE) {
BKE_pbvh_bmesh_update_valence(pbvh->cd_dyn_vert, (SculptVertRef){.i = (intptr_t)v});
if (mv->flag & SCULPTVERT_NEED_VALENCE) {
BKE_pbvh_bmesh_update_valence(pbvh->cd_sculpt_vert, (SculptVertRef){.i = (intptr_t)v});
}
}
@ -2709,14 +2717,14 @@ static void long_edge_queue_create(EdgeQueueContext *eq_ctx,
destroy_nonmanifold_fins(pbvh, e);
}
MDynTopoVert *mv1 = BKE_PBVH_DYNVERT(cd_dyn_vert, e->v1);
MDynTopoVert *mv2 = BKE_PBVH_DYNVERT(cd_dyn_vert, e->v2);
MSculptVert *mv1 = BKE_PBVH_SCULPTVERT(cd_sculpt_vert, e->v1);
MSculptVert *mv2 = BKE_PBVH_SCULPTVERT(cd_sculpt_vert, e->v2);
if (mv1->flag & DYNVERT_NEED_VALENCE) {
BKE_pbvh_bmesh_update_valence(pbvh->cd_dyn_vert, (SculptVertRef){.i = (intptr_t)e->v1});
if (mv1->flag & SCULPTVERT_NEED_VALENCE) {
BKE_pbvh_bmesh_update_valence(pbvh->cd_sculpt_vert, (SculptVertRef){.i = (intptr_t)e->v1});
}
if (mv2->flag & DYNVERT_NEED_VALENCE) {
BKE_pbvh_bmesh_update_valence(pbvh->cd_dyn_vert, (SculptVertRef){.i = (intptr_t)e->v2});
if (mv2->flag & SCULPTVERT_NEED_VALENCE) {
BKE_pbvh_bmesh_update_valence(pbvh->cd_sculpt_vert, (SculptVertRef){.i = (intptr_t)e->v2});
}
check_vert_fan_are_tris(pbvh, e->v1);
@ -2791,7 +2799,7 @@ static void edge_queue_create_local(EdgeQueueContext *eq_ctx,
BLI_parallel_range_settings_defaults(&settings);
BLI_task_parallel_range(0, count, tdata, short_edge_queue_task_cb_local, &settings);
const int cd_dyn_vert = pbvh->cd_dyn_vert;
const int cd_sculpt_vert = pbvh->cd_sculpt_vert;
BMEdge **edges = NULL;
float *lens = NULL;
BLI_array_declare(edges);
@ -2839,10 +2847,10 @@ static void edge_queue_create_local(EdgeQueueContext *eq_ctx,
if (!is_collapse) {
if (!(v->head.hflag & BM_ELEM_TAG)) {
v->head.hflag |= BM_ELEM_TAG;
MDynTopoVert *mv = BKE_PBVH_DYNVERT(pbvh->cd_dyn_vert, v);
MSculptVert *mv = BKE_PBVH_SCULPTVERT(pbvh->cd_sculpt_vert, v);
if (mv->flag & DYNVERT_NEED_VALENCE) {
BKE_pbvh_bmesh_update_valence(pbvh->cd_dyn_vert, (SculptVertRef){.i = (intptr_t)v});
if (mv->flag & SCULPTVERT_NEED_VALENCE) {
BKE_pbvh_bmesh_update_valence(pbvh->cd_sculpt_vert, (SculptVertRef){.i = (intptr_t)v});
}
}
}
@ -2912,21 +2920,21 @@ static void edge_queue_create_local(EdgeQueueContext *eq_ctx,
for (int i = 0; i < BLI_array_len(edges); i++) {
BMEdge *e = edges[i];
MDynTopoVert *mv1, *mv2;
MSculptVert *mv1, *mv2;
e->head.hflag &= ~BM_ELEM_TAG;
mv1 = BKE_PBVH_DYNVERT(cd_dyn_vert, e->v1);
mv2 = BKE_PBVH_DYNVERT(cd_dyn_vert, e->v2);
mv1 = BKE_PBVH_SCULPTVERT(cd_sculpt_vert, e->v1);
mv2 = BKE_PBVH_SCULPTVERT(cd_sculpt_vert, e->v2);
pbvh_check_vert_boundary(pbvh, e->v1);
pbvh_check_vert_boundary(pbvh, e->v2);
if ((mv1->flag & DYNVERT_ALL_CORNER) || (mv2->flag & DYNVERT_ALL_CORNER)) {
if ((mv1->flag & SCULPTVERT_ALL_CORNER) || (mv2->flag & SCULPTVERT_ALL_CORNER)) {
continue;
}
if ((mv1->flag & DYNVERT_ALL_BOUNDARY) != (mv2->flag & DYNVERT_ALL_BOUNDARY)) {
if ((mv1->flag & SCULPTVERT_ALL_BOUNDARY) != (mv2->flag & SCULPTVERT_ALL_BOUNDARY)) {
continue;
}
@ -3068,7 +3076,7 @@ static void short_edge_queue_create(EdgeQueueContext *eq_ctx,
BLI_parallel_range_settings_defaults(&settings);
BLI_task_parallel_range(0, count, tdata, short_edge_queue_task_cb, &settings);
const int cd_dyn_vert = pbvh->cd_dyn_vert;
const int cd_sculpt_vert = pbvh->cd_sculpt_vert;
for (int i = 0; i < count; i++) {
EdgeQueueThreadData *td = tdata + i;
@ -3076,19 +3084,19 @@ static void short_edge_queue_create(EdgeQueueContext *eq_ctx,
BMEdge **edges = td->edges;
for (int j = 0; j < td->totedge; j++) {
BMEdge *e = edges[j];
MDynTopoVert *mv1, *mv2;
MSculptVert *mv1, *mv2;
mv1 = BKE_PBVH_DYNVERT(cd_dyn_vert, e->v1);
mv2 = BKE_PBVH_DYNVERT(cd_dyn_vert, e->v2);
mv1 = BKE_PBVH_SCULPTVERT(cd_sculpt_vert, e->v1);
mv2 = BKE_PBVH_SCULPTVERT(cd_sculpt_vert, e->v2);
pbvh_check_vert_boundary(pbvh, e->v1);
pbvh_check_vert_boundary(pbvh, e->v2);
if ((mv1->flag & DYNVERT_ALL_CORNER) || (mv2->flag & DYNVERT_ALL_CORNER)) {
if ((mv1->flag & SCULPTVERT_ALL_CORNER) || (mv2->flag & SCULPTVERT_ALL_CORNER)) {
continue;
}
if ((mv1->flag & DYNVERT_ALL_BOUNDARY) != (mv2->flag & DYNVERT_ALL_BOUNDARY)) {
if ((mv1->flag & SCULPTVERT_ALL_BOUNDARY) != (mv2->flag & SCULPTVERT_ALL_BOUNDARY)) {
continue;
}
@ -3130,16 +3138,16 @@ static void pbvh_bmesh_split_edge(EdgeQueueContext *eq_ctx,
// pbvh_bmesh_check_nodes(pbvh);
float co_mid[3], no_mid[3];
MDynTopoVert *mv1 = BKE_PBVH_DYNVERT(pbvh->cd_dyn_vert, e->v1);
MDynTopoVert *mv2 = BKE_PBVH_DYNVERT(pbvh->cd_dyn_vert, e->v2);
MSculptVert *mv1 = BKE_PBVH_SCULPTVERT(pbvh->cd_sculpt_vert, e->v1);
MSculptVert *mv2 = BKE_PBVH_SCULPTVERT(pbvh->cd_sculpt_vert, e->v2);
pbvh_check_vert_boundary(pbvh, e->v1);
pbvh_check_vert_boundary(pbvh, e->v2);
MV_ADD_FLAG(mv1, DYNVERT_NEED_VALENCE | DYNVERT_NEED_BOUNDARY | DYNVERT_NEED_DISK_SORT);
MV_ADD_FLAG(mv2, DYNVERT_NEED_VALENCE | DYNVERT_NEED_BOUNDARY | DYNVERT_NEED_DISK_SORT);
MV_ADD_FLAG(mv1, SCULPTVERT_NEED_VALENCE | SCULPTVERT_NEED_BOUNDARY | SCULPTVERT_NEED_DISK_SORT);
MV_ADD_FLAG(mv2, SCULPTVERT_NEED_VALENCE | SCULPTVERT_NEED_BOUNDARY | SCULPTVERT_NEED_DISK_SORT);
bool boundary = (mv1->flag & DYNVERT_ALL_BOUNDARY) && (mv2->flag & DYNVERT_ALL_BOUNDARY);
bool boundary = (mv1->flag & SCULPTVERT_ALL_BOUNDARY) && (mv2->flag & SCULPTVERT_ALL_BOUNDARY);
/* Get all faces adjacent to the edge */
pbvh_bmesh_edge_loops(edge_loops, e);
@ -3166,7 +3174,7 @@ static void pbvh_bmesh_split_edge(EdgeQueueContext *eq_ctx,
e1->head.hflag = e2->head.hflag = eflag;
v_new->head.hflag = vflag;
MDynTopoVert *mv_new = BKE_PBVH_DYNVERT(pbvh->cd_dyn_vert, v_new);
MSculptVert *mv_new = BKE_PBVH_SCULPTVERT(pbvh->cd_sculpt_vert, v_new);
/*TODO: is it worth interpolating edge customdata?*/
@ -3177,9 +3185,10 @@ static void pbvh_bmesh_split_edge(EdgeQueueContext *eq_ctx,
CustomData_bmesh_interp(
&pbvh->bm->vdata, (const void **)vsrcs, (float *)vws, NULL, 2, v_new->head.data);
// bke_pbvh_update_vert_boundary(pbvh->cd_dyn_vert, pbvh->cd_faceset_offset, v_new);
MV_ADD_FLAG(mv_new, DYNVERT_NEED_DISK_SORT | DYNVERT_NEED_VALENCE | DYNVERT_NEED_BOUNDARY);
mv_new->flag &= ~DYNVERT_VALENCE_TEMP;
// bke_pbvh_update_vert_boundary(pbvh->cd_sculpt_vert, pbvh->cd_faceset_offset, v_new);
MV_ADD_FLAG(mv_new,
SCULPTVERT_NEED_DISK_SORT | SCULPTVERT_NEED_VALENCE | SCULPTVERT_NEED_BOUNDARY);
mv_new->flag &= ~SCULPTVERT_VALENCE_TEMP;
int ni_new2 = BM_ELEM_CD_GET_INT(v_new, pbvh->cd_vert_node_offset);
if (ni_new2 != ni_new) {
@ -3208,13 +3217,16 @@ static void pbvh_bmesh_split_edge(EdgeQueueContext *eq_ctx,
v1 = l_adj->v;
v2 = l_adj->next->v;
MDynTopoVert *mv1b = BKE_PBVH_DYNVERT(pbvh->cd_dyn_vert, v1);
MDynTopoVert *mv2b = BKE_PBVH_DYNVERT(pbvh->cd_dyn_vert, v2);
MDynTopoVert *mv_opp = BKE_PBVH_DYNVERT(pbvh->cd_dyn_vert, v_opp);
MSculptVert *mv1b = BKE_PBVH_SCULPTVERT(pbvh->cd_sculpt_vert, v1);
MSculptVert *mv2b = BKE_PBVH_SCULPTVERT(pbvh->cd_sculpt_vert, v2);
MSculptVert *mv_opp = BKE_PBVH_SCULPTVERT(pbvh->cd_sculpt_vert, v_opp);
MV_ADD_FLAG(mv1b, DYNVERT_NEED_VALENCE | DYNVERT_NEED_BOUNDARY | DYNVERT_NEED_DISK_SORT);
MV_ADD_FLAG(mv2b, DYNVERT_NEED_VALENCE | DYNVERT_NEED_BOUNDARY | DYNVERT_NEED_DISK_SORT);
MV_ADD_FLAG(mv_opp, DYNVERT_NEED_VALENCE | DYNVERT_NEED_BOUNDARY | DYNVERT_NEED_DISK_SORT);
MV_ADD_FLAG(mv1b,
SCULPTVERT_NEED_VALENCE | SCULPTVERT_NEED_BOUNDARY | SCULPTVERT_NEED_DISK_SORT);
MV_ADD_FLAG(mv2b,
SCULPTVERT_NEED_VALENCE | SCULPTVERT_NEED_BOUNDARY | SCULPTVERT_NEED_DISK_SORT);
MV_ADD_FLAG(mv_opp,
SCULPTVERT_NEED_VALENCE | SCULPTVERT_NEED_BOUNDARY | SCULPTVERT_NEED_DISK_SORT);
if (ni != node_index && i == 0) {
pbvh_bmesh_vert_ownership_transfer(pbvh, &pbvh->nodes[ni], v_new);
@ -3601,20 +3613,21 @@ static void pbvh_bmesh_collapse_edge(PBVH *pbvh,
pbvh_check_vert_boundary(pbvh, v1);
pbvh_check_vert_boundary(pbvh, v2);
const int mupdateflag = DYNVERT_NEED_VALENCE | DYNVERT_NEED_BOUNDARY | DYNVERT_NEED_DISK_SORT;
// updateflag |= DYNVERT_NEED_TRIANGULATE; // to check for non-manifold flaps
const int mupdateflag = SCULPTVERT_NEED_VALENCE | SCULPTVERT_NEED_BOUNDARY |
SCULPTVERT_NEED_DISK_SORT;
// updateflag |= SCULPTVERT_NEED_TRIANGULATE; // to check for non-manifold flaps
validate_edge(pbvh, pbvh->bm, e, true, true);
check_vert_fan_are_tris(pbvh, e->v1);
check_vert_fan_are_tris(pbvh, e->v2);
MDynTopoVert *mv1 = BKE_PBVH_DYNVERT(pbvh->cd_dyn_vert, v1);
MDynTopoVert *mv2 = BKE_PBVH_DYNVERT(pbvh->cd_dyn_vert, v2);
MSculptVert *mv1 = BKE_PBVH_SCULPTVERT(pbvh->cd_sculpt_vert, v1);
MSculptVert *mv2 = BKE_PBVH_SCULPTVERT(pbvh->cd_sculpt_vert, v2);
/* one of the two vertices may be masked, select the correct one for deletion */
if (!(mv1->flag & DYNVERT_ALL_CORNER) || DYNTOPO_MASK(eq_ctx->cd_vert_mask_offset, v1) <
DYNTOPO_MASK(eq_ctx->cd_vert_mask_offset, v2)) {
if (!(mv1->flag & SCULPTVERT_ALL_CORNER) || DYNTOPO_MASK(eq_ctx->cd_vert_mask_offset, v1) <
DYNTOPO_MASK(eq_ctx->cd_vert_mask_offset, v2)) {
v_del = v1;
v_conn = v2;
}
@ -3622,24 +3635,24 @@ static void pbvh_bmesh_collapse_edge(PBVH *pbvh,
v_del = v2;
v_conn = v1;
SWAP(MDynTopoVert *, mv1, mv2);
SWAP(MSculptVert *, mv1, mv2);
}
if ((mv1->flag & DYNVERT_ALL_CORNER) ||
(mv1->flag & DYNVERT_ALL_BOUNDARY) != (mv2->flag & DYNVERT_ALL_BOUNDARY)) {
if ((mv1->flag & SCULPTVERT_ALL_CORNER) ||
(mv1->flag & SCULPTVERT_ALL_BOUNDARY) != (mv2->flag & SCULPTVERT_ALL_BOUNDARY)) {
return;
}
/*have to check edge flags directly, vertex flag test above isn't specific enough and
can sometimes let bad edges through*/
if ((mv1->flag & DYNVERT_SHARP_BOUNDARY) && (e->head.hflag & BM_ELEM_SMOOTH)) {
if ((mv1->flag & SCULPTVERT_SHARP_BOUNDARY) && (e->head.hflag & BM_ELEM_SMOOTH)) {
return;
}
if ((mv1->flag & DYNVERT_SEAM_BOUNDARY) && !(e->head.hflag & BM_ELEM_SEAM)) {
if ((mv1->flag & SCULPTVERT_SEAM_BOUNDARY) && !(e->head.hflag & BM_ELEM_SEAM)) {
return;
}
bool snap = !(mv2->flag & DYNVERT_ALL_CORNER);
bool snap = !(mv2->flag & SCULPTVERT_ALL_CORNER);
#if 0
// don't allow non-manifold case of
@ -3782,7 +3795,7 @@ static void pbvh_bmesh_collapse_edge(PBVH *pbvh,
int totl = 0;
BM_LOOPS_OF_VERT_ITER_BEGIN (l, v_del) {
MDynTopoVert *mv_l = BKE_PBVH_DYNVERT(pbvh->cd_dyn_vert, l->next->v);
MSculptVert *mv_l = BKE_PBVH_SCULPTVERT(pbvh->cd_sculpt_vert, l->next->v);
MV_ADD_FLAG(mv_l, mupdateflag);
BLI_array_append(ls, l);
@ -3791,7 +3804,7 @@ static void pbvh_bmesh_collapse_edge(PBVH *pbvh,
BM_LOOPS_OF_VERT_ITER_END;
BM_LOOPS_OF_VERT_ITER_BEGIN (l, v_conn) {
MDynTopoVert *mv_l = BKE_PBVH_DYNVERT(pbvh->cd_dyn_vert, l->next->v);
MSculptVert *mv_l = BKE_PBVH_SCULPTVERT(pbvh->cd_sculpt_vert, l->next->v);
MV_ADD_FLAG(mv_l, mupdateflag);
BLI_array_append(ls, l);
@ -3849,14 +3862,14 @@ static void pbvh_bmesh_collapse_edge(PBVH *pbvh,
do {
BMLoop *l2 = l->f->l_first;
do {
MDynTopoVert *mv = BKE_PBVH_DYNVERT(pbvh->cd_dyn_vert, l2->v);
MSculptVert *mv = BKE_PBVH_SCULPTVERT(pbvh->cd_sculpt_vert, l2->v);
if (l2->v == v_conn || l2->v == v_del) {
continue;
}
// if (mv->flag & DYNVERT_NEED_VALENCE) {
BKE_pbvh_bmesh_update_valence(pbvh->cd_dyn_vert, (SculptVertRef){.i = (intptr_t)l2->v});
// if (mv->flag & SCULPTVERT_NEED_VALENCE) {
BKE_pbvh_bmesh_update_valence(pbvh->cd_sculpt_vert, (SculptVertRef){.i = (intptr_t)l2->v});
//}
// BKE_pbvh_bmesh_check_valence(pbvh, (SculptVertRef){.i = (intptr_t)l2->v});
@ -3952,7 +3965,7 @@ static void pbvh_bmesh_collapse_edge(PBVH *pbvh,
continue;
}
MDynTopoVert *mv1 = BKE_PBVH_DYNVERT(pbvh->cd_dyn_vert, v);
MSculptVert *mv1 = BKE_PBVH_SCULPTVERT(pbvh->cd_sculpt_vert, v);
MV_ADD_FLAG(mv1, mupdateflag);
BKE_pbvh_bmesh_remove_vertex(pbvh, v, true);
@ -3984,7 +3997,7 @@ static void pbvh_bmesh_collapse_edge(PBVH *pbvh,
return;
}
MDynTopoVert *mv_conn = BKE_PBVH_DYNVERT(pbvh->cd_dyn_vert, v_conn);
MSculptVert *mv_conn = BKE_PBVH_SCULPTVERT(pbvh->cd_sculpt_vert, v_conn);
MV_ADD_FLAG(mv_conn, mupdateflag);
bool wasbad = false;
@ -4000,7 +4013,7 @@ static void pbvh_bmesh_collapse_edge(PBVH *pbvh,
BMLoop *l = e2->l;
BMVert *v2 = BM_edge_other_vert(e2, v_conn);
MDynTopoVert *mv2 = BKE_PBVH_DYNVERT(pbvh->cd_dyn_vert, v2);
MSculptVert *mv2 = BKE_PBVH_SCULPTVERT(pbvh->cd_sculpt_vert, v2);
MV_ADD_FLAG(mv2, mupdateflag);
// kill wire edge
@ -4054,7 +4067,7 @@ static void pbvh_bmesh_collapse_edge(PBVH *pbvh,
} while (v_conn->e && (e2 = enext) != v_conn->e);
// BM_vert_splice(pbvh->bm, v_del, v_conn);
MDynTopoVert *mv3 = BKE_PBVH_DYNVERT(pbvh->cd_dyn_vert, v_conn);
MSculptVert *mv3 = BKE_PBVH_SCULPTVERT(pbvh->cd_sculpt_vert, v_conn);
MV_ADD_FLAG(mv3, mupdateflag);
if (BM_ELEM_CD_GET_INT(v_conn, pbvh->cd_vert_node_offset) == DYNTOPO_NODE_NONE) {
@ -4080,7 +4093,7 @@ static void pbvh_bmesh_collapse_edge(PBVH *pbvh,
enext = BM_DISK_EDGE_NEXT(e, v_conn);
BMVert *v2 = BM_edge_other_vert(e, v_conn);
MDynTopoVert *mv4 = BKE_PBVH_DYNVERT(pbvh->cd_dyn_vert, v2);
MSculptVert *mv4 = BKE_PBVH_SCULPTVERT(pbvh->cd_sculpt_vert, v2);
} while ((e = enext) != v_conn->e);
}
@ -4113,7 +4126,8 @@ static void pbvh_bmesh_collapse_edge1(PBVH *pbvh,
BKE_pbvh_bmesh_check_origdata(pbvh, e->v1, pbvh->stroke_id);
BKE_pbvh_bmesh_check_origdata(pbvh, e->v2, pbvh->stroke_id);
const int mupdateflag = DYNVERT_NEED_BOUNDARY | DYNVERT_NEED_DISK_SORT | DYNVERT_NEED_VALENCE;
const int mupdateflag = SCULPTVERT_NEED_BOUNDARY | SCULPTVERT_NEED_DISK_SORT |
SCULPTVERT_NEED_VALENCE;
// customdata interpolation
@ -4153,7 +4167,7 @@ static void pbvh_bmesh_collapse_edge1(PBVH *pbvh,
do {
BMEdge *e2 = l->e;
MDynTopoVert *mv_l = BKE_PBVH_DYNVERT(pbvh->cd_dyn_vert, l->v);
MSculptVert *mv_l = BKE_PBVH_SCULPTVERT(pbvh->cd_sculpt_vert, l->v);
MV_ADD_FLAG(mv_l, mupdateflag);
l = l->next;
@ -4196,7 +4210,7 @@ static void pbvh_bmesh_collapse_edge1(PBVH *pbvh,
int totl = 0;
BM_LOOPS_OF_VERT_ITER_BEGIN (l, v_del) {
MDynTopoVert *mv_l = BKE_PBVH_DYNVERT(pbvh->cd_dyn_vert, l->v);
MSculptVert *mv_l = BKE_PBVH_SCULPTVERT(pbvh->cd_sculpt_vert, l->v);
MV_ADD_FLAG(mv_l, mupdateflag);
BLI_array_append(ls, l);
@ -4205,7 +4219,7 @@ static void pbvh_bmesh_collapse_edge1(PBVH *pbvh,
BM_LOOPS_OF_VERT_ITER_END;
BM_LOOPS_OF_VERT_ITER_BEGIN (l, v_conn) {
MDynTopoVert *mv_l = BKE_PBVH_DYNVERT(pbvh->cd_dyn_vert, l->v);
MSculptVert *mv_l = BKE_PBVH_SCULPTVERT(pbvh->cd_sculpt_vert, l->v);
MV_ADD_FLAG(mv_l, mupdateflag);
BLI_array_append(ls, l);
@ -4342,8 +4356,8 @@ static void pbvh_bmesh_collapse_edge1(PBVH *pbvh,
}
#endif
MDynTopoVert *mv2 = BKE_PBVH_DYNVERT(pbvh->cd_dyn_vert, v_tri[1]);
MDynTopoVert *mv3 = BKE_PBVH_DYNVERT(pbvh->cd_dyn_vert, v_tri[2]);
MSculptVert *mv2 = BKE_PBVH_SCULPTVERT(pbvh->cd_sculpt_vert, v_tri[1]);
MSculptVert *mv3 = BKE_PBVH_SCULPTVERT(pbvh->cd_sculpt_vert, v_tri[2]);
MV_ADD_FLAG(mv2, mupdateflag);
MV_ADD_FLAG(mv3, mupdateflag);
@ -4440,7 +4454,7 @@ static void pbvh_bmesh_collapse_edge1(PBVH *pbvh,
l1->e = bmesh_edge_create_log(pbvh, l1->v, l1->next->v, NULL);
}
MDynTopoVert *mv_l = BKE_PBVH_DYNVERT(pbvh->cd_dyn_vert, l->v);
MSculptVert *mv_l = BKE_PBVH_SCULPTVERT(pbvh->cd_sculpt_vert, l->v);
MV_ADD_FLAG(mv_l, mupdateflag);
l1 = l1->next;
@ -4510,7 +4524,7 @@ static void pbvh_bmesh_collapse_edge1(PBVH *pbvh,
* note that we can often get-away without this but causes T48779 */
BM_LOOPS_OF_VERT_ITER_BEGIN (l, v_conn) {
BMVert *v2 = BM_edge_other_vert(l->e, v_conn);
MDynTopoVert *mv2 = BKE_PBVH_DYNVERT(pbvh->cd_dyn_vert, v2);
MSculptVert *mv2 = BKE_PBVH_SCULPTVERT(pbvh->cd_sculpt_vert, v2);
MV_ADD_FLAG(mv2, mupdateflag);
@ -4520,10 +4534,10 @@ static void pbvh_bmesh_collapse_edge1(PBVH *pbvh,
}
BM_LOOPS_OF_VERT_ITER_END;
MDynTopoVert *mv_conn = BKE_PBVH_DYNVERT(pbvh->cd_dyn_vert, v_conn);
MSculptVert *mv_conn = BKE_PBVH_SCULPTVERT(pbvh->cd_sculpt_vert, v_conn);
MV_ADD_FLAG(mv_conn, mupdateflag);
MDynTopoVert *mv_del = BKE_PBVH_DYNVERT(pbvh->cd_dyn_vert, v_del);
MSculptVert *mv_del = BKE_PBVH_SCULPTVERT(pbvh->cd_sculpt_vert, v_del);
mv_conn->flag |= mv_del->flag;
validate_vert(pbvh, pbvh->bm, v_conn, true, false);
@ -4544,9 +4558,9 @@ static void pbvh_bmesh_collapse_edge1(PBVH *pbvh,
BM_log_face_removed(pbvh->bm_log, l->f);
// paranoia check, propegate update flags
MDynTopoVert *mv_l = BKE_PBVH_DYNVERT(pbvh->cd_dyn_vert, l->v);
MSculptVert *mv_l = BKE_PBVH_SCULPTVERT(pbvh->cd_sculpt_vert, l->v);
MV_ADD_FLAG(mv_l, mupdateflag);
mv_l = BKE_PBVH_DYNVERT(pbvh->cd_dyn_vert, l->next->v);
mv_l = BKE_PBVH_SCULPTVERT(pbvh->cd_sculpt_vert, l->next->v);
MV_ADD_FLAG(mv_l, mupdateflag);
if (ni >= 0) {
@ -4729,7 +4743,7 @@ cleanup_valence_3_4(EdgeQueueContext *ectx,
const int cd_vert_node = pbvh->cd_vert_node_offset;
int updateflag = DYNVERT_NEED_BOUNDARY | DYNVERT_NEED_DISK_SORT | DYNVERT_NEED_VALENCE;
int updateflag = SCULPTVERT_NEED_BOUNDARY | SCULPTVERT_NEED_DISK_SORT | SCULPTVERT_NEED_VALENCE;
for (int vi = 0; vi < ectx->val34_verts_tot; vi++) {
if (pbvh->dyntopo_stop) {
@ -4756,9 +4770,9 @@ cleanup_valence_3_4(EdgeQueueContext *ectx,
continue;
}
MDynTopoVert *mv = BKE_PBVH_DYNVERT(pbvh->cd_dyn_vert, v);
MSculptVert *mv = BKE_PBVH_SCULPTVERT(pbvh->cd_sculpt_vert, v);
mv->flag &= ~DYNVERT_VALENCE_TEMP;
mv->flag &= ~SCULPTVERT_VALENCE_TEMP;
validate_vert(pbvh, pbvh->bm, v, false, true);
check_vert_fan_are_tris(pbvh, v);
@ -4780,7 +4794,7 @@ cleanup_valence_3_4(EdgeQueueContext *ectx,
pbvh_check_vert_boundary(pbvh, v);
if (mv->flag & DYNVERT_ALL_BOUNDARY) {
if (mv->flag & SCULPTVERT_ALL_BOUNDARY) {
continue;
}
@ -4805,13 +4819,13 @@ cleanup_valence_3_4(EdgeQueueContext *ectx,
for (int j = 0; j < val; j++) {
ls[i++] = l->v == v ? l->next : l;
MDynTopoVert *mv_l;
MSculptVert *mv_l;
if (l->v == v) {
mv_l = BKE_PBVH_DYNVERT(pbvh->cd_dyn_vert, l->next->v);
mv_l = BKE_PBVH_SCULPTVERT(pbvh->cd_sculpt_vert, l->next->v);
}
else {
mv_l = BKE_PBVH_DYNVERT(pbvh->cd_dyn_vert, l->v);
mv_l = BKE_PBVH_SCULPTVERT(pbvh->cd_sculpt_vert, l->v);
}
MV_ADD_FLAG(mv_l, updateflag);
@ -4911,9 +4925,9 @@ cleanup_valence_3_4(EdgeQueueContext *ectx,
for (int j = 0; j < BLI_array_len(verts); j++) {
BMVert *v2 = verts[j];
MDynTopoVert *mv2 = BKE_PBVH_DYNVERT(pbvh->cd_dyn_vert, v2);
mv2->flag |= DYNVERT_NEED_BOUNDARY | DYNVERT_NEED_DISK_SORT | DYNVERT_NEED_VALENCE |
DYNVERT_NEED_TRIANGULATE;
MSculptVert *mv2 = BKE_PBVH_SCULPTVERT(pbvh->cd_sculpt_vert, v2);
mv2->flag |= SCULPTVERT_NEED_BOUNDARY | SCULPTVERT_NEED_DISK_SORT | SCULPTVERT_NEED_VALENCE |
SCULPTVERT_NEED_TRIANGULATE;
BMEdge *e3 = v2->e;
do {
@ -4928,9 +4942,9 @@ cleanup_valence_3_4(EdgeQueueContext *ectx,
BMLoop *l3 = l2->f->l_first;
do {
MDynTopoVert *mv3 = BKE_PBVH_DYNVERT(pbvh->cd_dyn_vert, l3->v);
mv3->flag |= DYNVERT_NEED_BOUNDARY | DYNVERT_NEED_DISK_SORT |
DYNVERT_NEED_VALENCE | DYNVERT_NEED_TRIANGULATE;
MSculptVert *mv3 = BKE_PBVH_SCULPTVERT(pbvh->cd_sculpt_vert, l3->v);
mv3->flag |= SCULPTVERT_NEED_BOUNDARY | SCULPTVERT_NEED_DISK_SORT |
SCULPTVERT_NEED_VALENCE | SCULPTVERT_NEED_TRIANGULATE;
} while ((l3 = l3->next) != l2->f->l_first);
}
} while ((l2 = l2->radial_next) != e3->l);
@ -5009,9 +5023,9 @@ cleanup_valence_3_4(EdgeQueueContext *ectx,
validate_vert(pbvh, pbvh->bm, v, false, false);
MDynTopoVert *mv1 = BKE_PBVH_DYNVERT(pbvh->cd_dyn_vert, vs[0]);
MDynTopoVert *mv2 = BKE_PBVH_DYNVERT(pbvh->cd_dyn_vert, vs[1]);
MDynTopoVert *mv3 = BKE_PBVH_DYNVERT(pbvh->cd_dyn_vert, vs[2]);
MSculptVert *mv1 = BKE_PBVH_SCULPTVERT(pbvh->cd_sculpt_vert, vs[0]);
MSculptVert *mv2 = BKE_PBVH_SCULPTVERT(pbvh->cd_sculpt_vert, vs[1]);
MSculptVert *mv3 = BKE_PBVH_SCULPTVERT(pbvh->cd_sculpt_vert, vs[2]);
MV_ADD_FLAG(mv1, updateflag);
MV_ADD_FLAG(mv2, updateflag);
@ -5044,9 +5058,9 @@ cleanup_valence_3_4(EdgeQueueContext *ectx,
ok2 = ok2 && !BM_face_exists(vs, 3);
if (ok2) {
MDynTopoVert *mv1 = BKE_PBVH_DYNVERT(pbvh->cd_dyn_vert, vs[0]);
MDynTopoVert *mv2 = BKE_PBVH_DYNVERT(pbvh->cd_dyn_vert, vs[1]);
MDynTopoVert *mv3 = BKE_PBVH_DYNVERT(pbvh->cd_dyn_vert, vs[2]);
MSculptVert *mv1 = BKE_PBVH_SCULPTVERT(pbvh->cd_sculpt_vert, vs[0]);
MSculptVert *mv2 = BKE_PBVH_SCULPTVERT(pbvh->cd_sculpt_vert, vs[1]);
MSculptVert *mv3 = BKE_PBVH_SCULPTVERT(pbvh->cd_sculpt_vert, vs[2]);
MV_ADD_FLAG(mv1, updateflag);
MV_ADD_FLAG(mv2, updateflag);
@ -5170,11 +5184,11 @@ static void on_vert_swap(BMVert *v1, BMVert *v2, void *userdata)
PBVH *pbvh = sdata->pbvh;
BMesh *bm = pbvh->bm;
MDynTopoVert *mv1 = BKE_PBVH_DYNVERT(pbvh->cd_dyn_vert, v1);
MDynTopoVert *mv2 = BKE_PBVH_DYNVERT(pbvh->cd_dyn_vert, v2);
MSculptVert *mv1 = BKE_PBVH_SCULPTVERT(pbvh->cd_sculpt_vert, v1);
MSculptVert *mv2 = BKE_PBVH_SCULPTVERT(pbvh->cd_sculpt_vert, v2);
MV_ADD_FLAG(mv1, DYNVERT_NEED_BOUNDARY | DYNVERT_NEED_VALENCE | DYNVERT_NEED_DISK_SORT);
MV_ADD_FLAG(mv2, DYNVERT_NEED_BOUNDARY | DYNVERT_NEED_VALENCE | DYNVERT_NEED_DISK_SORT);
MV_ADD_FLAG(mv1, SCULPTVERT_NEED_BOUNDARY | SCULPTVERT_NEED_VALENCE | SCULPTVERT_NEED_DISK_SORT);
MV_ADD_FLAG(mv2, SCULPTVERT_NEED_BOUNDARY | SCULPTVERT_NEED_VALENCE | SCULPTVERT_NEED_DISK_SORT);
int ni1 = BM_ELEM_CD_GET_INT(v1, pbvh->cd_vert_node_offset);
int ni2 = BM_ELEM_CD_GET_INT(v2, pbvh->cd_vert_node_offset);
@ -5239,10 +5253,10 @@ static bool do_cleanup_3_4(EdgeQueueContext *eq_ctx,
continue;
}
MDynTopoVert *mv = BKE_PBVH_DYNVERT(pbvh->cd_dyn_vert, v);
MSculptVert *mv = BKE_PBVH_SCULPTVERT(pbvh->cd_sculpt_vert, v);
if (mv->flag & DYNVERT_NEED_VALENCE) {
BKE_pbvh_bmesh_update_valence(pbvh->cd_dyn_vert, (SculptVertRef){.i = (intptr_t)v});
if (mv->flag & SCULPTVERT_NEED_VALENCE) {
BKE_pbvh_bmesh_update_valence(pbvh->cd_sculpt_vert, (SculptVertRef){.i = (intptr_t)v});
}
if (mv->valence < 5) {
@ -5264,9 +5278,9 @@ static bool do_cleanup_3_4(EdgeQueueContext *eq_ctx,
printf("%s error\n", __func__);
continue;
}
MDynTopoVert *mv = BKE_PBVH_DYNVERT(pbvh->cd_dyn_vert, v);
MSculptVert *mv = BKE_PBVH_SCULPTVERT(pbvh->cd_sculpt_vert, v);
mv->flag &= ~DYNVERT_VALENCE_TEMP;
mv->flag &= ~SCULPTVERT_VALENCE_TEMP;
}
modified |= cleanup_valence_3_4(
@ -5298,7 +5312,7 @@ bool BKE_pbvh_bmesh_update_topology(PBVH *pbvh,
const int cd_vert_mask_offset = CustomData_get_offset(&pbvh->bm->vdata, CD_PAINT_MASK);
const int cd_vert_node_offset = pbvh->cd_vert_node_offset;
const int cd_face_node_offset = pbvh->cd_face_node_offset;
const int cd_dyn_vert = pbvh->cd_dyn_vert;
const int cd_sculpt_vert = pbvh->cd_sculpt_vert;
float ratio = 1.0f;
bool modified = false;
@ -5361,7 +5375,7 @@ typedef struct EdgeQueueContext {
BMesh *bm;
DyntopoMaskCB mask_cb;
void *mask_cb_data;
int cd_dyn_vert;
int cd_sculpt_vert;
int cd_vert_mask_offset;
int cd_vert_node_offset;
int cd_face_node_offset;
@ -5382,7 +5396,7 @@ typedef struct EdgeQueueContext {
.mask_cb = mask_cb,
.mask_cb_data = mask_cb_data,
.cd_dyn_vert = cd_dyn_vert,
.cd_sculpt_vert = cd_sculpt_vert,
.cd_vert_mask_offset = cd_vert_mask_offset,
.cd_vert_node_offset = cd_vert_node_offset,
.cd_face_node_offset = cd_face_node_offset,
@ -5585,8 +5599,8 @@ typedef struct EdgeQueueContext {
continue;
}
MDynTopoVert *mv = BKE_PBVH_DYNVERT(pbvh->cd_dyn_vert, v);
mv->flag |= DYNVERT_NEED_BOUNDARY | DYNVERT_NEED_VALENCE | DYNVERT_NEED_DISK_SORT;
MSculptVert *mv = BKE_PBVH_SCULPTVERT(pbvh->cd_sculpt_vert, v);
mv->flag |= SCULPTVERT_NEED_BOUNDARY | SCULPTVERT_NEED_VALENCE | SCULPTVERT_NEED_DISK_SORT;
if (BLI_rng_get_double(rng) > 0.5f) {
continue;
@ -5895,8 +5909,9 @@ static void pbvh_split_edges(EdgeQueueContext *eq_ctx,
l2->e->head.hflag &= ~SPLIT_TAG;
l2->v->head.hflag &= ~SPLIT_TAG;
MDynTopoVert *mv = BKE_PBVH_DYNVERT(pbvh->cd_dyn_vert, l2->v);
MV_ADD_FLAG(mv, DYNVERT_NEED_VALENCE | DYNVERT_NEED_BOUNDARY | DYNVERT_NEED_DISK_SORT);
MSculptVert *mv = BKE_PBVH_SCULPTVERT(pbvh->cd_sculpt_vert, l2->v);
MV_ADD_FLAG(
mv, SCULPTVERT_NEED_VALENCE | SCULPTVERT_NEED_BOUNDARY | SCULPTVERT_NEED_DISK_SORT);
if (_j > 10000) {
printf("infinite loop error 1\n");
@ -6006,8 +6021,8 @@ static void pbvh_split_edges(EdgeQueueContext *eq_ctx,
e->head.hflag &= ~SPLIT_TAG;
MDynTopoVert *mv1 = BKE_PBVH_DYNVERT(pbvh->cd_dyn_vert, e->v1);
MDynTopoVert *mv2 = BKE_PBVH_DYNVERT(pbvh->cd_dyn_vert, e->v2);
MSculptVert *mv1 = BKE_PBVH_SCULPTVERT(pbvh->cd_sculpt_vert, e->v1);
MSculptVert *mv2 = BKE_PBVH_SCULPTVERT(pbvh->cd_sculpt_vert, e->v2);
if (mv1->stroke_id != pbvh->stroke_id) {
BKE_pbvh_bmesh_check_origdata(pbvh, e->v1, pbvh->stroke_id);
@ -6028,14 +6043,16 @@ static void pbvh_split_edges(EdgeQueueContext *eq_ctx,
validate_edge(pbvh, pbvh->bm, newe, true, true);
validate_vert(pbvh, pbvh->bm, newv, true, true);
MDynTopoVert *mv = BKE_PBVH_DYNVERT(pbvh->cd_dyn_vert, newv);
MSculptVert *mv = BKE_PBVH_SCULPTVERT(pbvh->cd_sculpt_vert, newv);
newv->head.hflag |= SPLIT_TAG;
MV_ADD_FLAG(mv, DYNVERT_NEED_VALENCE | DYNVERT_NEED_BOUNDARY | DYNVERT_NEED_DISK_SORT);
MV_ADD_FLAG(mv,
SCULPTVERT_NEED_VALENCE | SCULPTVERT_NEED_BOUNDARY | SCULPTVERT_NEED_DISK_SORT);
mv->stroke_id = pbvh->stroke_id;
MV_ADD_FLAG(mv, DYNVERT_NEED_DISK_SORT | DYNVERT_NEED_VALENCE | DYNVERT_NEED_BOUNDARY);
mv->flag &= ~DYNVERT_VALENCE_TEMP;
MV_ADD_FLAG(mv,
SCULPTVERT_NEED_DISK_SORT | SCULPTVERT_NEED_VALENCE | SCULPTVERT_NEED_BOUNDARY);
mv->flag &= ~SCULPTVERT_VALENCE_TEMP;
BM_ELEM_CD_SET_INT(newv, pbvh->cd_vert_node_offset, DYNTOPO_NODE_NONE);

16
source/blender/blenkernel/intern/paint.c
View File

@ -2228,7 +2228,7 @@ static PBVH *build_pbvh_for_dynamic_topology(Object *ob)
ob->sculpt->bm_log,
ob->sculpt->cd_vert_node_offset,
ob->sculpt->cd_face_node_offset,
ob->sculpt->cd_dyn_vert,
ob->sculpt->cd_sculpt_vert,
ob->sculpt->cd_face_areas,
ob->sculpt->fast_draw);
pbvh_show_mask_set(pbvh, ob->sculpt->show_mask);
@ -2343,10 +2343,11 @@ static void init_mdyntopo_layer_faces(SculptSession *ss, PBVH *pbvh, int totvert
BKE_pbvh_set_mdyntopo_verts(pbvh, ss->mdyntopo_verts);
MDynTopoVert *mv = ss->mdyntopo_verts;
MSculptVert *mv = ss->mdyntopo_verts;
for (int i = 0; i < totvert; i++, mv++) {
MV_ADD_FLAG(mv, DYNVERT_NEED_BOUNDARY | DYNVERT_NEED_VALENCE | DYNVERT_NEED_DISK_SORT);
MV_ADD_FLAG(mv,
SCULPTVERT_NEED_BOUNDARY | SCULPTVERT_NEED_VALENCE | SCULPTVERT_NEED_DISK_SORT);
mv->stroke_id = -1;
SculptVertRef vertex = {.i = i};
@ -2361,7 +2362,7 @@ static void init_mdyntopo_layer_faces(SculptSession *ss, PBVH *pbvh, int totvert
vertex);
// can't fully update boundary here, so still flag for update
MV_ADD_FLAG(mv, DYNVERT_NEED_BOUNDARY);
MV_ADD_FLAG(mv, SCULPTVERT_NEED_BOUNDARY);
}
}
@ -2376,10 +2377,11 @@ static void init_mdyntopo_layer_grids(SculptSession *ss, PBVH *pbvh, int totvert
BKE_pbvh_set_mdyntopo_verts(pbvh, ss->mdyntopo_verts);
MDynTopoVert *mv = ss->mdyntopo_verts;
MSculptVert *mv = ss->mdyntopo_verts;
for (int i = 0; i < totvert; i++, mv++) {
MV_ADD_FLAG(mv, DYNVERT_NEED_BOUNDARY | DYNVERT_NEED_VALENCE | DYNVERT_NEED_DISK_SORT);
MV_ADD_FLAG(mv,
SCULPTVERT_NEED_BOUNDARY | SCULPTVERT_NEED_VALENCE | SCULPTVERT_NEED_DISK_SORT);
mv->stroke_id = -1;
SculptVertRef vertex = {.i = i};
@ -2387,7 +2389,7 @@ static void init_mdyntopo_layer_grids(SculptSession *ss, PBVH *pbvh, int totvert
BKE_pbvh_update_vert_boundary_grids(pbvh, ss->subdiv_ccg, vertex);
// can't fully update boundary here, so still flag for update
MV_ADD_FLAG(mv, DYNVERT_NEED_BOUNDARY);
MV_ADD_FLAG(mv, SCULPTVERT_NEED_BOUNDARY);
}
}

56
source/blender/blenkernel/intern/pbvh.c
View File

@ -180,9 +180,9 @@ static void update_node_vb(PBVH *pbvh, PBVHNode *node, int updateflag)
}
if (do_orig) {
MDynTopoVert *mv = pbvh->type == PBVH_BMESH ?
BM_ELEM_CD_GET_VOID_P(vd.bm_vert, pbvh->cd_dyn_vert) :
pbvh->mdyntopo_verts + vd.index;
MSculptVert *mv = pbvh->type == PBVH_BMESH ?
BM_ELEM_CD_GET_VOID_P(vd.bm_vert, pbvh->cd_sculpt_vert) :
pbvh->mdyntopo_verts + vd.index;
if (mv->stroke_id != pbvh->stroke_id) {
BB_expand(&orig_vb, vd.co);
@ -657,7 +657,7 @@ void BKE_pbvh_build_mesh(PBVH *pbvh,
const MPoly *mpoly,
const MLoop *mloop,
MVert *verts,
MDynTopoVert *mdyntopo_verts,
MSculptVert *mdyntopo_verts,
int totvert,
struct CustomData *vdata,
@ -1638,7 +1638,7 @@ void BKE_pbvh_update_origcolor_bmesh(PBVH *pbvh, PBVHNode *node)
}
BKE_pbvh_vertex_iter_begin (pbvh, node, vd, PBVH_ITER_UNIQUE) {
MDynTopoVert *mv = BKE_PBVH_DYNVERT(pbvh->cd_dyn_vert, vd.bm_vert);
MSculptVert *mv = BKE_PBVH_SCULPTVERT(pbvh->cd_sculpt_vert, vd.bm_vert);
float *c2 = BM_ELEM_CD_GET_VOID_P(vd.bm_vert, pbvh->cd_vcol_offset);
copy_v4_v4(mv->origcolor, c2);
@ -1650,12 +1650,12 @@ void BKE_pbvh_update_origco_bmesh(PBVH *pbvh, PBVHNode *node)
{
PBVHVertexIter vd;
if (!pbvh->bm || pbvh->cd_dyn_vert < 0) {
if (!pbvh->bm || pbvh->cd_sculpt_vert < 0) {
return;
}
BKE_pbvh_vertex_iter_begin (pbvh, node, vd, PBVH_ITER_UNIQUE) {
MDynTopoVert *mv = BKE_PBVH_DYNVERT(pbvh->cd_dyn_vert, vd.bm_vert);
MSculptVert *mv = BKE_PBVH_SCULPTVERT(pbvh->cd_sculpt_vert, vd.bm_vert);
copy_v3_v3(mv->origco, vd.bm_vert->co);
copy_v3_v3(mv->origno, vd.bm_vert->no);
@ -3412,7 +3412,7 @@ void pbvh_vertex_iter_init(PBVH *pbvh, PBVHNode *node, PBVHVertexIter *vi, int m
vi->bm_vdata = &pbvh->bm->vdata;
vi->bm_vert = NULL;
vi->cd_dyn_vert = CustomData_get_offset(vi->bm_vdata, CD_DYNTOPO_VERT);
vi->cd_sculpt_vert = CustomData_get_offset(vi->bm_vdata, CD_DYNTOPO_VERT);
// we ensure pbvh->cd_vcol_offset is up to date here too
vi->cd_vcol_offset = pbvh->cd_vcol_offset = CustomData_get_offset(vi->bm_vdata, CD_PROP_COLOR);
@ -4172,14 +4172,14 @@ void BKE_pbvh_set_symmetry(PBVH *pbvh, int symmetry, int boundary_symmetry)
BMVert *v;
BM_ITER_MESH (v, &iter, pbvh->bm, BM_VERTS_OF_MESH) {
MDynTopoVert *mv = BKE_PBVH_DYNVERT(pbvh->cd_dyn_vert, v);
MSculptVert *mv = BKE_PBVH_SCULPTVERT(pbvh->cd_sculpt_vert, v);
MV_ADD_FLAG(mv, DYNVERT_NEED_BOUNDARY);
MV_ADD_FLAG(mv, SCULPTVERT_NEED_BOUNDARY);
}
}
}
void BKE_pbvh_set_mdyntopo_verts(PBVH *pbvh, struct MDynTopoVert *mdyntopoverts)
void BKE_pbvh_set_mdyntopo_verts(PBVH *pbvh, struct MSculptVert *mdyntopoverts)
{
pbvh->mdyntopo_verts = mdyntopoverts;
}
@ -4188,14 +4188,14 @@ void BKE_pbvh_update_vert_boundary_grids(PBVH *pbvh,
struct SubdivCCG *subdiv_ccg,
SculptVertRef vertex)
{
MDynTopoVert *mv = pbvh->mdyntopo_verts + vertex.i;
MSculptVert *mv = pbvh->mdyntopo_verts + vertex.i;
int last_fset = 0;
int last_fset2 = 0;
mv->flag &= ~(DYNVERT_BOUNDARY | DYNVERT_FSET_BOUNDARY | DYNVERT_NEED_BOUNDARY |
DYNVERT_FSET_CORNER | DYNVERT_CORNER | DYNVERT_SEAM_BOUNDARY |
DYNVERT_SHARP_BOUNDARY | DYNVERT_SEAM_CORNER | DYNVERT_SHARP_CORNER);
mv->flag &= ~(SCULPTVERT_BOUNDARY | SCULPTVERT_FSET_BOUNDARY | SCULPTVERT_NEED_BOUNDARY |
SCULPTVERT_FSET_CORNER | SCULPTVERT_CORNER | SCULPTVERT_SEAM_BOUNDARY |
SCULPTVERT_SHARP_BOUNDARY | SCULPTVERT_SEAM_CORNER | SCULPTVERT_SHARP_CORNER);
int totsharp = 0, totseam = 0;
int visible = false;
@ -4217,7 +4217,7 @@ void BKE_pbvh_update_vert_boundary_grids(PBVH *pbvh,
BKE_subdiv_ccg_neighbor_coords_get(subdiv_ccg, &coord, false, &neighbors);
mv->valence = neighbors.size;
mv->flag &= ~DYNVERT_NEED_VALENCE;
mv->flag &= ~SCULPTVERT_NEED_VALENCE;
}
void BKE_pbvh_update_vert_boundary_faces(int *face_sets,
@ -4225,19 +4225,19 @@ void BKE_pbvh_update_vert_boundary_faces(int *face_sets,
MEdge *medge,
MLoop *mloop,
MPoly *mpoly,
MDynTopoVert *mdyntopo_verts,
MSculptVert *mdyntopo_verts,
MeshElemMap *pmap,
SculptVertRef vertex)
{
MDynTopoVert *mv = mdyntopo_verts + vertex.i;
MSculptVert *mv = mdyntopo_verts + vertex.i;
MeshElemMap *vert_map = &pmap[vertex.i];
int last_fset = -1;
int last_fset2 = -1;
mv->flag &= ~(DYNVERT_BOUNDARY | DYNVERT_FSET_BOUNDARY | DYNVERT_NEED_BOUNDARY |
DYNVERT_FSET_CORNER | DYNVERT_CORNER | DYNVERT_SEAM_BOUNDARY |
DYNVERT_SHARP_BOUNDARY | DYNVERT_SEAM_CORNER | DYNVERT_SHARP_CORNER);
mv->flag &= ~(SCULPTVERT_BOUNDARY | SCULPTVERT_FSET_BOUNDARY | SCULPTVERT_NEED_BOUNDARY |
SCULPTVERT_FSET_CORNER | SCULPTVERT_CORNER | SCULPTVERT_SEAM_BOUNDARY |
SCULPTVERT_SHARP_BOUNDARY | SCULPTVERT_SEAM_CORNER | SCULPTVERT_SHARP_CORNER);
int totsharp = 0, totseam = 0;
int visible = false;
@ -4258,12 +4258,12 @@ void BKE_pbvh_update_vert_boundary_faces(int *face_sets,
if (j < mp->totloop) {
MEdge *me = medge + ml->e;
if (me->flag & ME_SHARP) {
mv->flag |= DYNVERT_SHARP_BOUNDARY;
mv->flag |= SCULPTVERT_SHARP_BOUNDARY;
totsharp++;
}
if (me->flag & ME_SEAM) {
mv->flag |= DYNVERT_SEAM_BOUNDARY;
mv->flag |= SCULPTVERT_SEAM_BOUNDARY;
totseam++;
}
}
@ -4278,11 +4278,11 @@ void BKE_pbvh_update_vert_boundary_faces(int *face_sets,
}
if (i > 0 && fset != last_fset) {
mv->flag |= DYNVERT_FSET_BOUNDARY;
mv->flag |= SCULPTVERT_FSET_BOUNDARY;
if (i > 1 && last_fset2 != last_fset && last_fset != -1 && last_fset2 != -1 && fset != -1 &&
last_fset2 != fset) {
mv->flag |= DYNVERT_FSET_CORNER;
mv->flag |= SCULPTVERT_FSET_CORNER;
}
}
@ -4294,14 +4294,14 @@ void BKE_pbvh_update_vert_boundary_faces(int *face_sets,
}
if (!visible) {
mv->flag |= DYNVERT_VERT_FSET_HIDDEN;
mv->flag |= SCULPTVERT_VERT_FSET_HIDDEN;
}
if (totsharp > 2) {
mv->flag |= DYNVERT_SHARP_CORNER;
mv->flag |= SCULPTVERT_SHARP_CORNER;
}
if (totseam > 2) {
mv->flag |= DYNVERT_SEAM_CORNER;
mv->flag |= SCULPTVERT_SEAM_CORNER;
}
}

211
source/blender/blenkernel/intern/pbvh_bmesh.c
View File

@ -153,7 +153,7 @@ void pbvh_bmesh_check_nodes(PBVH *pbvh)
_debugprint("vert in node->bm_other_verts");
}
MDynTopoVert *mv = BKE_PBVH_DYNVERT(pbvh->cd_dyn_vert,v);
MSculptVert *mv = BKE_PBVH_SCULPTVERT(pbvh->cd_sculpt_vert,v);
BKE_pbvh_bmesh_check_valence(pbvh,(SculptVertRef) { .i = (intptr_t)v });
if (BM_vert_edge_count(v) != mv->valence) {
@ -267,8 +267,8 @@ static void pbvh_bmesh_node_finalize(PBVH *pbvh,
do {
BMVert *v = l_iter->v;
MDynTopoVert *mv = BKE_PBVH_DYNVERT(pbvh->cd_dyn_vert, v);
MV_ADD_FLAG(mv, DYNVERT_NEED_BOUNDARY);
MSculptVert *mv = BKE_PBVH_SCULPTVERT(pbvh->cd_sculpt_vert, v);
MV_ADD_FLAG(mv, SCULPTVERT_NEED_BOUNDARY);
if (!BLI_table_gset_haskey(n->bm_unique_verts, v)) {
if (BM_ELEM_CD_GET_INT(v, cd_vert_node_offset) != DYNTOPO_NODE_NONE) {
@ -554,7 +554,7 @@ void bke_pbvh_insert_face_finalize(PBVH *pbvh, BMFace *f, const int ni)
BMLoop *l = f->l_first;
do {
const int ni2 = BM_ELEM_CD_GET_INT(l->v, pbvh->cd_vert_node_offset);
MDynTopoVert *mv = BKE_PBVH_DYNVERT(pbvh->cd_dyn_vert, l->v);
MSculptVert *mv = BKE_PBVH_SCULPTVERT(pbvh->cd_sculpt_vert, l->v);
BB_expand(&node->vb, l->v->co);
BB_expand(&node->orig_vb, mv->origco);
@ -810,7 +810,7 @@ void BKE_pbvh_bmesh_regen_node_verts(PBVH *pbvh)
void BKE_pbvh_bmesh_update_origvert(
PBVH *pbvh, BMVert *v, float **r_co, float **r_no, float **r_color, bool log_undo)
{
MDynTopoVert *mv = BKE_PBVH_DYNVERT(pbvh->cd_dyn_vert, v);
MSculptVert *mv = BKE_PBVH_SCULPTVERT(pbvh->cd_sculpt_vert, v);
if (log_undo) {
BM_log_vert_before_modified(pbvh->bm_log, v, pbvh->cd_vert_mask_offset, r_color != NULL);
@ -850,7 +850,7 @@ bool BKE_pbvh_bmesh_check_origdata(PBVH *pbvh, BMVert *v, int stroke_id)
{
// keep this up to date with surface_smooth_v_safe in dyntopo.c
MDynTopoVert *mv = BKE_PBVH_DYNVERT(pbvh->cd_dyn_vert, v);
MSculptVert *mv = BKE_PBVH_SCULPTVERT(pbvh->cd_sculpt_vert, v);
if (mv->stroke_id != stroke_id) {
float *dummy;
@ -884,7 +884,7 @@ bool pbvh_bmesh_node_raycast(PBVH *pbvh,
BKE_pbvh_bmesh_check_tris(pbvh, node);
PBVHTriBuf *tribuf = node->tribuf;
const int cd_dyn_vert = pbvh->cd_dyn_vert;
const int cd_sculpt_vert = pbvh->cd_sculpt_vert;
for (int i = 0; i < node->tribuf->tottri; i++) {
PBVHTri *tri = tribuf->tris + i;
@ -906,9 +906,9 @@ bool pbvh_bmesh_node_raycast(PBVH *pbvh,
BKE_pbvh_bmesh_check_origdata(pbvh, v2, stroke_id);
BKE_pbvh_bmesh_check_origdata(pbvh, v3, stroke_id);
co1 = BKE_PBVH_DYNVERT(cd_dyn_vert, v1)->origco;
co2 = BKE_PBVH_DYNVERT(cd_dyn_vert, v2)->origco;
co3 = BKE_PBVH_DYNVERT(cd_dyn_vert, v3)->origco;
co1 = BKE_PBVH_SCULPTVERT(cd_sculpt_vert, v1)->origco;
co2 = BKE_PBVH_SCULPTVERT(cd_sculpt_vert, v2)->origco;
co3 = BKE_PBVH_SCULPTVERT(cd_sculpt_vert, v3)->origco;
}
else {
co1 = v1->co;
@ -926,7 +926,7 @@ bool pbvh_bmesh_node_raycast(PBVH *pbvh,
for (int j = 0; j < 3; j++) {
BMVert *v = (BMVert *)tribuf->verts[tri->v[j]].i;
float *co = use_original ? BKE_PBVH_DYNVERT(cd_dyn_vert, v)->origco : v->co;
float *co = use_original ? BKE_PBVH_SCULPTVERT(cd_sculpt_vert, v)->origco : v->co;
float dist = len_squared_v3v3(co, ray_start);
if (dist < nearest_vertex_dist) {
@ -946,9 +946,9 @@ bool pbvh_bmesh_node_raycast(PBVH *pbvh,
float no[3];
if (use_original) {
copy_v3_v3(no, BKE_PBVH_DYNVERT(cd_dyn_vert, v1)->origno);
add_v3_v3(no, BKE_PBVH_DYNVERT(cd_dyn_vert, v2)->origno);
add_v3_v3(no, BKE_PBVH_DYNVERT(cd_dyn_vert, v3)->origno);
copy_v3_v3(no, BKE_PBVH_SCULPTVERT(cd_sculpt_vert, v1)->origno);
add_v3_v3(no, BKE_PBVH_SCULPTVERT(cd_sculpt_vert, v2)->origno);
add_v3_v3(no, BKE_PBVH_SCULPTVERT(cd_sculpt_vert, v3)->origno);
normalize_v3(no);
}
else {
@ -1021,7 +1021,7 @@ bool pbvh_bmesh_node_nearest_to_ray(PBVH *pbvh,
BKE_pbvh_bmesh_check_tris(pbvh, node);
PBVHTriBuf *tribuf = node->tribuf;
const int cd_dyn_vert = pbvh->cd_dyn_vert;
const int cd_sculpt_vert = pbvh->cd_sculpt_vert;
for (int i = 0; i < tribuf->tottri; i++) {
PBVHTri *tri = tribuf->tris + i;
@ -1042,9 +1042,9 @@ bool pbvh_bmesh_node_nearest_to_ray(PBVH *pbvh,
BKE_pbvh_bmesh_check_origdata(pbvh, v2, stroke_id);
BKE_pbvh_bmesh_check_origdata(pbvh, v3, stroke_id);
co1 = BKE_PBVH_DYNVERT(cd_dyn_vert, v1)->origco;
co2 = BKE_PBVH_DYNVERT(cd_dyn_vert, v2)->origco;
co3 = BKE_PBVH_DYNVERT(cd_dyn_vert, v3)->origco;
co1 = BKE_PBVH_SCULPTVERT(cd_sculpt_vert, v1)->origco;
co2 = BKE_PBVH_SCULPTVERT(cd_sculpt_vert, v2)->origco;
co3 = BKE_PBVH_SCULPTVERT(cd_sculpt_vert, v3)->origco;
}
else {
co1 = v1->co;
@ -1062,7 +1062,7 @@ typedef struct UpdateNormalsTaskData {
PBVHNode *node;
BMVert **border_verts;
int tot_border_verts;
int cd_dyn_vert;
int cd_sculpt_vert;
int cd_vert_node_offset;
int node_nr;
} UpdateNormalsTaskData;
@ -1083,9 +1083,9 @@ static void pbvh_update_normals_task_cb(void *__restrict userdata,
node->flag |= PBVH_UpdateCurvatureDir;
TGSET_ITER (v, node->bm_unique_verts) {
MDynTopoVert *mv = BKE_PBVH_DYNVERT(data->cd_dyn_vert, v);
MSculptVert *mv = BKE_PBVH_SCULPTVERT(data->cd_sculpt_vert, v);
int ni2 = BM_ELEM_CD_GET_INT(v, data->cd_vert_node_offset);
bool bad = ni2 != node_nr || (mv->flag & DYNVERT_PBVH_BOUNDARY);
bool bad = ni2 != node_nr || (mv->flag & SCULPTVERT_PBVH_BOUNDARY);
if (bad) {
BLI_array_append(bordervs, v);
@ -1100,9 +1100,9 @@ static void pbvh_update_normals_task_cb(void *__restrict userdata,
BM_face_normal_update(f);
BMLoop *l = f->l_first;
do {
MDynTopoVert *mv = BKE_PBVH_DYNVERT(data->cd_dyn_vert, l->v);
MSculptVert *mv = BKE_PBVH_SCULPTVERT(data->cd_sculpt_vert, l->v);
int ni2 = BM_ELEM_CD_GET_INT(l->v, data->cd_vert_node_offset);
bool bad = ni2 != node_nr || (mv->flag & DYNVERT_PBVH_BOUNDARY);
bool bad = ni2 != node_nr || (mv->flag & SCULPTVERT_PBVH_BOUNDARY);
if (!bad) {
add_v3_v3(l->v->no, f->no);
@ -1112,9 +1112,9 @@ static void pbvh_update_normals_task_cb(void *__restrict userdata,
TGSET_ITER_END
TGSET_ITER (v, node->bm_unique_verts) {
MDynTopoVert *mv = BKE_PBVH_DYNVERT(data->cd_dyn_vert, v);
MSculptVert *mv = BKE_PBVH_SCULPTVERT(data->cd_sculpt_vert, v);
int ni2 = BM_ELEM_CD_GET_INT(v, data->cd_vert_node_offset);
bool bad = ni2 != node_nr || (mv->flag & DYNVERT_PBVH_BOUNDARY);
bool bad = ni2 != node_nr || (mv->flag & SCULPTVERT_PBVH_BOUNDARY);
if (!bad) {
normalize_v3(v->no);
@ -1136,7 +1136,7 @@ void pbvh_bmesh_normals_update(PBVH *pbvh, PBVHNode **nodes, int totnode)
for (int i = 0; i < totnode; i++) {
datas[i].node = nodes[i];
datas[i].cd_dyn_vert = pbvh->cd_dyn_vert;
datas[i].cd_sculpt_vert = pbvh->cd_sculpt_vert;
datas[i].cd_vert_node_offset = pbvh->cd_vert_node_offset;
datas[i].node_nr = nodes[i] - pbvh->nodes;
}
@ -1488,7 +1488,7 @@ static int color_boundary_key(float col[4])
}
#endif
void bke_pbvh_update_vert_boundary(int cd_dyn_vert,
void bke_pbvh_update_vert_boundary(int cd_sculpt_vert,
int cd_faceset_offset,
int cd_vert_node_offset,
int cd_face_node_offset,
@ -1496,16 +1496,16 @@ void bke_pbvh_update_vert_boundary(int cd_dyn_vert,
BMVert *v,
int bound_symmetry)
{
MDynTopoVert *mv = BKE_PBVH_DYNVERT(cd_dyn_vert, v);
MSculptVert *mv = BKE_PBVH_SCULPTVERT(cd_sculpt_vert, v);
BMEdge *e = v->e;
mv->flag &= ~(DYNVERT_BOUNDARY | DYNVERT_FSET_BOUNDARY | DYNVERT_NEED_BOUNDARY |
DYNVERT_NEED_TRIANGULATE | DYNVERT_FSET_CORNER | DYNVERT_CORNER |
DYNVERT_NEED_VALENCE | DYNVERT_SEAM_BOUNDARY | DYNVERT_SHARP_BOUNDARY |
DYNVERT_SEAM_CORNER | DYNVERT_SHARP_CORNER | DYNVERT_PBVH_BOUNDARY);
mv->flag &= ~(SCULPTVERT_BOUNDARY | SCULPTVERT_FSET_BOUNDARY | SCULPTVERT_NEED_BOUNDARY |
SCULPTVERT_NEED_TRIANGULATE | SCULPTVERT_FSET_CORNER | SCULPTVERT_CORNER |
SCULPTVERT_NEED_VALENCE | SCULPTVERT_SEAM_BOUNDARY | SCULPTVERT_SHARP_BOUNDARY |
SCULPTVERT_SEAM_CORNER | SCULPTVERT_SHARP_CORNER | SCULPTVERT_PBVH_BOUNDARY);
if (!e) {
mv->flag |= DYNVERT_BOUNDARY;
mv->flag |= SCULPTVERT_BOUNDARY;
mv->valence = 0;
return;
}
@ -1536,15 +1536,15 @@ void bke_pbvh_update_vert_boundary(int cd_dyn_vert,
BMVert *v2 = v == e->v1 ? e->v2 : e->v1;
if (BM_ELEM_CD_GET_INT(v2, cd_vert_node_offset) != ni) {
mv->flag |= DYNVERT_PBVH_BOUNDARY;
mv->flag |= SCULPTVERT_PBVH_BOUNDARY;
}
if (e->head.hflag & BM_ELEM_SEAM) {
mv->flag |= DYNVERT_SEAM_BOUNDARY;
mv->flag |= SCULPTVERT_SEAM_BOUNDARY;
seamcount++;
if (seamcount > 2) {
mv->flag |= DYNVERT_SEAM_CORNER;
mv->flag |= SCULPTVERT_SEAM_CORNER;
}
}
@ -1557,23 +1557,23 @@ void bke_pbvh_update_vert_boundary(int cd_dyn_vert,
int colorkey2 = color_boundary_key(color2);
if (colorkey1 != colorkey2) {
mv->flag |= DYNVERT_FSET_BOUNDARY;
mv->flag |= SCULPTVERT_FSET_BOUNDARY;
}
}
#endif
if (!(e->head.hflag & BM_ELEM_SMOOTH)) {
mv->flag |= DYNVERT_SHARP_BOUNDARY;
mv->flag |= SCULPTVERT_SHARP_BOUNDARY;
sharpcount++;
if (sharpcount > 2) {
mv->flag |= DYNVERT_SHARP_CORNER;
mv->flag |= SCULPTVERT_SHARP_CORNER;
}
}
if (e->l) {
if (BM_ELEM_CD_GET_INT(e->l->f, cd_face_node_offset) != ni) {
mv->flag |= DYNVERT_PBVH_BOUNDARY;
mv->flag |= SCULPTVERT_PBVH_BOUNDARY;
}
if (e->l != e->l->radial_next) {
@ -1586,7 +1586,7 @@ void bke_pbvh_update_vert_boundary(int cd_dyn_vert,
}
if (BM_ELEM_CD_GET_INT(e->l->radial_next->f, cd_face_node_offset) != ni) {
mv->flag |= DYNVERT_PBVH_BOUNDARY;
mv->flag |= SCULPTVERT_PBVH_BOUNDARY;
}
}
@ -1594,7 +1594,7 @@ void bke_pbvh_update_vert_boundary(int cd_dyn_vert,
BM_ELEM_CD_GET_INT(e->l->f, cd_faceset_offset), bound_symmetry, v2->co);
if (e->l->f->len > 3) {
mv->flag |= DYNVERT_NEED_TRIANGULATE;
mv->flag |= SCULPTVERT_NEED_TRIANGULATE;
}
bool ok = true;
@ -1627,37 +1627,37 @@ void bke_pbvh_update_vert_boundary(int cd_dyn_vert,
}
if (e->l->radial_next->f->len > 3) {
mv->flag |= DYNVERT_NEED_TRIANGULATE;
mv->flag |= SCULPTVERT_NEED_TRIANGULATE;
}
}
}
if (!e->l || e->l->radial_next == e->l) {
mv->flag |= DYNVERT_BOUNDARY;
mv->flag |= SCULPTVERT_BOUNDARY;
}
val++;
} while ((e = BM_DISK_EDGE_NEXT(e, v)) != v->e);
if (BLI_array_len(fsets) > 1) {
mv->flag |= DYNVERT_FSET_BOUNDARY;
mv->flag |= SCULPTVERT_FSET_BOUNDARY;
}
if (BLI_array_len(fsets) > 2) {
mv->flag |= DYNVERT_FSET_CORNER;
mv->flag |= SCULPTVERT_FSET_CORNER;
}
if (sharpcount == 1) {
mv->flag |= DYNVERT_SHARP_CORNER;
mv->flag |= SCULPTVERT_SHARP_CORNER;
}
if (seamcount == 1) {
mv->flag |= DYNVERT_SEAM_CORNER;
mv->flag |= SCULPTVERT_SEAM_CORNER;
}
mv->valence = val;
if ((mv->flag & DYNVERT_BOUNDARY) && quadcount >= 3) {
mv->flag |= DYNVERT_CORNER;
if ((mv->flag & SCULPTVERT_BOUNDARY) && quadcount >= 3) {
mv->flag |= SCULPTVERT_CORNER;
}
BLI_array_free(fsets);
@ -1668,7 +1668,7 @@ bool BKE_pbvh_check_vert_boundary(PBVH *pbvh, BMVert *v)
return pbvh_check_vert_boundary(pbvh, v);
}
void BKE_pbvh_update_vert_boundary(int cd_dyn_vert,
void BKE_pbvh_update_vert_boundary(int cd_sculpt_vert,
int cd_faceset_offset,
int cd_vert_node_offset,
int cd_face_node_offset,
@ -1676,7 +1676,7 @@ void BKE_pbvh_update_vert_boundary(int cd_dyn_vert,
BMVert *v,
int bound_symmetry)
{
bke_pbvh_update_vert_boundary(cd_dyn_vert,
bke_pbvh_update_vert_boundary(cd_sculpt_vert,
cd_faceset_offset,
cd_vert_node_offset,
cd_face_node_offset,
@ -1692,7 +1692,7 @@ void BKE_pbvh_recalc_bmesh_boundary(PBVH *pbvh)
BMIter iter;
BM_ITER_MESH (v, &iter, pbvh->bm, BM_VERTS_OF_MESH) {
bke_pbvh_update_vert_boundary(pbvh->cd_dyn_vert,
bke_pbvh_update_vert_boundary(pbvh->cd_sculpt_vert,
pbvh->cd_faceset_offset,
pbvh->cd_vert_node_offset,
pbvh->cd_face_node_offset,
@ -1714,22 +1714,22 @@ void BKE_pbvh_update_all_boundary_bmesh(PBVH *pbvh)
const int cd_fset = CustomData_get_offset(&pbvh->bm->pdata, CD_SCULPT_FACE_SETS);
BM_ITER_MESH (v, &iter, pbvh->bm, BM_VERTS_OF_MESH) {
MDynTopoVert *mv = BKE_PBVH_DYNVERT(pbvh->cd_dyn_vert, v);
mv->flag &= ~(DYNVERT_BOUNDARY | DYNVERT_FSET_BOUNDARY | DYNVERT_NEED_BOUNDARY |
DYNVERT_VERT_FSET_HIDDEN);
MSculptVert *mv = BKE_PBVH_SCULPTVERT(pbvh->cd_sculpt_vert, v);
mv->flag &= ~(SCULPTVERT_BOUNDARY | SCULPTVERT_FSET_BOUNDARY | SCULPTVERT_NEED_BOUNDARY |
SCULPTVERT_VERT_FSET_HIDDEN);
if (cd_fset >= 0 && v->e && v->e->l) {
mv->flag |= DYNVERT_VERT_FSET_HIDDEN;
mv->flag |= SCULPTVERT_VERT_FSET_HIDDEN;
}
}
BM_ITER_MESH (e, &iter, pbvh->bm, BM_EDGES_OF_MESH) {
if (!e->l || e->l == e->l->radial_next) {
MDynTopoVert *mv1 = BKE_PBVH_DYNVERT(pbvh->cd_dyn_vert, e->v1);
MDynTopoVert *mv2 = BKE_PBVH_DYNVERT(pbvh->cd_dyn_vert, e->v2);
MSculptVert *mv1 = BKE_PBVH_SCULPTVERT(pbvh->cd_sculpt_vert, e->v1);
MSculptVert *mv2 = BKE_PBVH_SCULPTVERT(pbvh->cd_sculpt_vert, e->v2);
mv1->flag |= DYNVERT_BOUNDARY;
mv2->flag |= DYNVERT_BOUNDARY;
mv1->flag |= SCULPTVERT_BOUNDARY;
mv2->flag |= SCULPTVERT_BOUNDARY;
}
if (!e->l) {
@ -1737,15 +1737,15 @@ void BKE_pbvh_update_all_boundary_bmesh(PBVH *pbvh)
}
if (cd_fset < 0) {
MDynTopoVert *mv1 = BKE_PBVH_DYNVERT(pbvh->cd_dyn_vert, e->v1);
MDynTopoVert *mv2 = BKE_PBVH_DYNVERT(pbvh->cd_dyn_vert, e->v2);
MSculptVert *mv1 = BKE_PBVH_SCULPTVERT(pbvh->cd_sculpt_vert, e->v1);
MSculptVert *mv2 = BKE_PBVH_SCULPTVERT(pbvh->cd_sculpt_vert, e->v2);
BMLoop *l = e->l;
do {
if (l->f->len > 3) {
mv1->flag |= DYNVERT_NEED_TRIANGULATE;
mv2->flag |= DYNVERT_NEED_TRIANGULATE;
mv1->flag |= SCULPTVERT_NEED_TRIANGULATE;
mv2->flag |= SCULPTVERT_NEED_TRIANGULATE;
break;
}
@ -1754,8 +1754,8 @@ void BKE_pbvh_update_all_boundary_bmesh(PBVH *pbvh)
continue;
}
MDynTopoVert *mv1 = BKE_PBVH_DYNVERT(pbvh->cd_dyn_vert, e->v1);
MDynTopoVert *mv2 = BKE_PBVH_DYNVERT(pbvh->cd_dyn_vert, e->v2);
MSculptVert *mv1 = BKE_PBVH_SCULPTVERT(pbvh->cd_sculpt_vert, e->v1);
MSculptVert *mv2 = BKE_PBVH_SCULPTVERT(pbvh->cd_sculpt_vert, e->v2);
BMLoop *l = e->l;
int lastfset = BM_ELEM_CD_GET_INT(l->f, cd_fset);
@ -1763,18 +1763,18 @@ void BKE_pbvh_update_all_boundary_bmesh(PBVH *pbvh)
int fset = BM_ELEM_CD_GET_INT(l->f, cd_fset);
if (l->f->len > 3) {
mv1->flag |= DYNVERT_NEED_TRIANGULATE;
mv2->flag |= DYNVERT_NEED_TRIANGULATE;
mv1->flag |= SCULPTVERT_NEED_TRIANGULATE;
mv2->flag |= SCULPTVERT_NEED_TRIANGULATE;
}
if (fset > 0) {
MDynTopoVert *mv = BKE_PBVH_DYNVERT(pbvh->cd_dyn_vert, l->v);
mv->flag &= ~DYNVERT_VERT_FSET_HIDDEN;
MSculptVert *mv = BKE_PBVH_SCULPTVERT(pbvh->cd_sculpt_vert, l->v);
mv->flag &= ~SCULPTVERT_VERT_FSET_HIDDEN;
}
if (lastfset != fset) {
mv1->flag |= DYNVERT_FSET_BOUNDARY;
mv2->flag |= DYNVERT_FSET_BOUNDARY;
mv1->flag |= SCULPTVERT_FSET_BOUNDARY;
mv2->flag |= SCULPTVERT_FSET_BOUNDARY;
}
lastfset = fset;
@ -1790,7 +1790,7 @@ void BKE_pbvh_build_bmesh(PBVH *pbvh,
BMLog *log,
const int cd_vert_node_offset,
const int cd_face_node_offset,
const int cd_dyn_vert,
const int cd_sculpt_vert,
const int cd_face_areas,
bool fast_draw)
{
@ -1798,7 +1798,7 @@ void BKE_pbvh_build_bmesh(PBVH *pbvh,
pbvh->cd_vert_node_offset = cd_vert_node_offset;
pbvh->cd_face_node_offset = cd_face_node_offset;
pbvh->cd_vert_mask_offset = CustomData_get_offset(&bm->vdata, CD_PAINT_MASK);
pbvh->cd_dyn_vert = cd_dyn_vert;
pbvh->cd_sculpt_vert = cd_sculpt_vert;
smooth_shading |= fast_draw;
@ -1883,18 +1883,18 @@ void BKE_pbvh_build_bmesh(PBVH *pbvh,
MEM_freeN(nodeinfo);
BM_ITER_MESH (v, &iter, bm, BM_VERTS_OF_MESH) {
MDynTopoVert *mv = BKE_PBVH_DYNVERT(cd_dyn_vert, v);
MSculptVert *mv = BKE_PBVH_SCULPTVERT(cd_sculpt_vert, v);
mv->flag = DYNVERT_NEED_DISK_SORT;
mv->flag = SCULPTVERT_NEED_DISK_SORT;
bke_pbvh_update_vert_boundary(pbvh->cd_dyn_vert,
bke_pbvh_update_vert_boundary(pbvh->cd_sculpt_vert,
pbvh->cd_faceset_offset,
pbvh->cd_vert_node_offset,
pbvh->cd_face_node_offset,
pbvh->cd_vcol_offset,
v,
pbvh->boundary_symmetry);
BKE_pbvh_bmesh_update_valence(pbvh->cd_dyn_vert, (SculptVertRef){(intptr_t)v});
BKE_pbvh_bmesh_update_valence(pbvh->cd_sculpt_vert, (SculptVertRef){(intptr_t)v});
copy_v3_v3(mv->origco, v->co);
copy_v3_v3(mv->origno, v->no);
@ -2509,8 +2509,8 @@ void BKE_pbvh_bmesh_flag_all_disk_sort(PBVH *pbvh)
BMIter iter;
BM_ITER_MESH (v, &iter, pbvh->bm, BM_VERTS_OF_MESH) {
MDynTopoVert *mv = BKE_PBVH_DYNVERT(pbvh->cd_dyn_vert, v);
mv->flag |= DYNVERT_NEED_DISK_SORT;
MSculptVert *mv = BKE_PBVH_SCULPTVERT(pbvh->cd_sculpt_vert, v);
mv->flag |= SCULPTVERT_NEED_DISK_SORT;
}
}
@ -2520,7 +2520,7 @@ void BKE_pbvh_bmesh_update_all_valence(PBVH *pbvh)
BMVert *v;
BM_ITER_MESH (v, &iter, pbvh->bm, BM_VERTS_OF_MESH) {
BKE_pbvh_bmesh_update_valence(pbvh->cd_dyn_vert, (SculptVertRef){(intptr_t)v});
BKE_pbvh_bmesh_update_valence(pbvh->cd_sculpt_vert, (SculptVertRef){(intptr_t)v});
}
}
@ -2537,24 +2537,25 @@ void BKE_pbvh_bmesh_on_mesh_change(PBVH *pbvh)
}
}
const int cd_dyn_vert = pbvh->cd_dyn_vert;
const int cd_sculpt_vert = pbvh->cd_sculpt_vert;
BM_ITER_MESH (v, &iter, pbvh->bm, BM_VERTS_OF_MESH) {
MDynTopoVert *mv = BKE_PBVH_DYNVERT(cd_dyn_vert, v);
MSculptVert *mv = BKE_PBVH_SCULPTVERT(cd_sculpt_vert, v);
MV_ADD_FLAG(mv, DYNVERT_NEED_BOUNDARY | DYNVERT_NEED_DISK_SORT | DYNVERT_NEED_TRIANGULATE);
BKE_pbvh_bmesh_update_valence(pbvh->cd_dyn_vert, (SculptVertRef){.i = (intptr_t)v});
MV_ADD_FLAG(
mv, SCULPTVERT_NEED_BOUNDARY | SCULPTVERT_NEED_DISK_SORT | SCULPTVERT_NEED_TRIANGULATE);
BKE_pbvh_bmesh_update_valence(pbvh->cd_sculpt_vert, (SculptVertRef){.i = (intptr_t)v});
}
}
bool BKE_pbvh_bmesh_mark_update_valence(PBVH *pbvh, SculptVertRef vertex)
{
BMVert *v = (BMVert *)vertex.i;
MDynTopoVert *mv = BM_ELEM_CD_GET_VOID_P(v, pbvh->cd_dyn_vert);
MSculptVert *mv = BM_ELEM_CD_GET_VOID_P(v, pbvh->cd_sculpt_vert);
bool ret = mv->flag & DYNVERT_NEED_VALENCE;
bool ret = mv->flag & SCULPTVERT_NEED_VALENCE;
mv->flag |= DYNVERT_NEED_VALENCE;
mv->flag |= SCULPTVERT_NEED_VALENCE;
return ret;
}
@ -2562,24 +2563,24 @@ bool BKE_pbvh_bmesh_mark_update_valence(PBVH *pbvh, SculptVertRef vertex)
bool BKE_pbvh_bmesh_check_valence(PBVH *pbvh, SculptVertRef vertex)
{
BMVert *v = (BMVert *)vertex.i;
MDynTopoVert *mv = BM_ELEM_CD_GET_VOID_P(v, pbvh->cd_dyn_vert);
MSculptVert *mv = BM_ELEM_CD_GET_VOID_P(v, pbvh->cd_sculpt_vert);
if (mv->flag & DYNVERT_NEED_VALENCE) {
BKE_pbvh_bmesh_update_valence(pbvh->cd_dyn_vert, vertex);
if (mv->flag & SCULPTVERT_NEED_VALENCE) {
BKE_pbvh_bmesh_update_valence(pbvh->cd_sculpt_vert, vertex);
return true;
}
return false;
}
void BKE_pbvh_bmesh_update_valence(int cd_dyn_vert, SculptVertRef vertex)
void BKE_pbvh_bmesh_update_valence(int cd_sculpt_vert, SculptVertRef vertex)
{
BMVert *v = (BMVert *)vertex.i;
BMEdge *e;
MDynTopoVert *mv = BM_ELEM_CD_GET_VOID_P(v, cd_dyn_vert);
MSculptVert *mv = BM_ELEM_CD_GET_VOID_P(v, cd_sculpt_vert);
mv->flag &= ~DYNVERT_NEED_VALENCE;
mv->flag &= ~SCULPTVERT_NEED_VALENCE;
if (!v->e) {
mv->valence = 0;
@ -2635,8 +2636,8 @@ static void pbvh_bmesh_join_subnodes(PBVH *pbvh, PBVHNode *node, PBVHNode *paren
TGSET_ITER (v, node->bm_unique_verts) {
BLI_table_gset_add(parent->bm_unique_verts, v);
MDynTopoVert *mv = BKE_PBVH_DYNVERT(pbvh->cd_dyn_vert, v);
MV_ADD_FLAG(mv, DYNVERT_NEED_BOUNDARY); // need to update DYNVERT_PBVH_BOUNDARY flags
MSculptVert *mv = BKE_PBVH_SCULPTVERT(pbvh->cd_sculpt_vert, v);
MV_ADD_FLAG(mv, SCULPTVERT_NEED_BOUNDARY); // need to update SCULPTVERT_PBVH_BOUNDARY flags
BM_ELEM_CD_SET_INT(v, pbvh->cd_vert_node_offset, DYNTOPO_NODE_NONE);
}
@ -3070,8 +3071,8 @@ static void pbvh_bmesh_balance_tree(PBVH *pbvh)
TGSET_ITER_END;
TGSET_ITER (v, node2->bm_unique_verts) {
MDynTopoVert *mv = BKE_PBVH_DYNVERT(pbvh->cd_dyn_vert, v);
MV_ADD_FLAG(mv, DYNVERT_NEED_BOUNDARY);
MSculptVert *mv = BKE_PBVH_SCULPTVERT(pbvh->cd_sculpt_vert, v);
MV_ADD_FLAG(mv, SCULPTVERT_NEED_BOUNDARY);
BM_ELEM_CD_SET_INT(v, cd_vert_node, DYNTOPO_NODE_NONE);
}
@ -3397,7 +3398,7 @@ struct TableGSet *BKE_pbvh_bmesh_node_faces(PBVHNode *node)
void BKE_pbvh_update_offsets(PBVH *pbvh,
const int cd_vert_node_offset,
const int cd_face_node_offset,
const int cd_dyn_vert,
const int cd_sculpt_vert,
const int cd_face_areas)
{
if (pbvh->bm) {
@ -3409,7 +3410,7 @@ void BKE_pbvh_update_offsets(PBVH *pbvh,
pbvh->cd_face_area = cd_face_areas;
pbvh->cd_vert_mask_offset = CustomData_get_offset(&pbvh->bm->vdata, CD_PAINT_MASK);
pbvh->cd_vcol_offset = CustomData_get_offset(&pbvh->bm->vdata, CD_PROP_COLOR);
pbvh->cd_dyn_vert = cd_dyn_vert;
pbvh->cd_sculpt_vert = cd_sculpt_vert;
pbvh->cd_faceset_offset = CustomData_get_offset(&pbvh->bm->pdata, CD_SCULPT_FACE_SETS);
}
@ -5023,8 +5024,8 @@ void pbvh_bmesh_cache_test(CacheParams *params, BMesh **r_bm, PBVH **r_pbvh_out)
cd_face_node = bm->pdata.layers[cd_face_node].offset;
cd_face_area = bm->pdata.layers[cd_face_area].offset;
const int cd_dyn_vert = CustomData_get_offset(&bm->vdata, CD_DYNTOPO_VERT);
BMLog *bmlog = BM_log_create(bm, cd_dyn_vert);
const int cd_sculpt_vert = CustomData_get_offset(&bm->vdata, CD_DYNTOPO_VERT);
BMLog *bmlog = BM_log_create(bm, cd_sculpt_vert);
PBVH *pbvh = BKE_pbvh_new();
@ -5034,7 +5035,7 @@ void pbvh_bmesh_cache_test(CacheParams *params, BMesh **r_bm, PBVH **r_pbvh_out)
BM_mesh_elem_index_ensure(bm, BM_VERT | BM_EDGE | BM_FACE);
BKE_pbvh_build_bmesh(
pbvh, bm, false, bmlog, cd_vert_node, cd_face_node, cd_dyn_vert, cd_face_area, false);
pbvh, bm, false, bmlog, cd_vert_node, cd_face_node, cd_sculpt_vert, cd_face_area, false);
int loop_size = sizeof(BMLoop) - sizeof(void *) * 4;
@ -5435,7 +5436,7 @@ static void pbvh_bmesh_fetch_cdrefs(PBVH *pbvh)
pbvh->cd_vert_mask_offset = CustomData_get_offset(&bm->vdata, CD_PAINT_MASK);
pbvh->cd_vcol_offset = CustomData_get_offset(&bm->vdata, CD_PROP_COLOR);
pbvh->cd_faceset_offset = CustomData_get_offset(&bm->pdata, CD_SCULPT_FACE_SETS);
pbvh->cd_dyn_vert = CustomData_get_offset(&bm->vdata, CD_DYNTOPO_VERT);
pbvh->cd_sculpt_vert = CustomData_get_offset(&bm->vdata, CD_DYNTOPO_VERT);
}
void BKE_pbvh_bmesh_set_toolflags(PBVH *pbvh, bool use_toolflags)

14
source/blender/blenkernel/intern/pbvh_intern.h
View File

@ -26,7 +26,7 @@
/** \file
* \ingroup bli
*/
struct MDynTopoVert;
struct MSculptVert;
/* Axis-aligned bounding box */
typedef struct {
@ -159,7 +159,7 @@ struct PBVH {
MVert *verts;
const MPoly *mpoly;
const MLoop *mloop;
struct MDynTopoVert *mdyntopo_verts;
struct MSculptVert *mdyntopo_verts;
const MLoopTri *looptri;
CustomData *vdata;
CustomData *ldata;
@ -197,7 +197,7 @@ struct PBVH {
float bm_min_edge_len;
float bm_detail_range;
int cd_dyn_vert;
int cd_sculpt_vert;
int cd_vert_node_offset;
int cd_face_node_offset;
int cd_vert_mask_offset;
@ -336,7 +336,7 @@ bool pbvh_bmesh_node_limit_ensure(PBVH *pbvh, int node_index);
void pbvh_bmesh_check_nodes(PBVH *pbvh);
void bke_pbvh_insert_face_finalize(PBVH *pbvh, BMFace *f, const int ni);
void bke_pbvh_insert_face(PBVH *pbvh, struct BMFace *f);
void bke_pbvh_update_vert_boundary(int cd_dyn_vert,
void bke_pbvh_update_vert_boundary(int cd_sculpt_vert,
int cd_faceset_offset,
int cd_vert_node_offset,
int cd_face_node_offset,
@ -346,10 +346,10 @@ void bke_pbvh_update_vert_boundary(int cd_dyn_vert,
BLI_INLINE bool pbvh_check_vert_boundary(PBVH *pbvh, struct BMVert *v)
{
MDynTopoVert *mv = (MDynTopoVert *)BM_ELEM_CD_GET_VOID_P(v, pbvh->cd_dyn_vert);
MSculptVert *mv = (MSculptVert *)BM_ELEM_CD_GET_VOID_P(v, pbvh->cd_sculpt_vert);
if (mv->flag & DYNVERT_NEED_BOUNDARY) {
bke_pbvh_update_vert_boundary(pbvh->cd_dyn_vert,
if (mv->flag & SCULPTVERT_NEED_BOUNDARY) {
bke_pbvh_update_vert_boundary(pbvh->cd_sculpt_vert,
pbvh->cd_faceset_offset,
pbvh->cd_vert_node_offset,
pbvh->cd_face_node_offset,

12
source/blender/bmesh/intern/bmesh_log.c
View File

@ -285,7 +285,7 @@ struct BMLog {
BMLogEntry *current_entry;
bool has_edges;
int cd_dyn_vert;
int cd_sculpt_vert;
bool dead;
};
@ -1386,9 +1386,9 @@ static GHash *bm_log_compress_ids_to_indices(uint *ids, uint totid)
/***************************** Public API *****************************/
void BM_log_set_cd_offsets(BMLog *log, int cd_dyn_vert)
void BM_log_set_cd_offsets(BMLog *log, int cd_sculpt_vert)
{
log->cd_dyn_vert = cd_dyn_vert;
log->cd_sculpt_vert = cd_sculpt_vert;
}
void BM_log_set_bm(BMesh *bm, BMLog *log)
@ -1397,13 +1397,13 @@ void BM_log_set_bm(BMesh *bm, BMLog *log)
}
/* Allocate, initialize, and assign a new BMLog */
BMLog *BM_log_create(BMesh *bm, int cd_dyn_vert)
BMLog *BM_log_create(BMesh *bm, int cd_sculpt_vert)
{
BMLog *log = MEM_callocN(sizeof(*log), __func__);
BLI_rw_mutex_init(&log->lock);
BM_log_set_cd_offsets(log, cd_dyn_vert);
BM_log_set_cd_offsets(log, cd_sculpt_vert);
return log;
}
@ -2940,7 +2940,7 @@ const float *BM_log_original_vert_no(BMLog *log, BMVert *v)
* Does not modify the log or the vertex */
float BM_log_original_mask(BMLog *log, BMVert *v)
{
MDynTopoVert *mv = BM_ELEM_CD_GET_VOID_P(v, log->cd_dyn_vert);
MSculptVert *mv = BM_ELEM_CD_GET_VOID_P(v, log->cd_sculpt_vert);
return mv->origmask;
}

4
source/blender/bmesh/intern/bmesh_log.h
View File

@ -47,8 +47,8 @@ typedef struct BMLogCallbacks {
} BMLogCallbacks;
/* Allocate and initialize a new BMLog */
BMLog *BM_log_create(BMesh *bm, int cd_dyn_vert);
void BM_log_set_cd_offsets(BMLog *log, int cd_dyn_vert);
BMLog *BM_log_create(BMesh *bm, int cd_sculpt_vert);
void BM_log_set_cd_offsets(BMLog *log, int cd_sculpt_vert);
/* Allocate and initialize a new BMLog using existing BMLogEntries */
BMLog *BM_log_from_existing_entries_create(BMesh *bm, BMLogEntry *entry);

2
source/blender/editors/sculpt_paint/paint_mask.c
View File

@ -1357,7 +1357,7 @@ static void sculpt_gesture_apply_trim(SculptGestureContext *sgcontext)
sgcontext->ss->bm_log,
sgcontext->ss->cd_vert_node_offset,
sgcontext->ss->cd_face_node_offset,
sgcontext->ss->cd_dyn_vert,
sgcontext->ss->cd_sculpt_vert,
sgcontext->ss->cd_face_areas,
sgcontext->ss->fast_draw);
}

1127
source/blender/editors/sculpt_paint/sculpt.c
View File

File diff suppressed because it is too large Load Diff

4
source/blender/editors/sculpt_paint/sculpt_curvature.c
View File

@ -230,7 +230,7 @@ void SCULPT_curvature_dir_get(SculptSession *ss,
}
BMVert *bv = (BMVert *)v.i;
MDynTopoVert *mv = BKE_PBVH_DYNVERT(ss->cd_dyn_vert, bv);
MSculptVert *mv = BKE_PBVH_SCULPTVERT(ss->cd_sculpt_vert, bv);
copy_v3_v3(dir, mv->curvature_dir);
}
@ -249,7 +249,7 @@ void SCULPT_curvature_begin(SculptSession *ss, struct PBVHNode *node, bool useAc
BKE_pbvh_vertex_iter_begin (ss->pbvh, node, vi, PBVH_ITER_UNIQUE) {
BMVert *v = (BMVert *)vi.vertex.i;
MDynTopoVert *mv = BKE_PBVH_DYNVERT(ss->cd_dyn_vert, v);
MSculptVert *mv = BKE_PBVH_SCULPTVERT(ss->cd_sculpt_vert, v);
SculptCurvatureData curv;
SCULPT_calc_principle_curvatures(ss, vi.vertex, &curv, useAccurateSolver);

26
source/blender/editors/sculpt_paint/sculpt_dyntopo.c
View File

@ -359,10 +359,10 @@ void SCULT_dyntopo_flag_all_disk_sort(SculptSession *ss)
bool SCULPT_dyntopo_check_disk_sort(SculptSession *ss, SculptVertRef vertex)
{
BMVert *v = (BMVert *)vertex.i;
MDynTopoVert *mv = BKE_PBVH_DYNVERT(ss->cd_dyn_vert, v);
MSculptVert *mv = BKE_PBVH_SCULPTVERT(ss->cd_sculpt_vert, v);
if (mv->flag & DYNVERT_NEED_DISK_SORT) {
mv->flag &= ~DYNVERT_NEED_DISK_SORT;
if (mv->flag & SCULPTVERT_NEED_DISK_SORT) {
mv->flag &= ~SCULPTVERT_NEED_DISK_SORT;
BM_sort_disk_cycle(v);
@ -520,7 +520,7 @@ void SCULPT_dyntopo_save_origverts(SculptSession *ss)
BMVert *v;
BM_ITER_MESH (v, &iter, ss->bm, BM_VERTS_OF_MESH) {
MDynTopoVert *mv = BKE_PBVH_DYNVERT(ss->cd_dyn_vert, v);
MSculptVert *mv = BKE_PBVH_SCULPTVERT(ss->cd_sculpt_vert, v);
copy_v3_v3(mv->origco, v->co);
copy_v3_v3(mv->origno, v->no);
@ -541,11 +541,11 @@ void SCULPT_dyntopo_node_layers_update_offsets(SculptSession *ss)
BKE_pbvh_update_offsets(ss->pbvh,
ss->cd_vert_node_offset,
ss->cd_face_node_offset,
ss->cd_dyn_vert,
ss->cd_sculpt_vert,
ss->cd_face_areas);
}
if (ss->bm_log) {
BM_log_set_cd_offsets(ss->bm_log, ss->cd_dyn_vert);
BM_log_set_cd_offsets(ss->bm_log, ss->cd_sculpt_vert);
}
}
@ -614,7 +614,7 @@ void SCULPT_dyntopo_node_layers_add(SculptSession *ss)
ss->cd_origvcol_offset = -1;
ss->cd_dyn_vert = CustomData_get_offset(&ss->bm->vdata, CD_DYNTOPO_VERT);
ss->cd_sculpt_vert = CustomData_get_offset(&ss->bm->vdata, CD_DYNTOPO_VERT);
ss->cd_vcol_offset = CustomData_get_offset(&ss->bm->vdata, CD_PROP_COLOR);
@ -782,7 +782,7 @@ void SCULPT_dynamic_topology_enable_ex(Main *bmain, Depsgraph *depsgraph, Scene
/* also check bm_log */
if (!ss->bm_log) {
ss->bm_log = BM_log_create(ss->bm, ss->cd_dyn_vert);
ss->bm_log = BM_log_create(ss->bm, ss->cd_sculpt_vert);
}
return;
@ -862,18 +862,18 @@ void SCULPT_dynamic_topology_enable_ex(Main *bmain, Depsgraph *depsgraph, Scene
}
BM_ITER_MESH (v, &iter, ss->bm, BM_VERTS_OF_MESH) {
MDynTopoVert *mv = BKE_PBVH_DYNVERT(ss->cd_dyn_vert, v);
MSculptVert *mv = BKE_PBVH_SCULPTVERT(ss->cd_sculpt_vert, v);
mv->flag |= DYNVERT_NEED_DISK_SORT | DYNVERT_NEED_VALENCE;
mv->flag |= SCULPTVERT_NEED_DISK_SORT | SCULPTVERT_NEED_VALENCE;
BKE_pbvh_update_vert_boundary(ss->cd_dyn_vert,
BKE_pbvh_update_vert_boundary(ss->cd_sculpt_vert,
ss->cd_faceset_offset,
ss->cd_vert_node_offset,
ss->cd_face_node_offset,
ss->cd_vcol_offset,
v,
ss->boundary_symmetry);
BKE_pbvh_bmesh_update_valence(ss->cd_dyn_vert, (SculptVertRef){.i = (intptr_t)v});
BKE_pbvh_bmesh_update_valence(ss->cd_sculpt_vert, (SculptVertRef){.i = (intptr_t)v});
copy_v3_v3(mv->origco, v->co);
copy_v3_v3(mv->origno, v->no);
@ -896,7 +896,7 @@ void SCULPT_dynamic_topology_enable_ex(Main *bmain, Depsgraph *depsgraph, Scene
/* Enable logging for undo/redo. */
if (!ss->bm_log) {
ss->bm_log = BM_log_create(ss->bm, ss->cd_dyn_vert);
ss->bm_log = BM_log_create(ss->bm, ss->cd_sculpt_vert);
}
/* Update dependency graph, so modifiers that depend on dyntopo being enabled

28
source/blender/editors/sculpt_paint/sculpt_face_set.c
View File

@ -394,9 +394,9 @@ static void do_draw_face_sets_brush_task_cb_ex(void *__restrict userdata,
MVert *v = &ss->mvert[ml->v];
float fno[3];
MDynTopoVert *mv = ss->mdyntopo_verts + i;
MSculptVert *mv = ss->mdyntopo_verts + i;
MV_ADD_FLAG(mv, DYNVERT_NEED_BOUNDARY);
MV_ADD_FLAG(mv, SCULPTVERT_NEED_BOUNDARY);
normal_short_to_float_v3(fno, v->no);
float mask = ss->vmask ? ss->vmask[ml->v] : 0.0f;
@ -493,8 +493,8 @@ static void do_draw_face_sets_brush_task_cb_ex(void *__restrict userdata,
break;
}
MDynTopoVert *mv = BKE_PBVH_DYNVERT(ss->cd_dyn_vert, l->v);
MV_ADD_FLAG(mv, DYNVERT_NEED_BOUNDARY);
MSculptVert *mv = BKE_PBVH_SCULPTVERT(ss->cd_sculpt_vert, l->v);
MV_ADD_FLAG(mv, SCULPTVERT_NEED_BOUNDARY);
} while ((l = l->next) != f->l_first);
if (ok) {
@ -2106,8 +2106,8 @@ static void sculpt_face_set_extrude_id(Object *ob,
BM_mesh_select_mode_set(bm, SCE_SELECT_FACE);
int mupdateflag = DYNVERT_NEED_BOUNDARY | DYNVERT_NEED_DISK_SORT | DYNVERT_NEED_TRIANGULATE |
DYNVERT_NEED_VALENCE;
int mupdateflag = SCULPTVERT_NEED_BOUNDARY | SCULPTVERT_NEED_DISK_SORT |
SCULPTVERT_NEED_TRIANGULATE | SCULPTVERT_NEED_VALENCE;
BMVert **retvs = NULL;
BMVert **vs = NULL;
@ -2265,7 +2265,7 @@ static void sculpt_face_set_extrude_id(Object *ob,
sculpt_bm_mesh_elem_hflag_disable_all(
bm, BM_ALL_NOLOOP, BM_ELEM_SELECT | BM_ELEM_TAG_ALT | BM_ELEM_TAG);
int cd_dyn_vert = CustomData_get_offset(&bm->vdata, CD_DYNTOPO_VERT);
int cd_sculpt_vert = CustomData_get_offset(&bm->vdata, CD_DYNTOPO_VERT);
cd_faceset_offset = CustomData_get_offset(
&bm->pdata, CD_SCULPT_FACE_SETS); // recalc in case bmop changed it
@ -2351,10 +2351,10 @@ static void sculpt_face_set_extrude_id(Object *ob,
case BM_FACE: {
BMFace *f = (BMFace *)ele;
if (cd_dyn_vert != -1) {
if (cd_sculpt_vert != -1) {
BMLoop *l = f->l_first;
do {
MDynTopoVert *mv = BKE_PBVH_DYNVERT(cd_dyn_vert, l->v);
MSculptVert *mv = BKE_PBVH_SCULPTVERT(cd_sculpt_vert, l->v);
MV_ADD_FLAG(mv, mupdateflag);
} while ((l = l->next) != f->l_first);
}
@ -2393,10 +2393,10 @@ static void sculpt_face_set_extrude_id(Object *ob,
continue;
}
if (cd_dyn_vert >= 0) {
if (cd_sculpt_vert >= 0) {
BMLoop *l = f->l_first;
do {
MDynTopoVert *mv = BKE_PBVH_DYNVERT(cd_dyn_vert, l->v);
MSculptVert *mv = BKE_PBVH_SCULPTVERT(cd_sculpt_vert, l->v);
MV_ADD_FLAG(mv, mupdateflag);
} while ((l = l->next) != f->l_first);
}
@ -2422,14 +2422,14 @@ static void sculpt_face_set_extrude_id(Object *ob,
continue;
}
const int cd_dyn_vert = CustomData_get_offset(&bm->vdata, CD_DYNTOPO_VERT);
const int cd_sculpt_vert = CustomData_get_offset(&bm->vdata, CD_DYNTOPO_VERT);
BMLoop *l = f->l_first;
int count = 0;
do {
if (cd_dyn_vert >= 0) {
MDynTopoVert *mv = BM_ELEM_CD_GET_VOID_P(l->v, cd_dyn_vert);
if (cd_sculpt_vert >= 0) {
MSculptVert *mv = BM_ELEM_CD_GET_VOID_P(l->v, cd_sculpt_vert);
MV_ADD_FLAG(mv, mupdateflag);
}

6
source/blender/editors/sculpt_paint/sculpt_intern.h
View File

@ -238,7 +238,7 @@ float *SCULPT_vertex_origco_get(SculptSession *ss, SculptVertRef vertex);
float *SCULPT_vertex_origno_get(SculptSession *ss, SculptVertRef vertex);
void SCULPT_active_vertex_normal_get(SculptSession *ss, float normal[3]);
MDynTopoVert *SCULPT_vertex_get_mdyntopo(SculptSession *ss, SculptVertRef vertex);
MSculptVert *SCULPT_vertex_get_mdyntopo(SculptSession *ss, SculptVertRef vertex);
/* Returns PBVH deformed vertices array if shape keys or deform modifiers are used, otherwise
* returns mesh original vertices array. */
@ -747,7 +747,7 @@ void SCULPT_bmesh_four_neighbor_average(SculptSession *ss,
float projection,
bool check_fsets,
int cd_temp,
int cd_dyn_vert,
int cd_sculpt_vert,
bool do_origco);
/* Smoothing api */
@ -1056,7 +1056,7 @@ typedef struct SculptThreadedTaskData {
ThreadMutex mutex;
// Layer brush
int cd_temp, cd_dyn_vert;
int cd_temp, cd_sculpt_vert;
float smooth_projection;
float rake_projection;

15
source/blender/editors/sculpt_paint/sculpt_smooth.c
View File

@ -87,7 +87,7 @@ void SCULPT_neighbor_coords_average_interior(SculptSession *ss,
bool do_origco = args->do_origco;
SculptCustomLayer *bound_scl = args->bound_scl;
MDynTopoVert *mv = SCULPT_vertex_get_mdyntopo(ss, vertex);
MSculptVert *mv = SCULPT_vertex_get_mdyntopo(ss, vertex);
if (do_origco) {
SCULPT_vertex_check_origdata(ss, vertex);
@ -146,7 +146,7 @@ void SCULPT_neighbor_coords_average_interior(SculptSession *ss,
SculptVertexNeighborIter ni;
SCULPT_VERTEX_NEIGHBORS_ITER_BEGIN (ss, vertex, ni) {
MDynTopoVert *mv2 = SCULPT_vertex_get_mdyntopo(ss, ni.vertex);
MSculptVert *mv2 = SCULPT_vertex_get_mdyntopo(ss, ni.vertex);
const float *co2;
if (!do_origco || mv2->stroke_id != ss->stroke_id) {
@ -405,7 +405,7 @@ void SCULPT_bmesh_four_neighbor_average(SculptSession *ss,
float projection,
bool check_fsets,
int cd_temp,
int cd_dyn_vert,
int cd_sculpt_vert,
bool do_origco)
{
float avg_co[3] = {0.0f, 0.0f, 0.0f};
@ -415,7 +415,7 @@ void SCULPT_bmesh_four_neighbor_average(SculptSession *ss,
// zero_v3(direction);
MDynTopoVert *mv = BKE_PBVH_DYNVERT(cd_dyn_vert, v);
MSculptVert *mv = BKE_PBVH_SCULPTVERT(cd_sculpt_vert, v);
float *col = BM_ELEM_CD_GET_VOID_P(v, cd_temp);
float dir[3];
@ -479,7 +479,7 @@ void SCULPT_bmesh_four_neighbor_average(SculptSession *ss,
// bucketw *= 2.0;
//}
MDynTopoVert *mv2 = BKE_PBVH_DYNVERT(cd_dyn_vert, v_other);
MSculptVert *mv2 = BKE_PBVH_SCULPTVERT(cd_sculpt_vert, v_other);
float *co2;
float *no2;
@ -493,9 +493,10 @@ void SCULPT_bmesh_four_neighbor_average(SculptSession *ss,
}
// bool bound = (mv2->flag &
// (DYNVERT_BOUNDARY)); // | DYNVERT_FSET_BOUNDARY | DYNVERT_SHARP_BOUNDARY));
// (SCULPTVERT_BOUNDARY)); // | SCULPTVERT_FSET_BOUNDARY |
// SCULPTVERT_SHARP_BOUNDARY));
// bool bound2 = (mv2->flag &
// (DYNVERT_BOUNDARY | DYNVERT_FSET_BOUNDARY | DYNVERT_SHARP_BOUNDARY));
// (SCULPTVERT_BOUNDARY | SCULPTVERT_FSET_BOUNDARY | SCULPTVERT_SHARP_BOUNDARY));
SculptBoundaryType bflag = SCULPT_BOUNDARY_FACE_SET | SCULPT_BOUNDARY_MESH |
SCULPT_BOUNDARY_SHARP | SCULPT_BOUNDARY_SEAM;

52
source/blender/editors/sculpt_paint/sculpt_undo.c
View File

@ -428,7 +428,7 @@ typedef struct BmeshUndoData {
bool do_full_recalc;
bool balance_pbvh;
int cd_face_node_offset, cd_vert_node_offset;
int cd_dyn_vert;
int cd_sculpt_vert;
bool regen_all_unique_verts;
bool is_redo;
} BmeshUndoData;
@ -458,10 +458,10 @@ static void bmesh_undo_on_vert_add(BMVert *v, void *userdata)
// let face add vert
BM_ELEM_CD_SET_INT(v, data->cd_vert_node_offset, -1);
MDynTopoVert *mv = BKE_PBVH_DYNVERT(data->cd_dyn_vert, v);
MSculptVert *mv = BKE_PBVH_SCULPTVERT(data->cd_sculpt_vert, v);
MV_ADD_FLAG(mv,
DYNVERT_NEED_DISK_SORT | DYNVERT_NEED_VALENCE | DYNVERT_NEED_TRIANGULATE |
DYNVERT_NEED_BOUNDARY);
SCULPTVERT_NEED_DISK_SORT | SCULPTVERT_NEED_VALENCE | SCULPTVERT_NEED_TRIANGULATE |
SCULPTVERT_NEED_BOUNDARY);
}
static void bmesh_undo_on_face_kill(BMFace *f, void *userdata)
@ -493,8 +493,8 @@ static void bmesh_undo_on_face_add(BMFace *f, void *userdata)
BMLoop *l = f->l_first;
do {
MDynTopoVert *mv = BKE_PBVH_DYNVERT(data->cd_dyn_vert, l->v);
MV_ADD_FLAG(mv, DYNVERT_NEED_DISK_SORT | DYNVERT_NEED_BOUNDARY);
MSculptVert *mv = BKE_PBVH_SCULPTVERT(data->cd_sculpt_vert, l->v);
MV_ADD_FLAG(mv, SCULPTVERT_NEED_DISK_SORT | SCULPTVERT_NEED_BOUNDARY);
int ni_l = BM_ELEM_CD_GET_INT(l->v, data->cd_vert_node_offset);
@ -527,28 +527,28 @@ static void bmesh_undo_on_edge_kill(BMEdge *e, void *userdata)
{
BmeshUndoData *data = (BmeshUndoData *)userdata;
MDynTopoVert *mv1 = BKE_PBVH_DYNVERT(data->cd_dyn_vert, e->v1);
MDynTopoVert *mv2 = BKE_PBVH_DYNVERT(data->cd_dyn_vert, e->v2);
MSculptVert *mv1 = BKE_PBVH_SCULPTVERT(data->cd_sculpt_vert, e->v1);
MSculptVert *mv2 = BKE_PBVH_SCULPTVERT(data->cd_sculpt_vert, e->v2);
MV_ADD_FLAG(mv1,
DYNVERT_NEED_BOUNDARY | DYNVERT_NEED_TRIANGULATE | DYNVERT_NEED_DISK_SORT |
DYNVERT_NEED_VALENCE);
SCULPTVERT_NEED_BOUNDARY | SCULPTVERT_NEED_TRIANGULATE | SCULPTVERT_NEED_DISK_SORT |
SCULPTVERT_NEED_VALENCE);
MV_ADD_FLAG(mv2,
DYNVERT_NEED_BOUNDARY | DYNVERT_NEED_TRIANGULATE | DYNVERT_NEED_DISK_SORT |
DYNVERT_NEED_VALENCE);
SCULPTVERT_NEED_BOUNDARY | SCULPTVERT_NEED_TRIANGULATE | SCULPTVERT_NEED_DISK_SORT |
SCULPTVERT_NEED_VALENCE);
}
static void bmesh_undo_on_edge_add(BMEdge *e, void *userdata)
{
BmeshUndoData *data = (BmeshUndoData *)userdata;
MDynTopoVert *mv1 = BKE_PBVH_DYNVERT(data->cd_dyn_vert, e->v1);
MDynTopoVert *mv2 = BKE_PBVH_DYNVERT(data->cd_dyn_vert, e->v2);
MSculptVert *mv1 = BKE_PBVH_SCULPTVERT(data->cd_sculpt_vert, e->v1);
MSculptVert *mv2 = BKE_PBVH_SCULPTVERT(data->cd_sculpt_vert, e->v2);
mv1->flag |= DYNVERT_NEED_BOUNDARY | DYNVERT_NEED_TRIANGULATE | DYNVERT_NEED_DISK_SORT |
DYNVERT_NEED_VALENCE;
mv2->flag |= DYNVERT_NEED_BOUNDARY | DYNVERT_NEED_TRIANGULATE | DYNVERT_NEED_DISK_SORT |
DYNVERT_NEED_VALENCE;
mv1->flag |= SCULPTVERT_NEED_BOUNDARY | SCULPTVERT_NEED_TRIANGULATE | SCULPTVERT_NEED_DISK_SORT |
SCULPTVERT_NEED_VALENCE;
mv2->flag |= SCULPTVERT_NEED_BOUNDARY | SCULPTVERT_NEED_TRIANGULATE | SCULPTVERT_NEED_DISK_SORT |
SCULPTVERT_NEED_VALENCE;
}
static void bmesh_undo_on_vert_change(BMVert *v, void *userdata, void *old_customdata)
@ -648,7 +648,7 @@ static void sculpt_undo_bmesh_restore_generic(SculptUndoNode *unode, Object *ob,
false,
ss->cd_face_node_offset,
ss->cd_vert_node_offset,
ss->cd_dyn_vert,
ss->cd_sculpt_vert,
false,
!unode->applied};
@ -760,7 +760,7 @@ static void sculpt_undo_bmesh_enable(Object *ob, SculptUndoNode *unode, bool is_
BM_log_set_current_entry(ss->bm_log, entry);
}
BM_log_set_cd_offsets(ss->bm_log, ss->cd_dyn_vert);
BM_log_set_cd_offsets(ss->bm_log, ss->cd_sculpt_vert);
}
static void sculpt_undo_bmesh_restore_begin(
@ -964,7 +964,7 @@ static int sculpt_undo_bmesh_restore(
if (ss->bm_log && ss->bm &&
!ELEM(unode->type, SCULPT_UNDO_DYNTOPO_BEGIN, SCULPT_UNDO_DYNTOPO_END)) {
SCULPT_update_customdata_refs(ss);
BM_log_set_cd_offsets(ss->bm_log, ss->cd_dyn_vert);
BM_log_set_cd_offsets(ss->bm_log, ss->cd_sculpt_vert);
#if 0
if (ss->active_face_index.i && ss->active_face_index.i != -1LL) {
@ -1117,7 +1117,7 @@ static void sculpt_undo_restore_list(bContext *C, Depsgraph *depsgraph, ListBase
ss->bm_log = log;
SCULPT_dyntopo_node_layers_update_offsets(ss);
BM_log_set_cd_offsets(ss->bm_log, ss->cd_dyn_vert);
BM_log_set_cd_offsets(ss->bm_log, ss->cd_sculpt_vert);
}
// PBVH is corrupted at this point, destroy it
@ -1787,7 +1787,7 @@ void SCULPT_undo_ensure_bmlog(Object *ob)
ss->bm_log = BM_log_from_existing_entries_create(ss->bm, unode->bm_entry);
}
else {
ss->bm_log = BM_log_create(ss->bm, ss->cd_dyn_vert);
ss->bm_log = BM_log_create(ss->bm, ss->cd_sculpt_vert);
}
if (ss->pbvh) {
@ -1807,7 +1807,7 @@ static SculptUndoNode *sculpt_undo_bmesh_push(Object *ob, PBVHNode *node, Sculpt
SCULPT_undo_ensure_bmlog(ob);
if (!ss->bm_log) {
ss->bm_log = BM_log_create(ss->bm, ss->cd_dyn_vert);
ss->bm_log = BM_log_create(ss->bm, ss->cd_sculpt_vert);
}
bool new_node = false;
@ -2151,7 +2151,7 @@ void sculpt_undo_push_begin_ex(Object *ob, const char *name, bool no_first_entry
if (ss && ss->bm && ss->bm_log && BM_log_is_dead(ss->bm_log)) {
// forcibly destroy all entries? the 'true' parameter
BM_log_free(ss->bm_log, true);
ss->bm_log = BM_log_create(ss->bm, ss->cd_dyn_vert);
ss->bm_log = BM_log_create(ss->bm, ss->cd_sculpt_vert);
if (ss->pbvh) {
BKE_pbvh_set_bm_log(ss->pbvh, ss->bm_log);
@ -2671,7 +2671,7 @@ void SCULPT_substep_undo(bContext *C, int dir)
false,
ss->cd_face_node_offset,
ss->cd_vert_node_offset,
ss->cd_dyn_vert,
ss->cd_sculpt_vert,
false,
false};

4
source/blender/gpu/intern/gpu_buffers.c
View File

@ -1092,8 +1092,8 @@ static void gpu_bmesh_vert_to_buffer_copy(BMesh *bm,
/* Set coord, normal, and mask */
if (G.debug_value == 890 || pbvh_show_orig_co) {
const int cd_dyn_vert = bm->vdata.layers[bm->vdata.typemap[CD_DYNTOPO_VERT]].offset;
MDynTopoVert *mv = BM_ELEM_CD_GET_VOID_P(v, cd_dyn_vert);
const int cd_sculpt_vert = bm->vdata.layers[bm->vdata.typemap[CD_DYNTOPO_VERT]].offset;
MSculptVert *mv = BM_ELEM_CD_GET_VOID_P(v, cd_sculpt_vert);
GPU_vertbuf_attr_set(vert_buf, g_vbo_id.pos, v_index, mv->origco);
normal_float_to_short_v3(no_short, mv->origno);

36
source/blender/makesdna/DNA_meshdata_types.h
View File

@ -525,7 +525,7 @@ typedef struct MRecast {
/** \} */
typedef struct MDynTopoVert {
typedef struct MSculptVert {
short flag, valence;
/**original coordinates*/
@ -540,25 +540,25 @@ typedef struct MDynTopoVert {
/* id of current stroke, used to detect
if vertex original data needs to be updated*/
int stroke_id;
} MDynTopoVert;
} MSculptVert;
/* MDynTopoVert->flag */
/* MSculptVert->flag */
enum {
DYNVERT_BOUNDARY = (1 << 0),
DYNVERT_VERT_FSET_HIDDEN = (1 << 1),
DYNVERT_FSET_BOUNDARY = (1 << 2),
DYNVERT_NEED_BOUNDARY = (1 << 3),
DYNVERT_NEED_TRIANGULATE = (1 << 4),
DYNVERT_NEED_DISK_SORT = (1 << 5),
DYNVERT_NEED_VALENCE = (1 << 6),
DYNVERT_FSET_CORNER = (1 << 7),
DYNVERT_CORNER = (1 << 8),
DYNVERT_SEAM_BOUNDARY = (1 << 9),
DYNVERT_SHARP_BOUNDARY = (1 << 10),
DYNVERT_SEAM_CORNER = (1 << 11),
DYNVERT_SHARP_CORNER = (1 << 12),
DYNVERT_SPLIT_TEMP = (1 << 13),
DYNVERT_PBVH_BOUNDARY = (1 << 14)
SCULPTVERT_BOUNDARY = (1 << 0),
SCULPTVERT_VERT_FSET_HIDDEN = (1 << 1),
SCULPTVERT_FSET_BOUNDARY = (1 << 2),
SCULPTVERT_NEED_BOUNDARY = (1 << 3),
SCULPTVERT_NEED_TRIANGULATE = (1 << 4),
SCULPTVERT_NEED_DISK_SORT = (1 << 5),
SCULPTVERT_NEED_VALENCE = (1 << 6),
SCULPTVERT_FSET_CORNER = (1 << 7),
SCULPTVERT_CORNER = (1 << 8),
SCULPTVERT_SEAM_BOUNDARY = (1 << 9),
SCULPTVERT_SHARP_BOUNDARY = (1 << 10),
SCULPTVERT_SEAM_CORNER = (1 << 11),
SCULPTVERT_SHARP_CORNER = (1 << 12),
SCULPTVERT_SPLIT_TEMP = (1 << 13),
SCULPTVERT_PBVH_BOUNDARY = (1 << 14)
};
/* for internal bmesh toolflags api */