archive/blender-archive
Archived
1
1
Fork 0
Code Pull Requests Packages Activity

Dyntopo: replace GHash with GSet, saves some memory

Browse Source
This commit is contained in:
Campbell Barton
2014-04-08 14:45:48 +10:00
parent 593b698b44
commit ebaf3781fa
5 changed files with 87 additions and 112 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -594,7 +594,7 @@ void BKE_pbvh_free(PBVH *bvh)
BKE_pbvh_node_layer_disp_free(node); BKE_pbvh_node_layer_disp_free(node);
if (node->bm_faces) if (node->bm_faces)
BLI_ghash_free(node->bm_faces, NULL, NULL); BLI_gset_free(node->bm_faces, NULL);
if (node->bm_unique_verts) if (node->bm_unique_verts)
BLI_gset_free(node->bm_unique_verts, NULL); BLI_gset_free(node->bm_unique_verts, NULL);
if (node->bm_other_verts) if (node->bm_other_verts)

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

@@ -48,7 +48,7 @@
/* Update node data after splitting */ /* Update node data after splitting */
static void pbvh_bmesh_node_finalize(PBVH *bvh, int node_index) static void pbvh_bmesh_node_finalize(PBVH *bvh, int node_index)
{ {
GHashIterator gh_iter; GSetIterator gs_iter;
PBVHNode *n = &bvh->nodes[node_index]; PBVHNode *n = &bvh->nodes[node_index];
/* Create vert hash sets */ /* Create vert hash sets */
@@ -57,8 +57,8 @@ static void pbvh_bmesh_node_finalize(PBVH *bvh, int node_index)
BB_reset(&n->vb); BB_reset(&n->vb);
GHASH_ITER (gh_iter, n->bm_faces) { GSET_ITER (gs_iter, n->bm_faces) {
BMFace *f = BLI_ghashIterator_getKey(&gh_iter); BMFace *f = BLI_gsetIterator_getKey(&gs_iter);
BMLoop *l_iter; BMLoop *l_iter;
BMLoop *l_first; BMLoop *l_first;
BMVert *v; BMVert *v;
@@ -99,8 +99,7 @@ static void pbvh_bmesh_node_finalize(PBVH *bvh, int node_index)
/* Recursively split the node if it exceeds the leaf_limit */ /* Recursively split the node if it exceeds the leaf_limit */
static void pbvh_bmesh_node_split(PBVH *bvh, GHash *prim_bbc, int node_index) static void pbvh_bmesh_node_split(PBVH *bvh, GHash *prim_bbc, int node_index)
{ {
GHash *empty, *other; GSet *empty, *other;
GHashIterator gh_iter;
GSetIterator gs_iter; GSetIterator gs_iter;
PBVHNode *n, *c1, *c2; PBVHNode *n, *c1, *c2;
BB cb; BB cb;
@@ -109,7 +108,7 @@ static void pbvh_bmesh_node_split(PBVH *bvh, GHash *prim_bbc, int node_index)
n = &bvh->nodes[node_index]; n = &bvh->nodes[node_index];
if (BLI_ghash_size(n->bm_faces) <= bvh->leaf_limit) { if (BLI_gset_size(n->bm_faces) <= bvh->leaf_limit) {
/* Node limit not exceeded */ /* Node limit not exceeded */
pbvh_bmesh_node_finalize(bvh, node_index); pbvh_bmesh_node_finalize(bvh, node_index);
return; return;
@@ -117,8 +116,8 @@ static void pbvh_bmesh_node_split(PBVH *bvh, GHash *prim_bbc, int node_index)
/* Calculate bounding box around primitive centroids */ /* Calculate bounding box around primitive centroids */
BB_reset(&cb); BB_reset(&cb);
GHASH_ITER (gh_iter, n->bm_faces) { GSET_ITER (gs_iter, n->bm_faces) {
const BMFace *f = BLI_ghashIterator_getKey(&gh_iter); const BMFace *f = BLI_gsetIterator_getKey(&gs_iter);
const BBC *bbc = BLI_ghash_lookup(prim_bbc, f); const BBC *bbc = BLI_ghash_lookup(prim_bbc, f);
BB_expand(&cb, bbc->bcentroid); BB_expand(&cb, bbc->bcentroid);
@@ -141,35 +140,35 @@ static void pbvh_bmesh_node_split(PBVH *bvh, GHash *prim_bbc, int node_index)
c2 = &bvh->nodes[children + 1]; c2 = &bvh->nodes[children + 1];
c1->flag |= PBVH_Leaf; c1->flag |= PBVH_Leaf;
c2->flag |= PBVH_Leaf; c2->flag |= PBVH_Leaf;
c1->bm_faces = BLI_ghash_ptr_new_ex("bm_faces", BLI_ghash_size(n->bm_faces) / 2); c1->bm_faces = BLI_gset_ptr_new_ex("bm_faces", BLI_gset_size(n->bm_faces) / 2);
c2->bm_faces = BLI_ghash_ptr_new_ex("bm_faces", BLI_ghash_size(n->bm_faces) / 2); c2->bm_faces = BLI_gset_ptr_new_ex("bm_faces", BLI_gset_size(n->bm_faces) / 2);
/* Partition the parent node's faces between the two children */ /* Partition the parent node's faces between the two children */
GHASH_ITER (gh_iter, n->bm_faces) { GSET_ITER (gs_iter, n->bm_faces) {
BMFace *f = BLI_ghashIterator_getKey(&gh_iter); BMFace *f = BLI_gsetIterator_getKey(&gs_iter);
const BBC *bbc = BLI_ghash_lookup(prim_bbc, f); const BBC *bbc = BLI_ghash_lookup(prim_bbc, f);
if (bbc->bcentroid[axis] < mid) if (bbc->bcentroid[axis] < mid)
BLI_ghash_insert(c1->bm_faces, f, NULL); BLI_gset_insert(c1->bm_faces, f);
else else
BLI_ghash_insert(c2->bm_faces, f, NULL); BLI_gset_insert(c2->bm_faces, f);
} }
/* Enforce at least one primitive in each node */ /* Enforce at least one primitive in each node */
empty = NULL; empty = NULL;
if (BLI_ghash_size(c1->bm_faces) == 0) { if (BLI_gset_size(c1->bm_faces) == 0) {
empty = c1->bm_faces; empty = c1->bm_faces;
other = c2->bm_faces; other = c2->bm_faces;
} }
else if (BLI_ghash_size(c2->bm_faces) == 0) { else if (BLI_gset_size(c2->bm_faces) == 0) {
empty = c2->bm_faces; empty = c2->bm_faces;
other = c1->bm_faces; other = c1->bm_faces;
} }
if (empty) { if (empty) {
GHASH_ITER (gh_iter, other) { GSET_ITER (gs_iter, other) {
void *key = BLI_ghashIterator_getKey(&gh_iter); void *key = BLI_gsetIterator_getKey(&gs_iter);
BLI_ghash_insert(empty, key, NULL); BLI_gset_insert(empty, key);
BLI_ghash_remove(other, key, NULL, NULL); BLI_gset_remove(other, key, NULL);
break; break;
} }
} }
@@ -186,11 +185,11 @@ static void pbvh_bmesh_node_split(PBVH *bvh, GHash *prim_bbc, int node_index)
} }
/* Unclaim faces */ /* Unclaim faces */
GHASH_ITER (gh_iter, n->bm_faces) { GSET_ITER (gs_iter, n->bm_faces) {
BMFace *f = BLI_ghashIterator_getKey(&gh_iter); BMFace *f = BLI_gsetIterator_getKey(&gs_iter);
BLI_ghash_remove(bvh->bm_face_to_node, f, NULL, NULL); BLI_ghash_remove(bvh->bm_face_to_node, f, NULL, NULL);
} }
BLI_ghash_free(n->bm_faces, NULL, NULL); BLI_gset_free(n->bm_faces, NULL);
if (n->bm_other_verts) if (n->bm_other_verts)
BLI_gset_free(n->bm_other_verts, NULL); BLI_gset_free(n->bm_other_verts, NULL);
@@ -228,14 +227,14 @@ static void pbvh_bmesh_node_split(PBVH *bvh, GHash *prim_bbc, int node_index)
static bool pbvh_bmesh_node_limit_ensure(PBVH *bvh, int node_index) static bool pbvh_bmesh_node_limit_ensure(PBVH *bvh, int node_index)
{ {
GHash *prim_bbc; GHash *prim_bbc;
GHash *bm_faces; GSet *bm_faces;
int bm_faces_size; int bm_faces_size;
GHashIterator gh_iter; GSetIterator gs_iter;
BBC *bbc_array; BBC *bbc_array;
unsigned int i; unsigned int i;
bm_faces = bvh->nodes[node_index].bm_faces; bm_faces = bvh->nodes[node_index].bm_faces;
bm_faces_size = BLI_ghash_size(bm_faces); bm_faces_size = BLI_gset_size(bm_faces);
if (bm_faces_size <= bvh->leaf_limit) { if (bm_faces_size <= bvh->leaf_limit) {
/* Node limit not exceeded */ /* Node limit not exceeded */
return false; return false;
@@ -245,8 +244,8 @@ static bool pbvh_bmesh_node_limit_ensure(PBVH *bvh, int node_index)
prim_bbc = BLI_ghash_ptr_new_ex("prim_bbc", bm_faces_size); prim_bbc = BLI_ghash_ptr_new_ex("prim_bbc", bm_faces_size);
bbc_array = MEM_callocN(sizeof(BBC) * bm_faces_size, "BBC"); bbc_array = MEM_callocN(sizeof(BBC) * bm_faces_size, "BBC");
GHASH_ITER_INDEX (gh_iter, bm_faces, i) { GSET_ITER_INDEX (gs_iter, bm_faces, i) {
BMFace *f = BLI_ghashIterator_getKey(&gh_iter); BMFace *f = BLI_gsetIterator_getKey(&gs_iter);
BBC *bbc = &bbc_array[i]; BBC *bbc = &bbc_array[i];
BMLoop *l_iter; BMLoop *l_iter;
BMLoop *l_first; BMLoop *l_first;
@@ -317,7 +316,7 @@ static BMFace *pbvh_bmesh_face_create(PBVH *bvh, int node_index,
BLI_assert(!BLI_ghash_haskey(bvh->bm_face_to_node, f)); BLI_assert(!BLI_ghash_haskey(bvh->bm_face_to_node, f));
{ {
BLI_ghash_insert(bvh->nodes[node_index].bm_faces, f, NULL); BLI_gset_insert(bvh->nodes[node_index].bm_faces, f);
BLI_ghash_insert(bvh->bm_face_to_node, f, val); BLI_ghash_insert(bvh->bm_face_to_node, f, val);
/* mark node for update */ /* mark node for update */
@@ -456,7 +455,7 @@ static void pbvh_bmesh_face_remove(PBVH *bvh, BMFace *f)
} while ((l_iter = l_iter->next) != l_first); } while ((l_iter = l_iter->next) != l_first);
/* Remove face from node and top level */ /* Remove face from node and top level */
BLI_ghash_remove(f_node->bm_faces, f, NULL, NULL); BLI_gset_remove(f_node->bm_faces, f, NULL);
BLI_ghash_remove(bvh->bm_face_to_node, f, NULL, NULL); BLI_ghash_remove(bvh->bm_face_to_node, f, NULL, NULL);
/* Log removed face */ /* Log removed face */
@@ -622,11 +621,11 @@ static void long_edge_queue_create(EdgeQueueContext *eq_ctx,
if ((node->flag & PBVH_Leaf) && if ((node->flag & PBVH_Leaf) &&
(node->flag & PBVH_UpdateTopology)) (node->flag & PBVH_UpdateTopology))
{ {
GHashIterator gh_iter; GSetIterator gs_iter;
/* Check each face */ /* Check each face */
GHASH_ITER (gh_iter, node->bm_faces) { GSET_ITER (gs_iter, node->bm_faces) {
BMFace *f = BLI_ghashIterator_getKey(&gh_iter); BMFace *f = BLI_gsetIterator_getKey(&gs_iter);
long_edge_queue_face_add(eq_ctx, f); long_edge_queue_face_add(eq_ctx, f);
} }
@@ -661,11 +660,11 @@ static void short_edge_queue_create(EdgeQueueContext *eq_ctx,
if ((node->flag & PBVH_Leaf) && if ((node->flag & PBVH_Leaf) &&
(node->flag & PBVH_UpdateTopology)) (node->flag & PBVH_UpdateTopology))
{ {
GHashIterator gh_iter; GSetIterator gs_iter;
/* Check each face */ /* Check each face */
GHASH_ITER (gh_iter, node->bm_faces) { GSET_ITER (gs_iter, node->bm_faces) {
BMFace *f = BLI_ghashIterator_getKey(&gh_iter); BMFace *f = BLI_gsetIterator_getKey(&gs_iter);
short_edge_queue_face_add(eq_ctx, f); short_edge_queue_face_add(eq_ctx, f);
} }
@@ -815,8 +814,9 @@ static bool pbvh_bmesh_subdivide_long_edges(EdgeQueueContext *eq_ctx, PBVH *bvh,
return any_subdivided; return any_subdivided;
} }
static void pbvh_bmesh_collapse_edge(PBVH *bvh, BMEdge *e, BMVert *v1, static void pbvh_bmesh_collapse_edge(PBVH *bvh, BMEdge *e,
BMVert *v2, GHash *deleted_verts, BMVert *v1, BMVert *v2,
GSet *deleted_verts,
BLI_Buffer *edge_loops, BLI_Buffer *edge_loops,
BLI_Buffer *deleted_faces, BLI_Buffer *deleted_faces,
int cd_vert_mask_offset) int cd_vert_mask_offset)
@@ -922,7 +922,7 @@ static void pbvh_bmesh_collapse_edge(PBVH *bvh, BMEdge *e, BMVert *v1,
* remove them from the PBVH */ * remove them from the PBVH */
for (j = 0; j < 3; j++) { for (j = 0; j < 3; j++) {
if (v_tri[j] != v_del && BM_vert_face_count(v_tri[j]) == 1) { if (v_tri[j] != v_del && BM_vert_face_count(v_tri[j]) == 1) {
BLI_ghash_insert(deleted_verts, v_tri[j], NULL); BLI_gset_insert(deleted_verts, v_tri[j]);
pbvh_bmesh_vert_remove(bvh, v_tri[j]); pbvh_bmesh_vert_remove(bvh, v_tri[j]);
} }
else { else {
@@ -952,14 +952,14 @@ static void pbvh_bmesh_collapse_edge(PBVH *bvh, BMEdge *e, BMVert *v1,
/* Move v_conn to the midpoint of v_conn and v_del (if v_conn still exists, it /* Move v_conn to the midpoint of v_conn and v_del (if v_conn still exists, it
* may have been deleted above) */ * may have been deleted above) */
if (!BLI_ghash_haskey(deleted_verts, v_conn)) { if (!BLI_gset_haskey(deleted_verts, v_conn)) {
BM_log_vert_before_modified(bvh->bm_log, v_conn, cd_vert_mask_offset); BM_log_vert_before_modified(bvh->bm_log, v_conn, cd_vert_mask_offset);
mid_v3_v3v3(v_conn->co, v_conn->co, v_del->co); mid_v3_v3v3(v_conn->co, v_conn->co, v_del->co);
} }
/* Delete v_del */ /* Delete v_del */
BLI_assert(BM_vert_face_count(v_del) == 0); BLI_assert(BM_vert_face_count(v_del) == 0);
BLI_ghash_insert(deleted_verts, v_del, NULL); BLI_gset_insert(deleted_verts, v_del);
BM_log_vert_removed(bvh->bm_log, v_del, cd_vert_mask_offset); BM_log_vert_removed(bvh->bm_log, v_del, cd_vert_mask_offset);
BM_vert_kill(bvh->bm, v_del); BM_vert_kill(bvh->bm, v_del);
} }
@@ -970,10 +970,10 @@ static bool pbvh_bmesh_collapse_short_edges(EdgeQueueContext *eq_ctx,
BLI_Buffer *deleted_faces) BLI_Buffer *deleted_faces)
{ {
float min_len_squared = bvh->bm_min_edge_len * bvh->bm_min_edge_len; float min_len_squared = bvh->bm_min_edge_len * bvh->bm_min_edge_len;
GHash *deleted_verts; GSet *deleted_verts;
bool any_collapsed = false; bool any_collapsed = false;
deleted_verts = BLI_ghash_ptr_new("deleted_verts"); deleted_verts = BLI_gset_ptr_new("deleted_verts");
while (!BLI_heap_is_empty(eq_ctx->q->heap)) { while (!BLI_heap_is_empty(eq_ctx->q->heap)) {
BMVert **pair = BLI_heap_popmin(eq_ctx->q->heap); BMVert **pair = BLI_heap_popmin(eq_ctx->q->heap);
@@ -984,8 +984,8 @@ static bool pbvh_bmesh_collapse_short_edges(EdgeQueueContext *eq_ctx,
pair = NULL; pair = NULL;
/* Check the verts still exist */ /* Check the verts still exist */
if (BLI_ghash_haskey(deleted_verts, v1) || if (BLI_gset_haskey(deleted_verts, v1) ||
BLI_ghash_haskey(deleted_verts, v2)) BLI_gset_haskey(deleted_verts, v2))
{ {
continue; continue;
} }
@@ -1015,19 +1015,18 @@ static bool pbvh_bmesh_collapse_short_edges(EdgeQueueContext *eq_ctx,
deleted_faces, eq_ctx->cd_vert_mask_offset); deleted_faces, eq_ctx->cd_vert_mask_offset);
} }
BLI_ghash_free(deleted_verts, NULL, NULL); BLI_gset_free(deleted_verts, NULL);
return any_collapsed; return any_collapsed;
} }
/************************* Called from pbvh.c *************************/ /************************* Called from pbvh.c *************************/
int pbvh_bmesh_node_raycast(PBVHNode *node, const float ray_start[3], bool pbvh_bmesh_node_raycast(PBVHNode *node, const float ray_start[3],
const float ray_normal[3], float *dist, const float ray_normal[3], float *dist,
int use_original) int use_original)
{ {
GHashIterator gh_iter; bool hit = false;
int hit = 0;
if (use_original && node->bm_tot_ortri) { if (use_original && node->bm_tot_ortri) {
int i; int i;
@@ -1041,8 +1040,10 @@ int pbvh_bmesh_node_raycast(PBVHNode *node, const float ray_start[3],
} }
} }
else { else {
GHASH_ITER (gh_iter, node->bm_faces) { GSetIterator gs_iter;
BMFace *f = BLI_ghashIterator_getKey(&gh_iter);
GSET_ITER (gs_iter, node->bm_faces) {
BMFace *f = BLI_gsetIterator_getKey(&gs_iter);
BLI_assert(f->len == 3); BLI_assert(f->len == 3);
if (f->len == 3 && !paint_is_bmesh_face_hidden(f)) { if (f->len == 3 && !paint_is_bmesh_face_hidden(f)) {
@@ -1066,15 +1067,15 @@ bool BKE_pbvh_bmesh_node_raycast_detail(
const float ray_start[3], const float ray_normal[3], const float ray_start[3], const float ray_normal[3],
float *detail, float *dist) float *detail, float *dist)
{ {
GHashIterator gh_iter; GSetIterator gs_iter;
bool hit = false; bool hit = false;
BMFace *f_hit = NULL; BMFace *f_hit = NULL;
if (node->flag & PBVH_FullyHidden) if (node->flag & PBVH_FullyHidden)
return 0; return 0;
GHASH_ITER (gh_iter, node->bm_faces) { GSET_ITER (gs_iter, node->bm_faces) {
BMFace *f = BLI_ghashIterator_getKey(&gh_iter); BMFace *f = BLI_gsetIterator_getKey(&gs_iter);
BLI_assert(f->len == 3); BLI_assert(f->len == 3);
if (f->len == 3 && !paint_is_bmesh_face_hidden(f)) { if (f->len == 3 && !paint_is_bmesh_face_hidden(f)) {
@@ -1119,11 +1120,10 @@ void pbvh_bmesh_normals_update(PBVHNode **nodes, int totnode)
PBVHNode *node = nodes[n]; PBVHNode *node = nodes[n];
if (node->flag & PBVH_UpdateNormals) { if (node->flag & PBVH_UpdateNormals) {
GHashIterator gh_iter;
GSetIterator gs_iter; GSetIterator gs_iter;
GHASH_ITER (gh_iter, node->bm_faces) { GSET_ITER (gs_iter, node->bm_faces) {
BM_face_normal_update(BLI_ghashIterator_getKey(&gh_iter)); BM_face_normal_update(BLI_gsetIterator_getKey(&gs_iter));
} }
GSET_ITER (gs_iter, node->bm_unique_verts) { GSET_ITER (gs_iter, node->bm_unique_verts) {
BM_vert_normal_update(BLI_gsetIterator_getKey(&gs_iter)); BM_vert_normal_update(BLI_gsetIterator_getKey(&gs_iter));
@@ -1166,9 +1166,9 @@ void BKE_pbvh_build_bmesh(PBVH *bvh, BMesh *bm, bool smooth_shading, BMLog *log)
n = bvh->nodes = MEM_callocN(sizeof(PBVHNode), "PBVHNode"); n = bvh->nodes = MEM_callocN(sizeof(PBVHNode), "PBVHNode");
bvh->totnode = 1; bvh->totnode = 1;
n->flag = PBVH_Leaf; n->flag = PBVH_Leaf;
n->bm_faces = BLI_ghash_ptr_new_ex("bm_faces", bvh->bm->totface); n->bm_faces = BLI_gset_ptr_new_ex("bm_faces", bvh->bm->totface);
BM_ITER_MESH (f, &iter, bvh->bm, BM_FACES_OF_MESH) { BM_ITER_MESH (f, &iter, bvh->bm, BM_FACES_OF_MESH) {
BLI_ghash_insert(n->bm_faces, f, NULL); BLI_gset_insert(n->bm_faces, f);
} }
/* Recursively split the node until it is under the limit; if no /* Recursively split the node until it is under the limit; if no
@@ -1247,7 +1247,6 @@ BLI_INLINE void bm_face_as_array_index_tri(BMFace *f, int r_index[3])
* Skips triangles that are hidden. */ * Skips triangles that are hidden. */
void BKE_pbvh_bmesh_node_save_orig(PBVHNode *node) void BKE_pbvh_bmesh_node_save_orig(PBVHNode *node)
{ {
GHashIterator gh_iter;
GSetIterator gs_iter; GSetIterator gs_iter;
int i, totvert, tottri; int i, totvert, tottri;
@@ -1258,7 +1257,7 @@ void BKE_pbvh_bmesh_node_save_orig(PBVHNode *node)
totvert = (BLI_gset_size(node->bm_unique_verts) + totvert = (BLI_gset_size(node->bm_unique_verts) +
BLI_gset_size(node->bm_other_verts)); BLI_gset_size(node->bm_other_verts));
tottri = BLI_ghash_size(node->bm_faces); tottri = BLI_gset_size(node->bm_faces);
node->bm_orco = MEM_mallocN(sizeof(*node->bm_orco) * totvert, __func__); node->bm_orco = MEM_mallocN(sizeof(*node->bm_orco) * totvert, __func__);
node->bm_ortri = MEM_mallocN(sizeof(*node->bm_ortri) * tottri, __func__); node->bm_ortri = MEM_mallocN(sizeof(*node->bm_ortri) * tottri, __func__);
@@ -1280,8 +1279,8 @@ void BKE_pbvh_bmesh_node_save_orig(PBVHNode *node)
/* Copy the triangles */ /* Copy the triangles */
i = 0; i = 0;
GHASH_ITER (gh_iter, node->bm_faces) { GSET_ITER (gs_iter, node->bm_faces) {
BMFace *f = BLI_ghashIterator_getKey(&gh_iter); BMFace *f = BLI_gsetIterator_getKey(&gs_iter);
if (paint_is_bmesh_face_hidden(f)) if (paint_is_bmesh_face_hidden(f))
continue; continue;
@@ -1342,26 +1341,6 @@ GSet *BKE_pbvh_bmesh_node_other_verts(PBVHNode *node)
/****************************** Debugging *****************************/ /****************************** Debugging *****************************/
#if 0 #if 0
void bli_ghash_duplicate_key_check(GHash *gh)
{
GHashIterator gh_iter1, gh_iter2;
GHASH_ITER (gh_iter1, gh) {
void *key1 = BLI_ghashIterator_getKey(&gh_iter1);
int dup = -1;
GHASH_ITER (gh_iter2, gh) {
void *key2 = BLI_ghashIterator_getKey(&gh_iter2);
if (key1 == key2) {
dup++;
if (dup > 0) {
BLI_assert(!"duplicate in hash");
}
}
}
}
}
void bli_gset_duplicate_key_check(GSet *gs) void bli_gset_duplicate_key_check(GSet *gs)
{ {
@@ -1516,7 +1495,7 @@ void pbvh_bmesh_verify(PBVH *bvh)
BLI_assert(n->flag & PBVH_Leaf); BLI_assert(n->flag & PBVH_Leaf);
/* Check that the face's node knows it owns the face */ /* Check that the face's node knows it owns the face */
BLI_assert(BLI_ghash_haskey(n->bm_faces, f)); BLI_assert(BLI_gset_haskey(n->bm_faces, f));
/* Check the face's vertices... */ /* Check the face's vertices... */
BM_ITER_ELEM (v, &bm_iter, f, BM_VERTS_OF_FACE) { BM_ITER_ELEM (v, &bm_iter, f, BM_VERTS_OF_FACE) {
@@ -1604,7 +1583,7 @@ void pbvh_bmesh_verify(PBVH *bvh)
/* Check for duplicate entries */ /* Check for duplicate entries */
/* Slow */ /* Slow */
#if 0 #if 0
bli_ghash_duplicate_key_check(n->bm_faces); bli_gset_duplicate_key_check(n->bm_faces);
bli_gset_duplicate_key_check(n->bm_unique_verts); bli_gset_duplicate_key_check(n->bm_unique_verts);
bli_gset_duplicate_key_check(n->bm_other_verts); bli_gset_duplicate_key_check(n->bm_other_verts);
#endif #endif

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

@@ -104,7 +104,7 @@ struct PBVHNode {
PBVHProxyNode *proxies; PBVHProxyNode *proxies;
/* Dyntopo */ /* Dyntopo */
GHash *bm_faces; GSet *bm_faces;
GSet *bm_unique_verts; GSet *bm_unique_verts;
GSet *bm_other_verts; GSet *bm_other_verts;
float (*bm_orco)[3]; float (*bm_orco)[3];
@@ -181,15 +181,11 @@ bool ray_face_intersection(const float ray_start[3], const float ray_normal[3],
void pbvh_update_BB_redraw(PBVH *bvh, PBVHNode **nodes, int totnode, int flag); void pbvh_update_BB_redraw(PBVH *bvh, PBVHNode **nodes, int totnode, int flag);
/* pbvh_bmesh.c */ /* pbvh_bmesh.c */
int pbvh_bmesh_node_raycast( bool pbvh_bmesh_node_raycast(
PBVHNode *node, const float ray_start[3], PBVHNode *node, const float ray_start[3],
const float ray_normal[3], float *dist, const float ray_normal[3], float *dist,
int use_original); int use_original);
int pbvh_bmesh_node_raycast_detail(
PBVHNode *node, const float ray_start[3],
const float ray_normal[3], float *detail, float *dist);
void pbvh_bmesh_normals_update(PBVHNode **nodes, int totnode); void pbvh_bmesh_normals_update(PBVHNode **nodes, int totnode);
#endif #endif

4
source/blender/gpu/GPU_buffers.h
View File

@@ -177,7 +177,7 @@ GPU_PBVH_Buffers *GPU_build_bmesh_pbvh_buffers(int smooth_shading);
void GPU_update_bmesh_pbvh_buffers(GPU_PBVH_Buffers *buffers, void GPU_update_bmesh_pbvh_buffers(GPU_PBVH_Buffers *buffers,
struct BMesh *bm, struct BMesh *bm,
struct GHash *bm_faces, struct GSet *bm_faces,
struct GSet *bm_unique_verts, struct GSet *bm_unique_verts,
struct GSet *bm_other_verts, struct GSet *bm_other_verts,
bool show_diffuse_color); bool show_diffuse_color);
@@ -190,7 +190,7 @@ void GPU_update_grid_pbvh_buffers(GPU_PBVH_Buffers *buffers, struct CCGElem **gr
void GPU_draw_pbvh_buffers(GPU_PBVH_Buffers *buffers, DMSetMaterial setMaterial, void GPU_draw_pbvh_buffers(GPU_PBVH_Buffers *buffers, DMSetMaterial setMaterial,
bool wireframe); bool wireframe);
bool GPU_pbvh_buffers_diffuse_changed(GPU_PBVH_Buffers *buffers, struct GHash *bm_faces, bool show_diffuse_color); bool GPU_pbvh_buffers_diffuse_changed(GPU_PBVH_Buffers *buffers, struct GSet *bm_faces, bool show_diffuse_color);
void GPU_free_pbvh_buffers(GPU_PBVH_Buffers *buffers); void GPU_free_pbvh_buffers(GPU_PBVH_Buffers *buffers);

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

@@ -2010,13 +2010,13 @@ static int gpu_bmesh_vert_visible_count(GSet *bm_unique_verts,
} }
/* Return the total number of visible faces */ /* Return the total number of visible faces */
static int gpu_bmesh_face_visible_count(GHash *bm_faces) static int gpu_bmesh_face_visible_count(GSet *bm_faces)
{ {
GHashIterator gh_iter; GSetIterator gh_iter;
int totface = 0; int totface = 0;
GHASH_ITER (gh_iter, bm_faces) { GSET_ITER (gh_iter, bm_faces) {
BMFace *f = BLI_ghashIterator_getKey(&gh_iter); BMFace *f = BLI_gsetIterator_getKey(&gh_iter);
if (!paint_is_bmesh_face_hidden(f)) if (!paint_is_bmesh_face_hidden(f))
totface++; totface++;
@@ -2029,7 +2029,7 @@ static int gpu_bmesh_face_visible_count(GHash *bm_faces)
* shading, an element index buffer. */ * shading, an element index buffer. */
void GPU_update_bmesh_pbvh_buffers(GPU_PBVH_Buffers *buffers, void GPU_update_bmesh_pbvh_buffers(GPU_PBVH_Buffers *buffers,
BMesh *bm, BMesh *bm,
GHash *bm_faces, GSet *bm_faces,
GSet *bm_unique_verts, GSet *bm_unique_verts,
GSet *bm_other_verts, GSet *bm_other_verts,
bool show_diffuse_color) bool show_diffuse_color)
@@ -2075,10 +2075,10 @@ void GPU_update_bmesh_pbvh_buffers(GPU_PBVH_Buffers *buffers,
diffuse_color[0] = diffuse_color[1] = diffuse_color[2] = 1.0; diffuse_color[0] = diffuse_color[1] = diffuse_color[2] = 1.0;
else if (show_diffuse_color) { else if (show_diffuse_color) {
/* due to dynamic nature of dyntopo, only get first material */ /* due to dynamic nature of dyntopo, only get first material */
GHashIterator gh_iter; GSetIterator gs_iter;
BMFace *f; BMFace *f;
BLI_ghashIterator_init(&gh_iter, bm_faces); BLI_gsetIterator_init(&gs_iter, bm_faces);
f = BLI_ghashIterator_getKey(&gh_iter); f = BLI_gsetIterator_getKey(&gs_iter);
GPU_material_diffuse_get(f->mat_nr + 1, diffuse_color); GPU_material_diffuse_get(f->mat_nr + 1, diffuse_color);
} }
@@ -2117,10 +2117,10 @@ void GPU_update_bmesh_pbvh_buffers(GPU_PBVH_Buffers *buffers,
maxvert = v_index; maxvert = v_index;
} }
else { else {
GHashIterator gh_iter; GSetIterator gs_iter;
GHASH_ITER (gh_iter, bm_faces) { GSET_ITER (gs_iter, bm_faces) {
BMFace *f = BLI_ghashIterator_getKey(&gh_iter); BMFace *f = BLI_gsetIterator_getKey(&gs_iter);
BLI_assert(f->len == 3); BLI_assert(f->len == 3);
@@ -2175,10 +2175,10 @@ void GPU_update_bmesh_pbvh_buffers(GPU_PBVH_Buffers *buffers,
/* Fill triangle index buffer */ /* Fill triangle index buffer */
tri_data = glMapBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, GL_WRITE_ONLY_ARB); tri_data = glMapBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, GL_WRITE_ONLY_ARB);
if (tri_data) { if (tri_data) {
GHashIterator gh_iter; GSetIterator gs_iter;
GHASH_ITER (gh_iter, bm_faces) { GSET_ITER (gs_iter, bm_faces) {
BMFace *f = BLI_ghashIterator_getKey(&gh_iter); BMFace *f = BLI_gsetIterator_getKey(&gs_iter);
if (!paint_is_bmesh_face_hidden(f)) { if (!paint_is_bmesh_face_hidden(f)) {
BMLoop *l_iter; BMLoop *l_iter;
@@ -2529,7 +2529,7 @@ void GPU_draw_pbvh_buffers(GPU_PBVH_Buffers *buffers, DMSetMaterial setMaterial,
} }
} }
bool GPU_pbvh_buffers_diffuse_changed(GPU_PBVH_Buffers *buffers, GHash *bm_faces, bool show_diffuse_color) bool GPU_pbvh_buffers_diffuse_changed(GPU_PBVH_Buffers *buffers, GSet *bm_faces, bool show_diffuse_color)
{ {
float diffuse_color[4]; float diffuse_color[4];
@@ -2549,10 +2549,10 @@ bool GPU_pbvh_buffers_diffuse_changed(GPU_PBVH_Buffers *buffers, GHash *bm_faces
} }
else if (buffers->use_bmesh) { else if (buffers->use_bmesh) {
/* due to dynamc nature of dyntopo, only get first material */ /* due to dynamc nature of dyntopo, only get first material */
GHashIterator gh_iter; GSetIterator gs_iter;
BMFace *f; BMFace *f;
BLI_ghashIterator_init(&gh_iter, bm_faces); BLI_gsetIterator_init(&gs_iter, bm_faces);
f = BLI_ghashIterator_getKey(&gh_iter); f = BLI_gsetIterator_getKey(&gs_iter);
GPU_material_diffuse_get(f->mat_nr + 1, diffuse_color); GPU_material_diffuse_get(f->mat_nr + 1, diffuse_color);
} }
else { else {