[Bf-blender-cvs] [7acd3ad7d8e] master: Cleanup: Use simpler loops in weld modifier
Hans Goudey
noreply at git.blender.org
Tue Dec 21 01:03:20 CET 2021
Commit: 7acd3ad7d8e58b913c563edad2fb2abfee5a3b6b
Author: Hans Goudey
Date: Mon Dec 20 18:03:06 2021 -0600
Branches: master
https://developer.blender.org/rB7acd3ad7d8e58b913c563edad2fb2abfee5a3b6b
Cleanup: Use simpler loops in weld modifier
In this commit I changed many loops to range-based for loops.
I also removed some of the redundant iterator variables, using
indexing inside the loop instead. Generally an optimizing compiler
should have no problem doing the smartest thing in that situation,
and this way makes it much easier to tell where data is coming from.
I only changed the loops I was confident about, so there is still more
that could be done in the future.
Differential Revision: https://developer.blender.org/D13637
===================================================================
M source/blender/modifiers/intern/MOD_weld.cc
===================================================================
diff --git a/source/blender/modifiers/intern/MOD_weld.cc b/source/blender/modifiers/intern/MOD_weld.cc
index ac93f50edf4..d117d86014e 100644
--- a/source/blender/modifiers/intern/MOD_weld.cc
+++ b/source/blender/modifiers/intern/MOD_weld.cc
@@ -37,6 +37,7 @@
#include "BLI_array.hh"
#include "BLI_bitmap.h"
+#include "BLI_index_range.hh"
#include "BLI_kdtree.h"
#include "BLI_math.h"
#include "BLI_span.hh"
@@ -72,6 +73,7 @@
#include "MOD_ui_common.h"
using blender::Array;
+using blender::IndexRange;
using blender::MutableSpan;
using blender::Span;
using blender::Vector;
@@ -374,23 +376,20 @@ static void weld_assert_poly_len(const WeldPoly *wp, const Span<WeldLoop> wloop)
/** \name Weld Vert API
* \{ */
-static Vector<WeldVert> weld_vert_ctx_alloc_and_setup(const int mvert_len,
- Span<int> vert_dest_map)
+static Vector<WeldVert> weld_vert_ctx_alloc_and_setup(Span<int> vert_dest_map)
{
Vector<WeldVert> wvert;
- wvert.reserve(mvert_len);
+ wvert.reserve(vert_dest_map.size());
- const int *v_dest_iter = &vert_dest_map[0];
- for (int i = 0; i < mvert_len; i++, v_dest_iter++) {
- if (*v_dest_iter != OUT_OF_CONTEXT) {
- wvert.append({*v_dest_iter, i});
+ for (const int i : vert_dest_map.index_range()) {
+ if (vert_dest_map[i] != OUT_OF_CONTEXT) {
+ wvert.append({vert_dest_map[i], i});
}
}
return wvert;
}
-static void weld_vert_groups_setup(const int mvert_len,
- Span<WeldVert> wvert,
+static void weld_vert_groups_setup(Span<WeldVert> wvert,
Span<int> vert_dest_map,
MutableSpan<int> r_vert_groups_map,
Array<int> &r_vert_groups_buffer,
@@ -399,21 +398,19 @@ static void weld_vert_groups_setup(const int mvert_len,
/* Get weld vert groups. */
int wgroups_len = 0;
- const int *vert_dest_iter = &vert_dest_map[0];
- int *group_map_iter = &r_vert_groups_map[0];
- for (int i = 0; i < mvert_len; i++, group_map_iter++, vert_dest_iter++) {
- int vert_dest = *vert_dest_iter;
+ for (const int i : vert_dest_map.index_range()) {
+ const int vert_dest = vert_dest_map[i];
if (vert_dest != OUT_OF_CONTEXT) {
if (vert_dest != i) {
- *group_map_iter = ELEM_MERGED;
+ r_vert_groups_map[i] = ELEM_MERGED;
}
else {
- *group_map_iter = wgroups_len;
+ r_vert_groups_map[i] = wgroups_len;
wgroups_len++;
}
}
else {
- *group_map_iter = OUT_OF_CONTEXT;
+ r_vert_groups_map[i] = OUT_OF_CONTEXT;
}
}
@@ -421,31 +418,27 @@ static void weld_vert_groups_setup(const int mvert_len,
r_vert_groups.fill({0, 0});
MutableSpan<WeldGroup> wgroups = r_vert_groups;
- const WeldVert *wv = &wvert[0];
- for (int i = wvert.size(); i--; wv++) {
- int group_index = r_vert_groups_map[wv->vert_dest];
+ for (const WeldVert &wv : wvert) {
+ int group_index = r_vert_groups_map[wv.vert_dest];
wgroups[group_index].len++;
}
int ofs = 0;
- WeldGroup *wg_iter = &wgroups[0];
- for (int i = wgroups_len; i--; wg_iter++) {
- wg_iter->ofs = ofs;
- ofs += wg_iter->len;
+ for (WeldGroup &wg : wgroups) {
+ wg.ofs = ofs;
+ ofs += wg.len;
}
BLI_assert(ofs == wvert.size());
r_vert_groups_buffer.reinitialize(ofs);
- wv = &wvert[0];
- for (int i = wvert.size(); i--; wv++) {
- int group_index = r_vert_groups_map[wv->vert_dest];
- r_vert_groups_buffer[wgroups[group_index].ofs++] = wv->vert_orig;
+ for (const WeldVert &wv : wvert) {
+ int group_index = r_vert_groups_map[wv.vert_dest];
+ r_vert_groups_buffer[wgroups[group_index].ofs++] = wv.vert_orig;
}
- wg_iter = &wgroups[0];
- for (int i = wgroups_len; i--; wg_iter++) {
- wg_iter->ofs -= wg_iter->len;
+ for (WeldGroup &wg : wgroups) {
+ wg.ofs -= wg.len;
}
}
@@ -455,29 +448,24 @@ static void weld_vert_groups_setup(const int mvert_len,
/** \name Weld Edge API
* \{ */
-static void weld_edge_ctx_setup(const int mvert_len,
- MutableSpan<WeldGroup> r_vlinks,
+static void weld_edge_ctx_setup(MutableSpan<WeldGroup> r_vlinks,
MutableSpan<int> r_edge_dest_map,
MutableSpan<WeldEdge> r_wedge,
int *r_edge_kiil_len)
{
- WeldEdge *we;
-
/* Setup Edge Overlap. */
int edge_kill_len = 0;
MutableSpan<WeldGroup> v_links = r_vlinks;
- WeldGroup *vl_iter = &r_vlinks[0];
- we = &r_wedge[0];
- for (int i = r_wedge.size(); i--; we++) {
- int dst_vert_a = we->vert_a;
- int dst_vert_b = we->vert_b;
+ for (WeldEdge &we : r_wedge) {
+ int dst_vert_a = we.vert_a;
+ int dst_vert_b = we.vert_b;
if (dst_vert_a == dst_vert_b) {
- BLI_assert(we->edge_dest == OUT_OF_CONTEXT);
- r_edge_dest_map[we->edge_orig] = ELEM_COLLAPSED;
- we->flag = ELEM_COLLAPSED;
+ BLI_assert(we.edge_dest == OUT_OF_CONTEXT);
+ r_edge_dest_map[we.edge_orig] = ELEM_COLLAPSED;
+ we.flag = ELEM_COLLAPSED;
edge_kill_len++;
continue;
}
@@ -487,44 +475,42 @@ static void weld_edge_ctx_setup(const int mvert_len,
}
int link_len = 0;
- vl_iter = &v_links[0];
- for (int i = mvert_len; i--; vl_iter++) {
- vl_iter->ofs = link_len;
- link_len += vl_iter->len;
+ for (WeldGroup &vl : r_vlinks) {
+ vl.ofs = link_len;
+ link_len += vl.len;
}
if (link_len > 0) {
Array<int> link_edge_buffer(link_len);
- we = &r_wedge[0];
- for (int i = 0; i < r_wedge.size(); i++, we++) {
- if (we->flag == ELEM_COLLAPSED) {
+ for (const int i : r_wedge.index_range()) {
+ const WeldEdge &we = r_wedge[i];
+ if (we.flag == ELEM_COLLAPSED) {
continue;
}
- int dst_vert_a = we->vert_a;
- int dst_vert_b = we->vert_b;
+ int dst_vert_a = we.vert_a;
+ int dst_vert_b = we.vert_b;
link_edge_buffer[v_links[dst_vert_a].ofs++] = i;
link_edge_buffer[v_links[dst_vert_b].ofs++] = i;
}
- vl_iter = &v_links[0];
- for (int i = mvert_len; i--; vl_iter++) {
+ for (WeldGroup &vl : r_vlinks) {
/* Fix offset */
- vl_iter->ofs -= vl_iter->len;
+ vl.ofs -= vl.len;
}
- we = &r_wedge[0];
- for (int i = 0; i < r_wedge.size(); i++, we++) {
- if (we->edge_dest != OUT_OF_CONTEXT) {
+ for (const int i : r_wedge.index_range()) {
+ const WeldEdge &we = r_wedge[i];
+ if (we.edge_dest != OUT_OF_CONTEXT) {
/* No need to retest edges.
* (Already includes collapsed edges). */
continue;
}
- int dst_vert_a = we->vert_a;
- int dst_vert_b = we->vert_b;
+ int dst_vert_a = we.vert_a;
+ int dst_vert_b = we.vert_b;
struct WeldGroup *link_a = &v_links[dst_vert_a];
struct WeldGroup *link_b = &v_links[dst_vert_b];
@@ -538,7 +524,7 @@ static void weld_edge_ctx_setup(const int mvert_len,
int *edges_ctx_a = &link_edge_buffer[link_a->ofs];
int *edges_ctx_b = &link_edge_buffer[link_b->ofs];
- int edge_orig = we->edge_orig;
+ int edge_orig = we.edge_orig;
for (; edges_len_a--; edges_ctx_a++) {
int e_ctx_a = *edges_ctx_a;
@@ -586,12 +572,9 @@ static Vector<WeldEdge> weld_edge_ctx_alloc(const MEdge *medge,
Vector<WeldEdge> wedge;
wedge.reserve(medge_len);
- const MEdge *me = &medge[0];
- int *e_dest_iter = &r_edge_dest_map[0];
- int *iter = &r_edge_ctx_map[0];
- for (int i = 0; i < medge_len; i++, me++, iter++, e_dest_iter++) {
- int v1 = me->v1;
- int v2 = me->v2;
+ for (const int i : IndexRange(medge_len)) {
+ int v1 = medge[i].v1;
+ int v2 = medge[i].v2;
int v_dest_1 = vert_dest_map[v1];
int v_dest_2 = vert_dest_map[v2];
if ((v_dest_1 != OUT_OF_CONTEXT) || (v_dest_2 != OUT_OF_CONTEXT)) {
@@ -601,12 +584,12 @@ static Vector<WeldEdge> weld_edge_ctx_alloc(const MEdge *medge,
we.edge_dest = OUT_OF_CONTEXT;
we.edge_orig = i;
wedge.append(we);
- *e_dest_iter = i;
- *iter = wedge_len++;
+ r_edge_dest_map[i] = i;
+ r_edge_ctx_map[i] = wedge_len++;
}
else {
- *e_dest_iter = OUT_OF_CONTEXT;
- *iter = OUT_OF_CONTEXT;
+ r_edge_dest_map[i] = OUT_OF_CONTEXT;
+ r_edge_ctx_map[i] = OUT_OF_CONTEXT;
}
}
@@ -633,62 +616,56 @@ static void weld_edge_groups_setup(const int medge_len,
wegrp_iter = &r_edge_groups[0];
wgroups_len = 0;
- const int *edge_ctx_iter = &wedge_map[0];
- int *group_map_iter = &r_edge_groups_map[0];
- for (int i = medge_len; i--; edge_ctx_iter++, group_map_iter++) {
- int edge_ctx = *edge_ctx_iter;
+ for (const int i : IndexRange(medge_len)) {
+ int edge_ctx = wedge_map[i];
if (edge_ctx != OUT_OF_CONTEXT) {
WeldEdge *we = &wedge[edge_ctx];
int edge_dest = we->edge_dest;
if (edge_dest != OUT_OF_CONTEXT) {
BLI_assert(edge_dest != we->edge_orig);
- *group_map_iter = ELEM_MERGED;
+ r_edge_groups_map[i] = ELEM_MERGED;
}
else {
we->edge_dest = we->edge_orig;
wegrp_iter->v1 = we->vert_a;
wegrp_iter->v2 = we->vert_b;
- *group_map_iter = wgroups_len;
+ r_edge_groups_map[i] = wgroups_len;
wgroups_len++;
wegrp_iter++;
}
}
else {
- *group_map_iter = OUT_OF_CONTEXT;
+ r_edge_groups_map[i] = OUT_OF_CONTEXT;
}
}
BLI_assert(wgroups_len == wedge.size() - edge_kill_len);
- WeldEdge *we = &wedge[0];
- for (int i = wedge.size(); i--; we++) {
- if (we->flag == ELEM_COLLAPSED) {
+ for (const WeldEdge &we : wedge) {
+ if (we.flag == ELEM_COLLAPSED) {
continue;
}
- int group_index = r_edge_groups_map[we->edge_dest];
+ int group_index = r_edge_groups_map[we.edge_dest];
wegroups[group_index].group.len++;
}
int ofs = 0;
- wegrp_iter = &wegroups[0];
- for (int i = wgroups_len; i--; wegrp_iter++) {
- wegrp_iter->group.ofs = ofs;
- ofs += wegrp_iter->group.len;
+ for (WeldGroupEdge &wegrp : wegroups) {
+ wegrp.group.ofs = ofs;
+ ofs += wegrp.group.len;
@@ Diff output truncated at 10240 characters. @@
More information about the Bf-blender-cvs
mailing list