griefith/test
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

Cleanup: Various changes for calc_area_normal_and_center

Browse Source 
* Remove `_r` suffix from internal variable
* Use bitflag instead of two booleans for function parameter

Pull Request: https://projects.blender.org/blender/blender/pulls/144597
This commit is contained in:
Sean Kim
2025-08-21 03:36:52 +02:00
committed by Sean Kim
parent 884ab7beb6
commit e648f1fcbc
1 changed files with 72 additions and 54 deletions
Download Patch File Download Diff File Expand all files Collapse all files

126
source/blender/editors/sculpt_paint/sculpt.cc
View File

@@ -1355,13 +1355,20 @@ struct SampleLocalData {
Vector<float> distances; Vector<float> distances;
}; };
enum class AverageDataFlags : uint8_t {
Position = 1 << 0,
Normal = 1 << 1,
All = Position | Normal
};
ENUM_OPERATORS(AverageDataFlags, AverageDataFlags::Normal);
static void calc_area_normal_and_center_node_mesh(const Object &object, static void calc_area_normal_and_center_node_mesh(const Object &object,
const Span<float3> vert_positions, const Span<float3> vert_positions,
const Span<float3> vert_normals, const Span<float3> vert_normals,
const Span<bool> hide_vert, const Span<bool> hide_vert,
const Brush &brush, const Brush &brush,
const bool use_area_nos, const AverageDataFlags flag,
const bool use_area_cos,
const bke::pbvh::MeshNode &node, const bke::pbvh::MeshNode &node,
SampleLocalData &tls, SampleLocalData &tls,
AreaNormalCenterData &anctd) AreaNormalCenterData &anctd)
@@ -1395,19 +1402,21 @@ static void calc_area_normal_and_center_node_mesh(const Object &object,
if (!hide_vert.is_empty() && hide_vert[vert]) { if (!hide_vert.is_empty() && hide_vert[vert]) {
continue; continue;
} }
const bool normal_test_r = use_area_nos && distances_sq[i] <= normal_radius_sq; const bool needs_normal = bool(flag & AverageDataFlags::Normal) &&
const bool area_test_r = use_area_cos && distances_sq[i] <= position_radius_sq; distances_sq[i] <= normal_radius_sq;
if (!normal_test_r && !area_test_r) { const bool needs_center = bool(flag & AverageDataFlags::Position) &&
distances_sq[i] <= position_radius_sq;
if (!needs_normal && !needs_center) {
continue; continue;
} }
const float3 &normal = orig_normals[i]; const float3 &normal = orig_normals[i];
const float distance = std::sqrt(distances_sq[i]); const float distance = std::sqrt(distances_sq[i]);
const int flip_index = math::dot(view_normal, normal) <= 0.0f; const int flip_index = math::dot(view_normal, normal) <= 0.0f;
if (area_test_r) { if (needs_center) {
accumulate_area_center( accumulate_area_center(
location, orig_positions[i], distance, position_radius_inv, flip_index, anctd); location, orig_positions[i], distance, position_radius_inv, flip_index, anctd);
} }
if (normal_test_r) { if (needs_normal) {
accumulate_area_normal(normal, distance, normal_radius_inv, flip_index, anctd); accumulate_area_normal(normal, distance, normal_radius_inv, flip_index, anctd);
} }
} }
@@ -1425,19 +1434,21 @@ static void calc_area_normal_and_center_node_mesh(const Object &object,
if (!hide_vert.is_empty() && hide_vert[vert]) { if (!hide_vert.is_empty() && hide_vert[vert]) {
continue; continue;
} }
const bool normal_test_r = distances_sq[i] <= normal_radius_sq; const bool needs_normal = bool(flag & AverageDataFlags::Normal) &&
const bool area_test_r = distances_sq[i] <= position_radius_sq; distances_sq[i] <= normal_radius_sq;
if (!normal_test_r && !area_test_r) { const bool needs_center = bool(flag & AverageDataFlags::Position) &&
distances_sq[i] <= position_radius_sq;
if (!needs_normal && !needs_center) {
continue; continue;
} }
const float3 &normal = vert_normals[vert]; const float3 &normal = vert_normals[vert];
const float distance = std::sqrt(distances_sq[i]); const float distance = std::sqrt(distances_sq[i]);
const int flip_index = math::dot(view_normal, normal) <= 0.0f; const int flip_index = math::dot(view_normal, normal) <= 0.0f;
if (area_test_r) { if (needs_center) {
accumulate_area_center( accumulate_area_center(
location, vert_positions[vert], distance, position_radius_inv, flip_index, anctd); location, vert_positions[vert], distance, position_radius_inv, flip_index, anctd);
} }
if (normal_test_r) { if (needs_normal) {
accumulate_area_normal(normal, distance, normal_radius_inv, flip_index, anctd); accumulate_area_normal(normal, distance, normal_radius_inv, flip_index, anctd);
} }
} }
@@ -1445,8 +1456,7 @@ static void calc_area_normal_and_center_node_mesh(const Object &object,
static void calc_area_normal_and_center_node_grids(const Object &object, static void calc_area_normal_and_center_node_grids(const Object &object,
const Brush &brush, const Brush &brush,
const bool use_area_nos, const AverageDataFlags flag,
const bool use_area_cos,
const bke::pbvh::GridsNode &node, const bke::pbvh::GridsNode &node,
SampleLocalData &tls, SampleLocalData &tls,
AreaNormalCenterData &anctd) AreaNormalCenterData &anctd)
@@ -1488,15 +1498,17 @@ static void calc_area_normal_and_center_node_grids(const Object &object,
} }
const int node_vert = grid_range_node[offset]; const int node_vert = grid_range_node[offset];
const bool normal_test_r = use_area_nos && distances_sq[node_vert] <= normal_radius_sq; const bool needs_normal = bool(flag & AverageDataFlags::Normal) &&
const bool area_test_r = use_area_cos && distances_sq[node_vert] <= position_radius_sq; distances_sq[node_vert] <= normal_radius_sq;
if (!normal_test_r && !area_test_r) { const bool needs_center = bool(flag & AverageDataFlags::Position) &&
distances_sq[node_vert] <= position_radius_sq;
if (!needs_normal && !needs_center) {
continue; continue;
} }
const float3 &normal = orig_normals[node_vert]; const float3 &normal = orig_normals[node_vert];
const float distance = std::sqrt(distances_sq[node_vert]); const float distance = std::sqrt(distances_sq[node_vert]);
const int flip_index = math::dot(view_normal, normal) <= 0.0f; const int flip_index = math::dot(view_normal, normal) <= 0.0f;
if (area_test_r) { if (needs_center) {
accumulate_area_center(location, accumulate_area_center(location,
orig_positions[node_vert], orig_positions[node_vert],
distance, distance,
@@ -1504,7 +1516,7 @@ static void calc_area_normal_and_center_node_grids(const Object &object,
flip_index, flip_index,
anctd); anctd);
} }
if (normal_test_r) { if (needs_normal) {
accumulate_area_normal(normal, distance, normal_radius_inv, flip_index, anctd); accumulate_area_normal(normal, distance, normal_radius_inv, flip_index, anctd);
} }
} }
@@ -1530,19 +1542,21 @@ static void calc_area_normal_and_center_node_grids(const Object &object,
const int node_vert = grid_range_node[offset]; const int node_vert = grid_range_node[offset];
const int vert = grid_range[offset]; const int vert = grid_range[offset];
const bool normal_test_r = use_area_nos && distances_sq[node_vert] <= normal_radius_sq; const bool needs_normal = uint8_t(flag & AverageDataFlags::Normal) != 0 &&
const bool area_test_r = use_area_cos && distances_sq[node_vert] <= position_radius_sq; distances_sq[node_vert] <= normal_radius_sq;
if (!normal_test_r && !area_test_r) { const bool needs_center = uint8_t(flag & AverageDataFlags::Position) != 0 &&
distances_sq[node_vert] <= position_radius_sq;
if (!needs_normal && !needs_center) {
continue; continue;
} }
const float3 &normal = normals[vert]; const float3 &normal = normals[vert];
const float distance = std::sqrt(distances_sq[node_vert]); const float distance = std::sqrt(distances_sq[node_vert]);
const int flip_index = math::dot(view_normal, normal) <= 0.0f; const int flip_index = math::dot(view_normal, normal) <= 0.0f;
if (area_test_r) { if (needs_center) {
accumulate_area_center( accumulate_area_center(
location, positions[node_vert], distance, position_radius_inv, flip_index, anctd); location, positions[node_vert], distance, position_radius_inv, flip_index, anctd);
} }
if (normal_test_r) { if (needs_normal) {
accumulate_area_normal(normal, distance, normal_radius_inv, flip_index, anctd); accumulate_area_normal(normal, distance, normal_radius_inv, flip_index, anctd);
} }
} }
@@ -1551,8 +1565,7 @@ static void calc_area_normal_and_center_node_grids(const Object &object,
static void calc_area_normal_and_center_node_bmesh(const Object &object, static void calc_area_normal_and_center_node_bmesh(const Object &object,
const Brush &brush, const Brush &brush,
const bool use_area_nos, const AverageDataFlags flag,
const bool use_area_cos,
const bool has_bm_orco, const bool has_bm_orco,
const bke::pbvh::BMeshNode &node, const bke::pbvh::BMeshNode &node,
SampleLocalData &tls, SampleLocalData &tls,
@@ -1597,9 +1610,11 @@ static void calc_area_normal_and_center_node_bmesh(const Object &object,
ss, positions, eBrushFalloffShape(brush.falloff_shape), distances_sq); ss, positions, eBrushFalloffShape(brush.falloff_shape), distances_sq);
for (const int i : orig_tris.index_range()) { for (const int i : orig_tris.index_range()) {
const bool normal_test_r = use_area_nos && distances_sq[i] <= normal_radius_sq; const bool needs_normal = bool(flag & AverageDataFlags::Normal) &&
const bool area_test_r = use_area_cos && distances_sq[i] <= position_radius_sq; distances_sq[i] <= normal_radius_sq;
if (!normal_test_r && !area_test_r) { const bool needs_center = bool(flag & AverageDataFlags::Position) &&
distances_sq[i] <= position_radius_sq;
if (!needs_normal && !needs_center) {
continue; continue;
} }
const float3 normal = math::normal_tri(float3(orig_positions[orig_tris[i][0]]), const float3 normal = math::normal_tri(float3(orig_positions[orig_tris[i][0]]),
@@ -1608,11 +1623,11 @@ static void calc_area_normal_and_center_node_bmesh(const Object &object,
const float distance = std::sqrt(distances_sq[i]); const float distance = std::sqrt(distances_sq[i]);
const int flip_index = math::dot(view_normal, normal) <= 0.0f; const int flip_index = math::dot(view_normal, normal) <= 0.0f;
if (area_test_r) { if (needs_center) {
accumulate_area_center( accumulate_area_center(
location, positions[i], distance, position_radius_inv, flip_index, anctd); location, positions[i], distance, position_radius_inv, flip_index, anctd);
} }
if (normal_test_r) { if (needs_normal) {
accumulate_area_normal(normal, distance, normal_radius_inv, flip_index, anctd); accumulate_area_normal(normal, distance, normal_radius_inv, flip_index, anctd);
} }
} }
@@ -1638,20 +1653,22 @@ static void calc_area_normal_and_center_node_bmesh(const Object &object,
i++; i++;
continue; continue;
} }
const bool normal_test_r = use_area_nos && distances_sq[i] <= normal_radius_sq; const bool needs_normal = bool(flag & AverageDataFlags::Normal) &&
const bool area_test_r = use_area_cos && distances_sq[i] <= position_radius_sq; distances_sq[i] <= normal_radius_sq;
if (!normal_test_r && !area_test_r) { const bool needs_center = bool(flag & AverageDataFlags::Position) &&
distances_sq[i] <= position_radius_sq;
if (!needs_normal && !needs_center) {
i++; i++;
continue; continue;
} }
const float3 &normal = normals[i]; const float3 &normal = normals[i];
const float distance = std::sqrt(distances_sq[i]); const float distance = std::sqrt(distances_sq[i]);
const int flip_index = math::dot(view_normal, normal) <= 0.0f; const int flip_index = math::dot(view_normal, normal) <= 0.0f;
if (area_test_r) { if (needs_center) {
accumulate_area_center( accumulate_area_center(
location, positions[i], distance, position_radius_inv, flip_index, anctd); location, positions[i], distance, position_radius_inv, flip_index, anctd);
} }
if (normal_test_r) { if (needs_normal) {
accumulate_area_normal(normal, distance, normal_radius_inv, flip_index, anctd); accumulate_area_normal(normal, distance, normal_radius_inv, flip_index, anctd);
} }
i++; i++;
@@ -1672,20 +1689,22 @@ static void calc_area_normal_and_center_node_bmesh(const Object &object,
i++; i++;
continue; continue;
} }
const bool normal_test_r = use_area_nos && distances_sq[i] <= normal_radius_sq; const bool needs_normal = bool(flag & AverageDataFlags::Normal) &&
const bool area_test_r = use_area_cos && distances_sq[i] <= position_radius_sq; distances_sq[i] <= normal_radius_sq;
if (!normal_test_r && !area_test_r) { const bool needs_center = bool(flag & AverageDataFlags::Position) &&
distances_sq[i] <= position_radius_sq;
if (!needs_normal && !needs_center) {
i++; i++;
continue; continue;
} }
const float3 normal = vert->no; const float3 normal = vert->no;
const float distance = std::sqrt(distances_sq[i]); const float distance = std::sqrt(distances_sq[i]);
const int flip_index = math::dot(view_normal, normal) <= 0.0f; const int flip_index = math::dot(view_normal, normal) <= 0.0f;
if (area_test_r) { if (needs_center) {
accumulate_area_center( accumulate_area_center(
location, positions[i], distance, position_radius_inv, flip_index, anctd); location, positions[i], distance, position_radius_inv, flip_index, anctd);
} }
if (normal_test_r) { if (needs_normal) {
accumulate_area_normal(normal, distance, normal_radius_inv, flip_index, anctd); accumulate_area_normal(normal, distance, normal_radius_inv, flip_index, anctd);
} }
i++; i++;
@@ -1743,8 +1762,7 @@ void calc_area_center(const Depsgraph &depsgraph,
vert_normals, vert_normals,
hide_vert, hide_vert,
brush, brush,
false, AverageDataFlags::Position,
true,
nodes[i], nodes[i],
tls, tls,
anctd); anctd);
@@ -1766,7 +1784,7 @@ void calc_area_center(const Depsgraph &depsgraph,
SampleLocalData &tls = all_tls.local(); SampleLocalData &tls = all_tls.local();
node_mask.slice(range).foreach_index([&](const int i) { node_mask.slice(range).foreach_index([&](const int i) {
calc_area_normal_and_center_node_bmesh( calc_area_normal_and_center_node_bmesh(
ob, brush, false, true, has_bm_orco, nodes[i], tls, anctd); ob, brush, AverageDataFlags::Position, has_bm_orco, nodes[i], tls, anctd);
}); });
return anctd; return anctd;
}, },
@@ -1782,7 +1800,8 @@ void calc_area_center(const Depsgraph &depsgraph,
[&](const IndexRange range, AreaNormalCenterData anctd) { [&](const IndexRange range, AreaNormalCenterData anctd) {
SampleLocalData &tls = all_tls.local(); SampleLocalData &tls = all_tls.local();
node_mask.slice(range).foreach_index([&](const int i) { node_mask.slice(range).foreach_index([&](const int i) {
calc_area_normal_and_center_node_grids(ob, brush, false, true, nodes[i], tls, anctd); calc_area_normal_and_center_node_grids(
ob, brush, AverageDataFlags::Position, nodes[i], tls, anctd);
}); });
return anctd; return anctd;
}, },
@@ -1843,8 +1862,7 @@ std::optional<float3> calc_area_normal(const Depsgraph &depsgraph,
vert_normals, vert_normals,
hide_vert, hide_vert,
brush, brush,
true, AverageDataFlags::Normal,
false,
nodes[i], nodes[i],
tls, tls,
anctd); anctd);
@@ -1868,8 +1886,7 @@ std::optional<float3> calc_area_normal(const Depsgraph &depsgraph,
calc_area_normal_and_center_node_bmesh( calc_area_normal_and_center_node_bmesh(
ob, ob,
brush, brush,
true, AverageDataFlags::Normal,
false,
has_bm_orco, has_bm_orco,
static_cast<const blender::bke::pbvh::BMeshNode &>(nodes[i]), static_cast<const blender::bke::pbvh::BMeshNode &>(nodes[i]),
tls, tls,
@@ -1889,7 +1906,8 @@ std::optional<float3> calc_area_normal(const Depsgraph &depsgraph,
[&](const IndexRange range, AreaNormalCenterData anctd) { [&](const IndexRange range, AreaNormalCenterData anctd) {
SampleLocalData &tls = all_tls.local(); SampleLocalData &tls = all_tls.local();
node_mask.slice(range).foreach_index([&](const int i) { node_mask.slice(range).foreach_index([&](const int i) {
calc_area_normal_and_center_node_grids(ob, brush, true, false, nodes[i], tls, anctd); calc_area_normal_and_center_node_grids(
ob, brush, AverageDataFlags::Normal, nodes[i], tls, anctd);
}); });
return anctd; return anctd;
}, },
@@ -2042,8 +2060,7 @@ void calc_area_normal_and_center(const Depsgraph &depsgraph,
vert_normals, vert_normals,
hide_vert, hide_vert,
brush, brush,
true, AverageDataFlags::All,
true,
nodes[i], nodes[i],
tls, tls,
anctd); anctd);
@@ -2065,7 +2082,7 @@ void calc_area_normal_and_center(const Depsgraph &depsgraph,
SampleLocalData &tls = all_tls.local(); SampleLocalData &tls = all_tls.local();
node_mask.slice(range).foreach_index([&](const int i) { node_mask.slice(range).foreach_index([&](const int i) {
calc_area_normal_and_center_node_bmesh( calc_area_normal_and_center_node_bmesh(
ob, brush, true, true, has_bm_orco, nodes[i], tls, anctd); ob, brush, AverageDataFlags::All, has_bm_orco, nodes[i], tls, anctd);
}); });
return anctd; return anctd;
}, },
@@ -2081,7 +2098,8 @@ void calc_area_normal_and_center(const Depsgraph &depsgraph,
[&](const IndexRange range, AreaNormalCenterData anctd) { [&](const IndexRange range, AreaNormalCenterData anctd) {
SampleLocalData &tls = all_tls.local(); SampleLocalData &tls = all_tls.local();
node_mask.slice(range).foreach_index([&](const int i) { node_mask.slice(range).foreach_index([&](const int i) {
calc_area_normal_and_center_node_grids(ob, brush, true, true, nodes[i], tls, anctd); calc_area_normal_and_center_node_grids(
ob, brush, AverageDataFlags::All, nodes[i], tls, anctd);
}); });
return anctd; return anctd;
}, },