[Bf-blender-cvs] [94248012532] refactor-mesh-corners-generic: Merge branch 'refactor-mesh-position-generic' into refactor-mesh-corners-generic
Hans Goudey
noreply at git.blender.org
Wed Nov 30 16:15:14 CET 2022
Commit: 94248012532e96ab99187b9715a6f3d4b716f892
Author: Hans Goudey
Date: Tue Nov 29 22:02:02 2022 -0600
Branches: refactor-mesh-corners-generic
https://developer.blender.org/rB94248012532e96ab99187b9715a6f3d4b716f892
Merge branch 'refactor-mesh-position-generic' into refactor-mesh-corners-generic
===================================================================
===================================================================
diff --cc source/blender/blenkernel/BKE_mesh_mapping.h
index f1eb455ff6d,b5db649bb9a..34194f901e9
--- a/source/blender/blenkernel/BKE_mesh_mapping.h
+++ b/source/blender/blenkernel/BKE_mesh_mapping.h
@@@ -351,9 -349,10 +351,12 @@@ namespace blender::bke::mesh_topology
Array<int> build_loop_to_poly_map(Span<MPoly> polys, int loops_num);
Array<Vector<int>> build_vert_to_edge_map(Span<MEdge> edges, int verts_num);
-Array<Vector<int>> build_vert_to_poly_map(Span<MPoly> polys, Span<MLoop> loops, int verts_num);
-Array<Vector<int>> build_vert_to_loop_map(Span<MLoop> loops, int verts_num);
-Array<Vector<int>> build_edge_to_loop_map(Span<MLoop> loops, int edges_num);
-Vector<Vector<int>> build_edge_to_loop_map_resizable(Span<MLoop> loops, int edges_num);
++Array<Vector<int>> build_vert_to_poly_map(Span<MPoly> polys,
++ Span<int> corner_verts,
++ int verts_num);
+Array<Vector<int>> build_vert_to_loop_map(Span<int> corner_verts, int verts_num);
+Array<Vector<int>> build_edge_to_loop_map(Span<int> corner_edges, int edges_num);
+Vector<Vector<int>> build_edge_to_loop_map_resizable(Span<int> corner_edges, int edges_num);
inline int previous_poly_loop(const MPoly &poly, int loop_i)
{
diff --cc source/blender/blenkernel/intern/mesh.cc
index 6048e60d1b7,9f40cc381b8..1a7a4f028dc
--- a/source/blender/blenkernel/intern/mesh.cc
+++ b/source/blender/blenkernel/intern/mesh.cc
@@@ -1468,24 -1485,18 +1468,21 @@@ int BKE_mesh_edge_other_vert(const MEdg
return -1;
}
- void BKE_mesh_looptri_get_real_edges(const Mesh *mesh, const MLoopTri *looptri, int r_edges[3])
+ void BKE_mesh_looptri_get_real_edges(const MEdge *edges,
+ const MLoop *loops,
+ const MLoopTri *tri,
+ int r_edges[3])
{
+ const Span<MEdge> edges = mesh->edges();
- const Span<int> corner_edges = mesh->corner_edges();
- const Span<int> corner_verts = mesh->corner_edges();
++ const Span<MLoop> loops = mesh->loops();
+
for (int i = 2, i_next = 0; i_next < 3; i = i_next++) {
- const int corner_1 = looptri->tri[i];
- const int corner_2 = looptri->tri[i_next];
- const int vert_1 = corner_verts[corner_1];
- const int vert_2 = corner_verts[corner_1];
- const int edge_1 = corner_edges[corner_1];
- const int edge_2 = corner_edges[corner_1];
- const MEdge *e = &edges[edge_1];
- const MLoop *l1 = &loops[tri->tri[i]], *l2 = &loops[tri->tri[i_next]];
++ const MLoop *l1 = &loops[looptri->tri[i]], *l2 = &loops[looptri->tri[i_next]];
+ const MEdge *e = &edges[l1->e];
- bool is_real = (l1->v == e->v1 && l2->v == e->v2) || (l1->v == e->v2 && l2->v == e->v1);
+ bool is_real = (vert_1 == e->v1 && vert_2 == e->v2) || (vert_1 == e->v2 && vert_2 == e->v1);
- r_edges[i] = is_real ? l1->e : -1;
+ r_edges[i] = is_real ? edge_1 : -1;
}
}
diff --cc source/blender/blenkernel/intern/mesh_mapping.cc
index a1317ccb59a,f564634d77b..85cc9f60535
--- a/source/blender/blenkernel/intern/mesh_mapping.cc
+++ b/source/blender/blenkernel/intern/mesh_mapping.cc
@@@ -569,11 -576,25 +569,25 @@@ Array<Vector<int>> build_vert_to_edge_m
return map;
}
+ Array<Vector<int>> build_vert_to_poly_map(const Span<MPoly> polys,
- const Span<MLoop> loops,
++ const Span<int> corner_verts,
+ int verts_num)
+ {
+ Array<Vector<int>> map(verts_num);
+ for (const int64_t i : polys.index_range()) {
+ const MPoly &poly = polys[i];
- for (const MLoop &loop : loops.slice(poly.loopstart, poly.totloop)) {
- map[loop.v].append(int(i));
++ for (const int64_t vert_i : corner_verts.slice(poly.loopstart, poly.totloop)) {
++ map[int(vert_i)].append(int(i));
+ }
+ }
+ return map;
+ }
+
-Array<Vector<int>> build_vert_to_loop_map(const Span<MLoop> loops, const int verts_num)
+Array<Vector<int>> build_vert_to_loop_map(const Span<int> corner_verts, const int verts_num)
{
Array<Vector<int>> map(verts_num);
- for (const int64_t i : loops.index_range()) {
- map[loops[i].v].append(int(i));
+ for (const int64_t i : corner_verts.index_range()) {
+ map[corner_verts[i]].append(int(i));
}
return map;
}
diff --cc source/blender/blenkernel/intern/mesh_normals.cc
index 20a637cc325,23a026b56db..570195f529c
--- a/source/blender/blenkernel/intern/mesh_normals.cc
+++ b/source/blender/blenkernel/intern/mesh_normals.cc
@@@ -211,46 -209,35 +211,45 @@@ void BKE_mesh_calc_poly_normal(const MP
}
}
-static void calculate_normals_poly(const Span<float3> positions,
- const Span<MPoly> polys,
- const Span<MLoop> loops,
- MutableSpan<float3> poly_normals)
+struct MeshCalcNormalsData_Poly {
+ const float (*positions)[3];
- const int *corner_verts;
++ const MLoop *mloop;
+ const MPoly *mpoly;
+
+ /** Polygon normal output. */
+ float (*pnors)[3];
+};
+
+static void mesh_calc_normals_poly_fn(void *__restrict userdata,
+ const int pidx,
+ const TaskParallelTLS *__restrict /*tls*/)
{
- using namespace blender;
- threading::parallel_for(polys.index_range(), 1024, [&](const IndexRange range) {
- for (const int poly_i : range) {
- const MPoly &poly = polys[poly_i];
- BKE_mesh_calc_poly_normal(&poly,
- &loops[poly.loopstart],
- reinterpret_cast<const float(*)[3]>(positions.data()),
- poly_normals[poly_i]);
- }
- });
+ const MeshCalcNormalsData_Poly *data = (MeshCalcNormalsData_Poly *)userdata;
+ const MPoly *mp = &data->mpoly[pidx];
- BKE_mesh_calc_poly_normal(
- mp, data->corner_verts + mp->loopstart, data->positions, data->pnors[pidx]);
++ BKE_mesh_calc_poly_normal(mp, data->mloop + mp->loopstart, data->positions, data->pnors[pidx]);
}
void BKE_mesh_calc_normals_poly(const float (*positions)[3],
- const int verts_num,
+ int /*mvert_len*/,
- const int *corner_verts,
+ const MLoop *mloop,
- const int mloop_len,
+ int /*mloop_len*/,
const MPoly *mpoly,
int mpoly_len,
float (*r_poly_normals)[3])
{
- calculate_normals_poly({reinterpret_cast<const float3 *>(positions), mpoly_len},
- {mpoly, mpoly_len},
- {mloop, mloop_len},
- {reinterpret_cast<float3 *>(r_poly_normals), mpoly_len});
+ TaskParallelSettings settings;
+ BLI_parallel_range_settings_defaults(&settings);
+ settings.min_iter_per_thread = 1024;
+
+ BLI_assert((r_poly_normals != nullptr) || (mpoly_len == 0));
+
+ MeshCalcNormalsData_Poly data = {};
+ data.mpoly = mpoly;
- data.corner_verts = corner_verts;
++ data.mloop = mloop;
+ data.positions = positions;
+ data.pnors = r_poly_normals;
+
+ BLI_task_parallel_range(0, mpoly_len, &data, mesh_calc_normals_poly_fn, &settings);
}
/** \} */
@@@ -262,122 -249,110 +261,122 @@@
* meshes can slow down high-poly meshes. For details on performance, see D11993.
* \{ */
-static void calculate_normals_poly_and_vert(const Span<float3> positions,
- const Span<MPoly> polys,
- const Span<MLoop> loops,
- MutableSpan<float3> poly_normals,
- MutableSpan<float3> vert_normals)
-{
- using namespace blender;
+struct MeshCalcNormalsData_PolyAndVertex {
+ const float (*positions)[3];
- const int *corner_verts;
++ const MLoop *mloop;
+ const MPoly *mpoly;
- /** Polygon normal output. */
- float (*pnors)[3];
- /** Vertex normal output. */
- float (*vnors)[3];
- };
-
- static void mesh_calc_normals_poly_and_vertex_accum_fn(void *__restrict userdata,
- const int pidx,
- const TaskParallelTLS *__restrict /*tls*/)
- {
- const MeshCalcNormalsData_PolyAndVertex *data = (MeshCalcNormalsData_PolyAndVertex *)userdata;
- const MPoly *mp = &data->mpoly[pidx];
- const int *corner_verts = data->corner_verts;
- const float(*positions)[3] = data->positions;
- float(*vnors)[3] = data->vnors;
-
- float pnor_temp[3];
- float *pnor = data->pnors ? data->pnors[pidx] : pnor_temp;
-
- const int i_end = mp->totloop - 1;
-
- /* Polygon Normal and edge-vector. */
- /* Inline version of #BKE_mesh_calc_poly_normal, also does edge-vectors. */
+ /* Zero the vertex normal array for accumulation. */
{
- zero_v3(pnor);
- /* Newell's Method */
- const float *v_curr = positions[corner_verts[i_end]];
- for (int i_next = 0; i_next <= i_end; i_next++) {
- const float *v_next = positions[corner_verts[i_next]];
- add_newell_cross_v3_v3v3(pnor, v_curr, v_next);
- v_curr = v_next;
- }
- if (UNLIKELY(normalize_v3(pnor) == 0.0f)) {
- pnor[2] = 1.0f; /* Other axes set to zero. */
- }
+ memset(vert_normals.data(), 0, vert_normals.as_span().size_in_bytes());
}
- /* Accumulate angle weighted face normal into the vertex normal. */
- /* Inline version of #accumulate_vertex_normals_poly_v3. */
- /* Compute poly normals, accumulating them into vertex normals. */
++ static void mesh_calc_normals_poly_and_vertex_accum_fn(void *__restrict userdata,
++ const int pidx,
++ const TaskParallelTLS *__restrict /*tls*/)
{
- float edvec_prev[3],
@@ Diff output truncated at 10240 characters. @@
More information about the Bf-blender-cvs
mailing list