[Bf-blender-cvs] [302d692b0b3] master: Cleanup: Rename variables (_tot -> _len)
mano-wii
noreply at git.blender.org
Thu Dec 12 16:06:37 CET 2019
Commit: 302d692b0b398a6224871ccbc49efdf1580726a5
Author: mano-wii
Date: Thu Dec 12 12:01:37 2019 -0300
Branches: master
https://developer.blender.org/rB302d692b0b398a6224871ccbc49efdf1580726a5
Cleanup: Rename variables (_tot -> _len)
===================================================================
M source/blender/modifiers/intern/MOD_weld.c
===================================================================
diff --git a/source/blender/modifiers/intern/MOD_weld.c b/source/blender/modifiers/intern/MOD_weld.c
index ae081942a39..7c2754a5fce 100644
--- a/source/blender/modifiers/intern/MOD_weld.c
+++ b/source/blender/modifiers/intern/MOD_weld.c
@@ -146,10 +146,10 @@ typedef struct WeldMesh {
uint *loop_map;
uint *poly_map;
- uint vert_kill_tot;
- uint edge_kill_tot;
- uint loop_kill_tot;
- uint poly_kill_tot; /* Including the new polygons. */
+ uint vert_kill_len;
+ uint edge_kill_len;
+ uint loop_kill_len;
+ uint poly_kill_len; /* Including the new polygons. */
/* Size of the affected polygon with more sides. */
uint max_poly_len;
@@ -189,11 +189,11 @@ static bool weld_iter_loop_of_poly_begin(WeldLoopOfPolyIter *iter,
static bool weld_iter_loop_of_poly_next(WeldLoopOfPolyIter *iter);
static void weld_assert_vert_dest_map_setup(const BVHTreeOverlap *overlap,
- const uint overlap_tot,
+ const uint overlap_len,
const uint *vert_dest_map)
{
const BVHTreeOverlap *overlap_iter = &overlap[0];
- for (uint i = overlap_tot; i--; overlap_iter++) {
+ for (uint i = overlap_len; i--; overlap_iter++) {
uint indexA = overlap_iter->indexA;
uint indexB = overlap_iter->indexB;
uint va_dst = vert_dest_map[indexA];
@@ -205,7 +205,7 @@ static void weld_assert_vert_dest_map_setup(const BVHTreeOverlap *overlap,
static void weld_assert_edge_kill_len(const WeldEdge *wedge,
const uint wedge_len,
- const uint supposed_kill_tot)
+ const uint supposed_kill_len)
{
uint kills = 0;
const WeldEdge *we = &wedge[0];
@@ -216,7 +216,7 @@ static void weld_assert_edge_kill_len(const WeldEdge *wedge,
kills++;
}
}
- BLI_assert(kills == supposed_kill_tot);
+ BLI_assert(kills == supposed_kill_len);
}
static void weld_assert_poly_and_loop_kill_len(const WeldPoly *wpoly,
@@ -229,8 +229,8 @@ static void weld_assert_poly_and_loop_kill_len(const WeldPoly *wpoly,
const MPoly *mpoly,
const uint mpoly_len,
const uint mloop_len,
- const uint supposed_poly_kill_tot,
- const uint supposed_loop_kill_tot)
+ const uint supposed_poly_kill_len,
+ const uint supposed_loop_kill_len)
{
uint poly_kills = 0;
uint loop_kills = mloop_len;
@@ -306,8 +306,8 @@ static void weld_assert_poly_and_loop_kill_len(const WeldPoly *wpoly,
}
}
- BLI_assert(poly_kills == supposed_poly_kill_tot);
- BLI_assert(loop_kills == supposed_loop_kill_tot);
+ BLI_assert(poly_kills == supposed_poly_kill_len);
+ BLI_assert(loop_kills == supposed_loop_kill_len);
}
static void weld_assert_poly_no_vert_repetition(const WeldPoly *wp,
@@ -368,22 +368,22 @@ static void weld_assert_poly_len(const WeldPoly *wp, const WeldLoop *wloop)
/** \name Weld Vert API
* \{ */
-static void weld_vert_ctx_alloc_and_setup(const uint vert_tot,
+static void weld_vert_ctx_alloc_and_setup(const uint mvert_len,
const BVHTreeOverlap *overlap,
- const uint overlap_tot,
+ const uint overlap_len,
uint *r_vert_dest_map,
WeldVert **r_wvert,
- uint *r_wvert_tot,
- uint *r_vert_kill_tot)
+ uint *r_wvert_len,
+ uint *r_vert_kill_len)
{
uint *v_dest_iter = &r_vert_dest_map[0];
- for (uint i = vert_tot; i--; v_dest_iter++) {
+ for (uint i = mvert_len; i--; v_dest_iter++) {
*v_dest_iter = OUT_OF_CONTEXT;
}
- uint vert_kill_tot = 0;
+ uint vert_kill_len = 0;
const BVHTreeOverlap *overlap_iter = &overlap[0];
- for (uint i = 0; i < overlap_tot; i++, overlap_iter++) {
+ for (uint i = 0; i < overlap_len; i++, overlap_iter++) {
uint indexA = overlap_iter->indexA;
uint indexB = overlap_iter->indexB;
@@ -397,11 +397,11 @@ static void weld_vert_ctx_alloc_and_setup(const uint vert_tot,
r_vert_dest_map[indexB] = vb_dst;
}
r_vert_dest_map[indexA] = vb_dst;
- vert_kill_tot++;
+ vert_kill_len++;
}
else if (vb_dst == OUT_OF_CONTEXT) {
r_vert_dest_map[indexB] = va_dst;
- vert_kill_tot++;
+ vert_kill_len++;
}
else if (va_dst != vb_dst) {
uint v_new, v_old;
@@ -415,7 +415,7 @@ static void weld_vert_ctx_alloc_and_setup(const uint vert_tot,
}
BLI_assert(r_vert_dest_map[v_old] == v_old);
BLI_assert(r_vert_dest_map[v_new] == v_new);
- vert_kill_tot++;
+ vert_kill_len++;
const BVHTreeOverlap *overlap_iter_b = &overlap[0];
for (uint j = i + 1; j--; overlap_iter_b++) {
@@ -433,33 +433,33 @@ static void weld_vert_ctx_alloc_and_setup(const uint vert_tot,
}
/* Vert Context. */
- uint wvert_tot = 0;
+ uint wvert_len = 0;
WeldVert *wvert, *wv;
- wvert = MEM_mallocN(sizeof(*wvert) * vert_tot, __func__);
+ wvert = MEM_mallocN(sizeof(*wvert) * mvert_len, __func__);
wv = &wvert[0];
v_dest_iter = &r_vert_dest_map[0];
- for (uint i = 0; i < vert_tot; i++, v_dest_iter++) {
+ for (uint i = 0; i < mvert_len; i++, v_dest_iter++) {
if (*v_dest_iter != OUT_OF_CONTEXT) {
wv->vert_dest = *v_dest_iter;
wv->vert_orig = i;
wv++;
- wvert_tot++;
+ wvert_len++;
}
}
#ifdef USE_WELD_DEBUG
- weld_assert_vert_dest_map_setup(overlap, overlap_tot, r_vert_dest_map);
+ weld_assert_vert_dest_map_setup(overlap, overlap_len, r_vert_dest_map);
#endif
- *r_wvert = MEM_reallocN(wvert, sizeof(*wvert) * wvert_tot);
- *r_wvert_tot = wvert_tot;
- *r_vert_kill_tot = vert_kill_tot;
+ *r_wvert = MEM_reallocN(wvert, sizeof(*wvert) * wvert_len);
+ *r_wvert_len = wvert_len;
+ *r_vert_kill_len = vert_kill_len;
}
-static void weld_vert_groups_setup(const uint vert_tot,
- const uint wvert_tot,
+static void weld_vert_groups_setup(const uint mvert_len,
+ const uint wvert_len,
const WeldVert *wvert,
const uint *vert_dest_map,
uint *r_vert_groups_map,
@@ -471,7 +471,7 @@ static void weld_vert_groups_setup(const uint vert_tot,
uint wgroups_len = 0;
const uint *vert_dest_iter = &vert_dest_map[0];
uint *group_map_iter = &r_vert_groups_map[0];
- for (uint i = 0; i < vert_tot; i++, group_map_iter++, vert_dest_iter++) {
+ for (uint i = 0; i < mvert_len; i++, group_map_iter++, vert_dest_iter++) {
uint vert_dest = *vert_dest_iter;
if (vert_dest != OUT_OF_CONTEXT) {
if (vert_dest != i) {
@@ -490,7 +490,7 @@ static void weld_vert_groups_setup(const uint vert_tot,
struct WeldGroup *wgroups = MEM_callocN(sizeof(*wgroups) * wgroups_len, __func__);
const WeldVert *wv = &wvert[0];
- for (uint i = wvert_tot; i--; wv++) {
+ for (uint i = wvert_len; i--; wv++) {
uint group_index = r_vert_groups_map[wv->vert_dest];
wgroups[group_index].len++;
}
@@ -502,11 +502,11 @@ static void weld_vert_groups_setup(const uint vert_tot,
ofs += wg_iter->len;
}
- BLI_assert(ofs == wvert_tot);
+ BLI_assert(ofs == wvert_len);
uint *groups_buffer = MEM_mallocN(sizeof(*groups_buffer) * ofs, __func__);
wv = &wvert[0];
- for (uint i = wvert_tot; i--; wv++) {
+ for (uint i = wvert_len; i--; wv++) {
uint group_index = r_vert_groups_map[wv->vert_dest];
groups_buffer[wgroups[group_index].ofs++] = wv->vert_orig;
}
@@ -526,17 +526,17 @@ static void weld_vert_groups_setup(const uint vert_tot,
/** \name Weld Edge API
* \{ */
-static void weld_edge_ctx_setup(const uint vert_tot,
+static void weld_edge_ctx_setup(const uint mvert_len,
const uint wedge_len,
struct WeldGroup *r_vlinks,
uint *r_edge_dest_map,
WeldEdge *r_wedge,
- uint *r_edge_kiil_tot)
+ uint *r_edge_kiil_len)
{
WeldEdge *we;
/* Setup Edge Overlap. */
- uint edge_kill_tot = 0;
+ uint edge_kill_len = 0;
struct WeldGroup *vl_iter, *v_links;
v_links = r_vlinks;
@@ -551,7 +551,7 @@ static void weld_edge_ctx_setup(const uint vert_tot,
BLI_assert(we->edge_dest == OUT_OF_CONTEXT);
r_edge_dest_map[we->edge_orig] = ELEM_COLLAPSED;
we->flag = ELEM_COLLAPSED;
- edge_kill_tot++;
+ edge_kill_len++;
continue;
}
@@ -559,15 +559,15 @@ static void weld_edge_ctx_setup(const uint vert_tot,
v_links[dst_vert_b].len++;
}
- uint link_tot = 0;
+ uint link_len = 0;
vl_iter = &v_links[0];
- for (uint i = vert_tot; i--; vl_iter++) {
- vl_iter->ofs = link_tot;
- link_tot += vl_iter->len;
+ for (uint i = mvert_len; i--; vl_iter++) {
+ vl_iter->ofs = link_len;
+ link_len += vl_iter->len;
}
- if (link_tot) {
- uint *link_edge_buffer = MEM_mallocN(sizeof(*link_edge_buffer) * link_tot, __func__);
+ if (link_len) {
+ uint *link_edge_buffer = MEM_mallocN(sizeof(*link_edge_buffer) * link_len, __func__);
we = &r_wedge[0];
for (uint i = 0; i < wedge_len; i++, we++) {
@@ -583,7 +583,7 @@ static void weld_edge_ctx_setup(const uint vert_tot,
}
vl_iter = &v_links[0];
- for (uint i = vert_tot; i--; vl_iter++) {
+ for (uint i = mvert_len; i--; vl_iter++) {
/* Fix offset */
vl_iter->ofs -= vl_iter->len;
}
@@ -634,23 +634,23 @@ static void weld_edge_ctx_setup(const uint vert_tot,
BLI_assert(we_b->edge_o
@@ Diff output truncated at 10240 characters. @@
More information about the Bf-blender-cvs
mailing list