114namespace ed::sculpt_paint {
125 const float scale_factor)
169 return id_cast<const Mesh *>(
object.
data)->verts_num;
189 return mesh.vert_positions();
211 return face_set_none_id;
220 return face_set_none_id;
224 return face_sets[face_index];
227 return face_set_none_id;
229 return face_set_none_id;
237 for (
const int face : vert_to_face_map[vert]) {
246 return face_sets[face];
251 return face_set_none_id;
259 for (
const int face : vert_to_face_map[vert]) {
260 result.add(face_sets[face]);
263 result.add(face_set_none_id);
274 return face_set == face_set_none_id;
276 const Span<int> faces = vert_to_face_map[vert];
278 faces.
begin(), faces.
end(), [&](
const int face) { return face_sets[face] == face_set; });
287 return face_set == face_set_none_id;
295 if (face_set_offset == -1) {
296 return face_set == face_set_none_id;
314 return allowed_face_sets.
contains(face_set_none_id);
316 for (
const int face : vert_to_face_map[vert]) {
317 if (allowed_face_sets.
contains(face_sets[face])) {
333 for (
const int face_index : vert_to_face_map[vert]) {
338 if (face_sets[face_index] !=
face_set) {
358 const Span<int> vert_map = vert_to_face_map[v1];
359 int p1 = -1, p2 = -1;
360 for (
int i = 0; i < vert_map.
size(); i++) {
361 const int face_i = vert_map[i];
362 for (
const int corner : faces[face_i]) {
363 if (corner_verts[corner] ==
v2) {
377 if (p1 != -1 && p2 != -1) {
378 return face_sets[p1] == face_sets[p2];
396 subdiv_ccg, coord, corner_verts, faces, v1,
v2);
402 vert_to_face_map, face_sets, corner_verts, faces, v1,
v2);
419 return face_set == face_set_none_id;
429 faces, corner_verts, vert_to_face_map, face_sets, subdiv_ccg, coord, allowed_face_sets);
441 return allowed_face_sets.
contains(face_set_none_id);
450 subdiv_ccg, coord, corner_verts, faces, v1,
v2);
453 for (
const int face : vert_to_face_map[v1]) {
454 if (allowed_face_sets.
contains(face_sets[face])) {
461 for (
const int face : vert_to_face_map[v1]) {
466 if (allowed_face_sets.
contains(face_sets[face])) {
473 return allowed_face_sets.
contains(face_sets[face]);
497 if (other_vert != &vert) {
498 r_neighbors.
append(other_vert);
512 if (other_vert != &vert) {
513 r_neighbors.
append(other_vert);
519 if (r_neighbors.
size() == 2) {
543 for (
const int face : vert_to_face[vert]) {
544 if (!hide_poly.
is_empty() && hide_poly[face]) {
562 const int vert_start = r_data.
size();
563 for (
const int face : vert_to_face[vert]) {
564 if (!hide_poly.
is_empty() && hide_poly[face]) {
570 for (
const int neighbor : {neighbors[0], neighbors[1]}) {
572 for (
int i = r_data.
size() - 1; i >= vert_start; i--) {
573 if (r_data[i] == neighbor) {
609 if (adjacent_faces_edge_count[
e] < 2) {
610 const int2 &edge = edges[
e];
611 boundary_info.
edges.add(edge);
612 boundary_info.
verts[edge[0]].set();
613 boundary_info.
verts[edge[1]].set();
617 return boundary_info;
628 return boundary_verts[vert].test();
641 faces, corner_verts, boundary_verts, boundary_edges, subdiv_ccg, vert);
674 bool is_in_symmetry_area =
true;
675 for (
int i = 0; i < 3; i++) {
676 char symm_it = 1 << i;
677 if (symm & symm_it) {
678 if (pco[i] == 0.0f) {
680 is_in_symmetry_area =
false;
683 if (vco[i] * pco[i] < 0.0f) {
684 is_in_symmetry_area =
false;
688 return is_in_symmetry_area;
697 const float normal_weight,
705 float len_view_scale;
707 float view_aligned_normal[3];
710 len_view_scale = (len_view_scale >
FLT_EPSILON) ? 1.0f / len_view_scale : 1.0f;
713 mul_v3_fl(grab_delta, 1.0f - normal_weight);
723 if (normal_weight > 0.0f) {
734 const float max_distance,
735 const bool use_original)
737 const float max_distance_sq = max_distance * max_distance;
749 float distance_sq = std::numeric_limits<float>::max();
757 [&](
const IndexRange range, NearestData nearest) {
759 for (
const int vert :
nodes[i].verts()) {
760 if (!hide_vert.
is_empty() && hide_vert[vert]) {
764 if (distance_sq < nearest.distance_sq) {
765 nearest = {vert, distance_sq};
771 [](
const NearestData a,
const NearestData
b) {
772 return a.distance_sq <
b.distance_sq ? a :
b;
780 const float max_distance,
781 const bool use_original)
783 const float max_distance_sq = max_distance * max_distance;
795 float distance_sq = std::numeric_limits<float>::max();
807 [&](
const IndexRange range, NearestData nearest) {
809 for (
const int grid :
nodes[i].grids()) {
813 if (distance_sq < nearest.distance_sq) {
818 nearest = {coord, distance_sq};
825 [](
const NearestData a,
const NearestData
b) {
826 return a.distance_sq <
b.distance_sq ? a :
b;
828 return nearest.coord;
833 const float max_distance,
834 const bool use_original)
836 const float max_distance_sq = max_distance * max_distance;
848 float distance_sq = std::numeric_limits<float>::max();
856 [&](
const IndexRange range, NearestData nearest) {
865 if (distance_sq < nearest.distance_sq) {
866 nearest = {vert, distance_sq};
872 [](
const NearestData a,
const NearestData
b) {
873 return a.distance_sq <
b.distance_sq ? a :
b;
879 const float br_co[3],
883 for (
char i = 0; i <= symm; ++i) {
922 return ELEM(sculpt_brush_type,
1017 switch (
pbvh.type()) {
1032 node_changed[i] =
true;
1049 node_changed[i] =
true;
1069 for (
const int grid :
nodes[i].grids()) {
1072 if (grid_hidden.
is_empty() || !grid_hidden[grid][i]) {
1079 node_changed[i] =
true;
1095 nodes.index_range(),
1097 [&](
const int i) { return orig_color_data_lookup_mesh(object, nodes[i]).has_value(); },
1117 color_attribute.
span);
1121 pbvh.tag_attribute_changed(node_mask,
mesh.active_color_attribute);
1122 color_attribute.
finish();
1134 switch (
pbvh.type()) {
1138 *id_cast<Mesh *>(
object.
data));
1145 node_changed[i] =
true;
1156 *id_cast<Mesh *>(
object.
data));
1165 subdiv_ccg,
nodes[i], tls);
1167 node_changed[i] =
true;
1187 switch (
pbvh.type()) {
1195 nodes.index_range(),
1198 return orig_position_data_lookup_mesh(object, nodes[i]).has_value();
1207 const bool need_translations = !ss.
deform_imats.is_empty() || shape_key_data.has_value();
1213 LocalData &tls = all_tls.
local();
1217 if (need_translations) {
1219 tls.translations.resize(verts.
size());
1221 undo_positions, verts, positions_eval, tls.translations);
1226 if (positions_eval.
data() == positions_orig.
data()) {
1235 if (shape_key_data) {
1240 if (shape_key_data->basis_key_active) {
1252 pbvh.tag_positions_changed(node_mask);
1270 pbvh.tag_positions_changed(node_mask);
1277 nodes.index_range(),
1280 return orig_position_data_lookup_grids(object, nodes[i]).has_value();
1288 node_mask.foreach_index(
1292 for (
const int grid :
nodes[i].grids()) {
1295 if (grid_hidden.
is_empty() || !grid_hidden[grid][i]) {
1303 pbvh.tag_positions_changed(node_mask);
1314 switch (
brush->sculpt_brush_type) {
1379 test_radius *=
brush.normal_radius_factor;
1391 test_radius *=
brush.area_radius_factor;
1397 test_radius *=
brush.normal_radius_factor;
1406 float p = 1.0f - (
distance * radius_inv);
1407 return std::clamp(3.0f * p * p - 2.0f * p * p * p, 0.0f, 1.0f);
1413 const float radius_inv,
1417 float p = 1.0f - (
distance * radius_inv);
1418 const float afactor = std::clamp(3.0f * p * p - 2.0f * p * p * p, 0.0f, 1.0f);
1420 const float3 disp = (co - test_location) * (1.0f - afactor);
1421 return test_location + disp;
1427 const float radius_inv,
1428 const int flip_index,
1438 const float radius_inv,
1439 const int flip_index,
1473 const float position_radius_sq = position_radius * position_radius;
1474 const float position_radius_inv =
math::rcp(position_radius);
1476 const float normal_radius_sq = normal_radius * normal_radius;
1477 const float normal_radius_inv =
math::rcp(normal_radius);
1487 const Span<float3> orig_positions = orig_data->positions;
1494 const int vert = verts[i];
1495 if (!hide_vert.
is_empty() && hide_vert[vert]) {
1499 distances_sq[i] <= normal_radius_sq;
1501 distances_sq[i] <= position_radius_sq;
1502 if (!needs_normal && !needs_center) {
1505 const float3 &normal = orig_normals[i];
1506 const float distance = std::sqrt(distances_sq[i]);
1507 const int flip_index =
math::dot(view_normal, normal) <= 0.0f;
1510 location, orig_positions[i],
distance, position_radius_inv, flip_index, anctd);
1524 const int vert = verts[i];
1525 if (!hide_vert.
is_empty() && hide_vert[vert]) {
1529 distances_sq[i] <= normal_radius_sq;
1531 distances_sq[i] <= position_radius_sq;
1532 if (!needs_normal && !needs_center) {
1535 const float3 &normal = vert_normals[vert];
1536 const float distance = std::sqrt(distances_sq[i]);
1537 const int flip_index =
math::dot(view_normal, normal) <= 0.0f;
1540 location, vert_positions[vert],
distance, position_radius_inv, flip_index, anctd);
1560 const float position_radius_sq = position_radius * position_radius;
1561 const float position_radius_inv =
math::rcp(position_radius);
1563 const float normal_radius_sq = normal_radius * normal_radius;
1564 const float normal_radius_inv =
math::rcp(normal_radius);
1576 const Span<float3> orig_positions = orig_data->positions;
1586 const int grid = grids[i];
1588 if (!grid_hidden.
is_empty() && grid_hidden[grid][offset]) {
1591 const int node_vert = grid_range_node[offset];
1594 distances_sq[node_vert] <= normal_radius_sq;
1596 distances_sq[node_vert] <= position_radius_sq;
1597 if (!needs_normal && !needs_center) {
1600 const float3 &normal = orig_normals[node_vert];
1601 const float distance = std::sqrt(distances_sq[node_vert]);
1602 const int flip_index =
math::dot(view_normal, normal) <= 0.0f;
1605 orig_positions[node_vert],
1607 position_radius_inv,
1628 const int grid = grids[i];
1631 if (!grid_hidden.
is_empty() && grid_hidden[grid][offset]) {
1634 const int node_vert = grid_range_node[offset];
1638 distances_sq[node_vert] <= normal_radius_sq;
1640 distances_sq[node_vert] <= position_radius_sq;
1641 if (!needs_normal && !needs_center) {
1644 const float3 &normal = normals[vert];
1645 const float distance = std::sqrt(distances_sq[node_vert]);
1646 const int flip_index =
math::dot(view_normal, normal) <= 0.0f;
1649 location, positions[node_vert],
distance, position_radius_inv, flip_index, anctd);
1661 const bool has_bm_orco,
1671 const float position_radius_sq = position_radius * position_radius;
1672 const float position_radius_inv =
math::rcp(position_radius);
1674 const float normal_radius_sq = normal_radius * normal_radius;
1675 const float normal_radius_inv =
math::rcp(normal_radius);
1677 bool use_original =
false;
1684 if (use_original && has_bm_orco) {
1692 const float *co_tri[3] = {
1693 orig_positions[orig_tris[i][0]],
1694 orig_positions[orig_tris[i][1]],
1695 orig_positions[orig_tris[i][2]],
1707 distances_sq[i] <= normal_radius_sq;
1709 distances_sq[i] <= position_radius_sq;
1710 if (!needs_normal && !needs_center) {
1714 float3(orig_positions[orig_tris[i][1]]),
1715 float3(orig_positions[orig_tris[i][2]]));
1717 const float distance = std::sqrt(distances_sq[i]);
1718 const int flip_index =
math::dot(view_normal, normal) <= 0.0f;
1721 location, positions[i],
distance, position_radius_inv, flip_index, anctd);
1744 for (
BMVert *vert : verts) {
1750 distances_sq[i] <= normal_radius_sq;
1752 distances_sq[i] <= position_radius_sq;
1753 if (!needs_normal && !needs_center) {
1757 const float3 &normal = normals[i];
1758 const float distance = std::sqrt(distances_sq[i]);
1759 const int flip_index =
math::dot(view_normal, normal) <= 0.0f;
1762 location, positions[i],
distance, position_radius_inv, flip_index, anctd);
1780 for (
BMVert *vert : verts) {
1786 distances_sq[i] <= normal_radius_sq;
1788 distances_sq[i] <= position_radius_sq;
1789 if (!needs_normal && !needs_center) {
1793 const float3 normal = vert->no;
1794 const float distance = std::sqrt(distances_sq[i]);
1795 const int flip_index =
math::dot(view_normal, normal) <= 0.0f;
1798 location, positions[i],
distance, position_radius_inv, flip_index, anctd);
1838 switch (
pbvh.type()) {
1852 node_mask.slice(range).foreach_index([&](const int i) {
1853 calc_area_normal_and_center_node_mesh(ob,
1858 AverageDataFlags::Position,
1876 SampleLocalData &tls = all_tls.local();
1877 node_mask.slice(range).foreach_index([&](const int i) {
1878 calc_area_normal_and_center_node_bmesh(
1879 ob, brush, AverageDataFlags::Position, has_bm_orco, nodes[i], tls, anctd);
1889 node_mask.index_range(),
1893 SampleLocalData &tls = all_tls.local();
1894 node_mask.slice(range).foreach_index([&](const int i) {
1895 calc_area_normal_and_center_node_grids(
1896 ob, brush, AverageDataFlags::Position, nodes[i], tls, anctd);
1906 for (n = 0; n < anctd.area_cos.size(); n++) {
1907 if (anctd.count_co[n] == 0) {
1911 mul_v3_v3fl(r_area_co, anctd.area_cos[n], 1.0f / anctd.count_co[n]);
1919 if (anctd.count_co[0] == 0 && anctd.count_co[1] == 0) {
1921 copy_v3_v3(r_area_co, ss.cache->location_symm);
1937 switch (
pbvh.type()) {
1951 node_mask.slice(range).foreach_index([&](const int i) {
1952 calc_area_normal_and_center_node_mesh(ob,
1957 AverageDataFlags::Normal,
1975 SampleLocalData &tls = all_tls.local();
1976 node_mask.slice(range).foreach_index([&](const int i) {
1977 calc_area_normal_and_center_node_bmesh(
1980 AverageDataFlags::Normal,
1982 static_cast<const bke::pbvh::BMeshNode &>(nodes[i]),
1994 node_mask.index_range(),
1998 SampleLocalData &tls = all_tls.local();
1999 node_mask.slice(range).foreach_index([&](const int i) {
2000 calc_area_normal_and_center_node_grids(
2001 ob, brush, AverageDataFlags::Normal, nodes[i], tls, anctd);
2010 for (
const int i : {0, 1}) {
2011 if (anctd.count_no[i] != 0) {
2012 if (!math::is_zero(anctd.area_nos[i])) {
2013 return math::normalize(anctd.area_nos[i]);
2017 return std::nullopt;
2038 const float3 &plane_normal,
2039 const float3 &plane_center,
2040 float3 &r_stabilized_normal,
2041 float3 &r_stabilized_center)
2045 const float normal_weight =
brush.stabilize_normal;
2046 const float center_weight =
brush.stabilize_plane;
2051 if (plane_cache.first_time) {
2052 new_plane_normal = plane_normal;
2053 new_plane_center = plane_center;
2055 const int max_normal_index = int(1 +
2057 const int max_center_index = int(1 +
2060 plane_cache.normals.reinitialize(max_normal_index);
2061 plane_cache.centers.reinitialize(max_center_index);
2062 plane_cache.normals.fill(plane_normal);
2063 plane_cache.centers.fill(plane_center);
2065 plane_cache.normal_index = 0;
2066 plane_cache.center_index = 0;
2067 plane_cache.first_time =
false;
2070 const float3 last_normal = plane_cache.last_normal.value();
2071 const float3 last_center = plane_cache.last_center.value();
2081 float3 projected_plane_center;
2084 new_plane_center =
math::interpolate(plane_center, projected_plane_center, center_weight);
2087 plane_cache.normals[plane_cache.normal_index] = new_plane_normal;
2088 plane_cache.centers[plane_cache.center_index] = new_plane_center;
2090 plane_cache.normal_index = (plane_cache.normal_index + 1) % plane_cache.normals.size();
2091 plane_cache.center_index = (plane_cache.center_index + 1) % plane_cache.centers.size();
2093 r_stabilized_normal =
float3(0.0f);
2095 for (
const int i : plane_cache.normals.index_range()) {
2096 r_stabilized_normal += plane_cache.normals[i];
2102 float total_signed_distance = 0.0f;
2104 for (
const int i : plane_cache.centers.index_range()) {
2105 float signed_distance =
math::dot(r_stabilized_normal, plane_cache.centers[i]) -
2107 total_signed_distance += signed_distance;
2110 const float avg_signed_distance = total_signed_distance / plane_cache.centers.size();
2111 const float new_center_signed_distance =
math::dot(r_stabilized_normal, new_plane_center) -
2113 const float adjusted_distance = new_center_signed_distance - avg_signed_distance;
2114 r_stabilized_center = new_plane_center - r_stabilized_normal * adjusted_distance;
2116 plane_cache.last_normal = r_stabilized_normal;
2117 plane_cache.last_center = r_stabilized_center;
2133 switch (
pbvh.type()) {
2147 node_mask.slice(range).foreach_index([&](const int i) {
2148 calc_area_normal_and_center_node_mesh(ob,
2153 AverageDataFlags::All,
2171 SampleLocalData &tls = all_tls.local();
2172 node_mask.slice(range).foreach_index([&](const int i) {
2173 calc_area_normal_and_center_node_bmesh(
2174 ob, brush, AverageDataFlags::All, has_bm_orco, nodes[i], tls, anctd);
2184 node_mask.index_range(),
2188 SampleLocalData &tls = all_tls.local();
2189 node_mask.slice(range).foreach_index([&](const int i) {
2190 calc_area_normal_and_center_node_grids(
2191 ob, brush, AverageDataFlags::All, nodes[i], tls, anctd);
2201 for (n = 0; n < anctd.area_cos.size(); n++) {
2202 if (anctd.count_co[n] == 0) {
2206 mul_v3_v3fl(r_area_co, anctd.area_cos[n], 1.0f / anctd.count_co[n]);
2214 if (anctd.count_co[0] == 0 && anctd.count_co[1] == 0) {
2216 copy_v3_v3(r_area_co, ss.cache->location_symm);
2221 for (n = 0; n < anctd.area_nos.size(); n++) {
2227 if (brush.sculpt_brush_type == SCULPT_BRUSH_TYPE_PLANE) {
2228 float3 stabilized_normal;
2229 float3 stabilized_center;
2232 brush, *ss.cache, r_area_no, r_area_co, stabilized_normal, stabilized_center);
2269 const float alpha = root_alpha * root_alpha;
2281 float final_pressure;
2283 switch (
brush.sculpt_brush_type) {
2285 final_pressure =
pow4f(pressure);
2286 overlap = (1.0f + overlap) / 2.0f;
2287 return 0.25f * alpha * flip * final_pressure * overlap;
2291 return alpha * flip * pressure * overlap;
2293 return alpha * pressure * overlap;
2300 return root_alpha * pressure * overlap;
2305 return 0.1f * alpha * flip * pressure * overlap;
2310 return 10.0f * alpha * flip * pressure * overlap;
2313 return alpha * pressure * overlap;
2315 return alpha * pressure * overlap * 2.0f;
2317 final_pressure = pressure * pressure;
2318 return final_pressure * overlap;
2322 return alpha * pressure * overlap;
2325 final_pressure =
powf(pressure, 1.5f);
2326 return alpha * flip * final_pressure * overlap * 0.3f;
2328 final_pressure = pressure * pressure;
2329 return alpha * flip * final_pressure * overlap * 1.3f;
2332 overlap = (1.0f + overlap) / 2.0f;
2335 return alpha * flip * pressure * overlap;
2337 return alpha * pressure;
2342 return alpha * flip * pressure * overlap;
2346 return 0.250f * alpha * flip * pressure * overlap;
2349 return 0.125f * alpha * flip * pressure * overlap;
2353 overlap = (1.0f + overlap) / 2.0f;
2354 return alpha * flip * pressure * overlap;
2358 overlap = (1.0f + overlap) / 2.0f;
2359 return alpha * pressure * overlap;
2366 return 0.5f * alpha * pressure * overlap;
2369 return flip * alpha * pressure;
2373 return alpha * flip * pressure * overlap;
2376 return 0.25f * alpha * flip * pressure * overlap;
2380 overlap = (1.0f + overlap) / 2.0f;
2381 return alpha * pressure * overlap;
2384 return alpha * pressure;
2393 return alpha * pressure;
2404 return flip * alpha * pressure * overlap;
2413 const float brush_point[3],
2414 const int thread_id,
2452 float x = symm_point[0];
2453 float y = symm_point[1];
2464 *r_value -=
brush.texture_sample_bias;
2469 const float point_3d[3] = {point_2d[0], point_2d[1], 0.0f};
2481 translation[0] *= -1;
2482 translation[1] *= -1;
2486 for (
int i = 0; i < 3; ++i) {
2513 const float radius_sq,
2514 const bool original)
2523 const float radius_sq,
2524 const bool original)
2528 float dummy_co[3], dummy_depth;
2530 &ray_dist_precalc,
bounds.min,
bounds.max, dummy_co, &dummy_depth);
2533 return dist_sq < radius_sq ||
true;
2538 const float3 &brush_center,
2539 const float3 &brush_half_lengths,
2540 const bool test_z_axis)
2543 const float3 center_diff = brush_center - node_center;
2552 auto axis_separates_boxes = [&](
const float3 &axis) {
2554 const float radius2 =
math::abs(
math::dot(axis, node_x_axis)) * node_half_lengths.x +
2559 return projection > radius1 + radius2;
2564 float3{0.0f, 1.0f, 0.0f},
2565 float3{0.0f, 0.0f, 1.0f}} :
2567 float3{0.0f, 1.0f, 0.0f}};
2569 const std::array<float3, 3> node_axes = {node_x_axis, node_y_axis, node_z_axis};
2578 for (
const float3 &axis : brush_axes) {
2579 if (axis_separates_boxes(axis)) {
2585 for (
const float3 &axis : node_axes) {
2586 if (axis_separates_boxes(
float3(axis.x, axis.y, axis.z * test_z_axis))) {
2593 for (
const float3 &brush_axis : brush_axes) {
2594 for (
const float3 &node_axis : node_axes) {
2595 if (axis_separates_boxes(
math::cross(brush_axis, node_axis))) {
2624 const bool use_original,
2625 const float radius_scale,
2634 switch (
brush.falloff_shape) {
2662 const bool use_original,
2667 BLI_assert_msg(0,
"Unable to calculate cube test with empty 'brush_local_mat'");
2672 switch (
brush.falloff_shape) {
2698 const bool use_original,
2700 const float radius_sq,
2701 const std::optional<float3> &ray_direction,
2705 switch (falloff_shape) {
2718 location, ray_direction.value_or(
float3(0.0f)));
2739 switch (
brush.sculpt_plane) {
2795 const float center[3],
2796 const float screen_dir[2],
2797 float r_local_dir[3])
2802 mul_v3_m4v3(loc, ob.object_to_world().ptr(), center);
2809 mul_m4_v3(ob.world_to_object().ptr(), r_local_dir);
2813 const float3 &tip_location,
2825 float3 motion_normal_local;
2827 return motion_normal_local;
2831 const float3 &motion_normal_local,
2832 const float3 &tip_location,
2834 float local_mat[4][4],
2835 float local_mat_inv[4][4])
2880 const float tilt_strength)
2886 constexpr float tilt_sensitivity = 0.7f;
2887 const float rot_max =
M_PI_2 * tilt_strength * tilt_sensitivity;
2889 world_space, view_inverse.
x_axis(), tilt.y * rot_max);
2891 normal_tilt_y, view_inverse.
y_axis(), tilt.x * rot_max);
2898 const float tilt_strength)
2996 float axis[3],
angle;
3028 for (
int i = 0; i < 3; i++) {
3030 if (!(symm & symm_it)) {
3036 if (pivot[i] < 0.0f) {
3046 const float pivot[3])
3048 for (
int i = 0; i < 3; i++) {
3050 if (!(symm & symm_it)) {
3056 if (pivot[i] < 0.0f) {
3071 r_area_no =
float3(0.0f);
3072 r_area_co =
float3(0.0f);
3080 !use_original_plane || !use_original_normal;
3083 switch (
brush.sculpt_plane) {
3089 r_area_no =
float3(1.0f, 0.0f, 0.0f);
3093 r_area_no =
float3(0.0f, 1.0f, 0.0f);
3097 r_area_no =
float3(0.0f, 0.0f, 1.0f);
3170 constexpr float radius_scale = 1.25f;
3204 pbvh.tag_positions_changed(node_mask);
3205 pbvh.tag_topology_changed(node_mask);
3287 return {all_leaf_nodes(
pbvh, memory), std::nullopt, std::nullopt};
3299 float radius_scale = 1.0f;
3304 radius_scale = 2.0f;
3326 return {
IndexMask(), std::nullopt, std::nullopt};
3335 return {
IndexMask(), std::nullopt, std::nullopt};
3346 brush_local_mat.
ptr(),
3347 brush_local_mat_inv.
ptr());
3350 std::optional{tip_normal} :
3399 return "Draw Brush";
3401 return "Smooth Brush";
3403 return "Crease Brush";
3405 return "Blob Brush";
3407 return "Pinch Brush";
3409 return "Inflate Brush";
3411 return "Grab Brush";
3413 return "Nudge Brush";
3415 return "Thumb Brush";
3417 return "Layer Brush";
3419 return "Clay Brush";
3421 return "Clay Strips Brush";
3423 return "Clay Thumb Brush";
3425 return "Snake Hook Brush";
3427 return "Rotate Brush";
3429 return "Mask Brush";
3431 return "Simplify Brush";
3433 return "Draw Sharp Brush";
3435 return "Elastic Deform Brush";
3437 return "Pose Brush";
3439 return "Multi-plane Scrape Brush";
3441 return "Slide/Relax Brush";
3443 return "Boundary Brush";
3445 return "Cloth Brush";
3447 return "Draw Face Sets";
3449 return "Multires Displacement Eraser";
3451 return "Multires Displacement Smear";
3453 return "Paint Brush";
3455 return "Smear Brush";
3457 return "Plane Brush";
3459 return "Blur Brush";
3461 return "Scene Project Brush";
3480 depsgraph, sd, ob,
brush, memory);
3506 if (external_engine) {
3527 depsgraph, ob, 1.0f, 0.0f, 0.0f,
false,
true);
3535 std::numeric_limits<float>::max());
3539 switch (
brush.sculpt_brush_type) {
3561 depsgraph, sd, ob, node_mask, std::clamp(ss.
cache->
bstrength, 0.0f, 1.0f));
3689 brush.autosmooth_factor > 0)
3692 const float auto_smooth_factor =
brush.autosmooth_factor *
3704 depsgraph, sd, ob, node_mask,
brush.topology_rake_factor);
3743 float frac = 1.0f / max_overlap_count(sd);
3744 float reduce = (feather -
frac) / (1.0f -
frac);
3746 printf(
"feather: %f frac: %f reduce: %f\n", feather,
frac, reduce);
3749 mul_v3_fl(cache.grab_delta_symmetry, reduce);
3836 std::array<wmOperatorType *, 7> trim_operators = {
3846 return std::any_of(trim_operators.begin(), trim_operators.end(), [tref](
wmOperatorType *ot) {
3848 return WM_toolsystem_ref_properties_get_from_operator(tref, ot, &ptr);
3877namespace ed::sculpt_paint {
3894 for (
int i = 0; i < 3; i++) {
3909 mirror_ob_inv.
ptr(),
3910 ob.object_to_world().ptr());
3941 CLOG_WARN(&
LOG,
"Unable to switch to the '%s' essentials brush asset", target_asset);
3999 CLOG_WARN(&
LOG,
"Unable to switch to the 'Mask' essentials brush asset");
4032 const Object &active_object,
4038 const bool is_active_object = base.object == &active_object;
4042 if (is_active_object ||
object->type !=
OB_MESH || is_hidden) {
4047 if (!mesh_eval || mesh_eval->
faces_num == 0) {
4051 const float4x4 active_to_target_matrix =
object->world_to_object() *
4052 active_object.object_to_world();
4064 switch (
brush.sculpt_brush_type) {
4066 return max_ff(initial_size * 0.20f, initial_size *
pow3f(pressure_eval));
4068 return max_ff(initial_size * 0.30f, initial_size *
powf(pressure_eval, 1.5f));
4071 return initial_size *
4075 return initial_size * pressure_eval;
4131 const float mval[2] = {
4135 int brush_type =
brush.sculpt_brush_type;
4137 if (!
ELEM(brush_type,
4157 float grab_location[3], imat[4][4], delta[3], loc[3];
4161 !std::holds_alternative<std::monostate>(ss.
active_vert()))
4246 const float eps = 0.00001f;
4265 between_vecs.
angle() *
brush.rake_factor * rake_fade);
4323 bool use_origco =
false;
4326 switch (
pbvh.type()) {
4328 if (
const std::optional<OrigPositionData> orig_data =
4333 origco = orig_data->positions;
4341 origco = orig_data->positions;
4355 switch (
pbvh.type()) {
4357 int mesh_active_vert;
4396 BMVert *bmesh_active_vert;
4423 bool use_origco =
false;
4426 switch (
pbvh.type()) {
4428 if (
const std::optional<OrigPositionData> orig_data =
4433 origco = orig_data->positions;
4441 origco = orig_data->positions;
4486 const float4x4 &world_to_object = ob.world_to_object();
4524 return std::nullopt;
4532 float depth =
raycast_init(&vc, mval, ray_start, ray_end, ray_normal,
false);
4566 return std::nullopt;
4571 switch (
pbvh->type()) {
4586 const bool use_sampled_normal)
4594 *depsgraph, sd.
paint, &sd, vc, base, mval, use_sampled_normal);
4603 const bool use_sampled_normal)
4607 bool original =
false;
4617 return std::nullopt;
4624 float depth =
raycast_init(&vc, mval, ray_start, ray_end, ray_normal, original);
4662 return std::nullopt;
4668 switch (
pbvh->type()) {
4683 out.location = ray_start + ray_normal * srd.
depth;
4686 if (!use_sampled_normal) {
4688 return srd.
hit ? std::make_optional(
out) : std::nullopt;
4694 const float3 z_axis = {0.0f, 0.0f, 1.0f};
4711 return std::make_optional(
out);
4718 depsgraph,
brush, ob, node_mask))
4720 out.normal = *sampled_normal;
4727 return std::make_optional(
out);
4740 const bool force_original,
4741 const bool check_closest,
4742 const bool limit_closest_radius)
4748 const bool original = force_original || ((cache) ? !cache->
accum :
false);
4761 const float depth =
raycast_init(&vc, mval, ray_start, ray_end, ray_normal, original);
4765 std::optional<float3> hit_location;
4797 hit_location = ray_start + ray_normal * rd.
depth;
4801 if (hit_location.has_value() || !check_closest) {
4802 return hit_location;
4824 fntrd.
depth = std::numeric_limits<float>::max();
4836 hit_location = ray_start + ray_normal * fntrd.
depth;
4839 float closest_radius_sq = std::numeric_limits<float>::max();
4840 if (limit_closest_radius) {
4844 closest_radius_sq *= closest_radius_sq;
4849 return hit_location;
4852 return std::nullopt;
4859 const float mval[2],
4860 const bool force_original)
4865 depsgraph, vc, sd.
paint, &sd, mval, force_original, check_closest,
true);
4873 const bool force_original)
4878 depsgraph, vc,
paint,
nullptr, mval, force_original, check_closest,
true);
4883 const bool force_original)
4912 std::optional<float3> get_location(
float2 mouse,
bool force_original)
override;
4914 void redraw(
bool final)
override;
4915 bool test_cancel()
override;
4916 void update_step(
wmOperator *op,
const StrokeStep &stroke_step)
override;
4917 void done(
bool is_cancel,
bool stroke_started)
override;
4963 return toggle_settings;
4973 if (!
G.background) {
4978 ss.
cache = MEM_new<StrokeCache>(__func__);
5058 if (!
mesh.runtime->corner_tris_cache.frozen) {
5059 mesh.runtime->corner_tris_cache.freeze();
5065 if (use_pbvh_draw) {
5071 mesh.tag_positions_changed_no_normals();
5073 mesh.runtime->corner_normals_cache.tag_dirty();
5079 mesh.tag_positions_changed();
5084 if (
object.runtime->bounds_eval) {
5085 object.runtime->bounds_eval =
mesh.bounds_min_max();
5106 if (mmd !=
nullptr) {
5115 if (!use_pbvh_draw) {
5169 if (other_rv3d != vc.
rv3d) {
5207 dst_attributes.
remove(name);
5214 dst_attributes.
add(name, domain, data_type,
init);
5218 dst_attributes.
add(name, domain, data_type,
init);
5270 if (layer_index == -1) {
5273 return mesh.vert_data.layers[layer_index].sharing_info;
5278 const Depsgraph &depsgraph,
5286 bool entire_mesh_changed =
false;
5288 if (changed_topology) {
5290 entire_mesh_changed =
true;
5296 vertex_group_names.
add(vertex_group.
name);
5301 if (
ELEM(iter.
name,
".edge_verts",
".corner_vert",
".corner_edge")) {
5312 changed_attributes.
add(iter.
name);
5316 if (!new_mesh->attributes().contains(iter.
name)) {
5317 changed_attributes.
add(iter.
name);
5325 if (vertex_groups_changed) {
5338 mesh.attribute_storage.wrap().remove(
"position");
5350 mesh.attribute_storage.wrap().add(
5357 pbvh.tag_positions_changed(leaf_nodes);
5358 pbvh.update_bounds(depsgraph,
object);
5371 mesh.attributes_for_write());
5372 pbvh.tag_masks_changed(leaf_nodes);
5384 mesh.attributes_for_write());
5385 pbvh.tag_face_sets_changed(leaf_nodes);
5394 entire_mesh_changed =
true;
5398 if (!use_pbvh_draw || entire_mesh_changed) {
5415 *depsgraph, vc, sd.
paint, &sd, mval,
false, check_closest,
true)
5424 const float mval[2])
5434 if (
const SculptSession &ss = *
object.runtime->sculpt_session; ss.
bm) {
5455 float max_scale = 0.0f;
5456 for (
int i = 0; i < 3; i++) {
5486 cache->
accum =
true;
5490 cache->
accum =
false;
5496 cache->
accum =
false;
5501 cache->
accum =
false;
5503 cache->
accum =
true;
5514 constexpr int pixel_input_threshold = 5;
5552 const Depsgraph &depsgraph,
5674 Depsgraph &
depsgraph = *this->depsgraph;
5752 MEM_delete(ss.
cache);
5755 if (!is_cancel && stroke_started) {
5849 const bool ignore_background_click =
RNA_boolean_get(op->
ptr,
"ignore_background_click");
5851 if (ignore_background_click && !
over_mesh(
C, op, mval)) {
5888 stroke->
exec(
C, op);
5929 ot->
name =
"Sculpt";
5930 ot->
idname =
"SCULPT_OT_brush_stroke";
5931 ot->
description =
"Sculpt a stroke into the geometry";
5950 "override_location",
5952 "Override Location",
5953 "Override the given \"location\" array by recalculating object space positions from the "
5954 "provided \"mouse_event\" positions");
5958 "ignore_background_click",
5960 "Ignore Background Click",
5961 "Clicks on the background do not start the stroke");
5987 if (joined.
vert == -1) {
5988 joined.
vert =
b.vert;
5992 joined.
vert =
b.vert;
6003 const float max_distance_sq,
6004 const int island_id,
6008 for (
const int vert :
node.verts()) {
6009 if (!hide_vert.
is_empty() && hide_vert[vert]) {
6019 if (distance_sq < max_distance_sq && distance_sq < nvtd.
distance_sq) {
6031 const float max_distance_sq,
6032 const int island_id,
6036 for (
const int grid :
node.grids()) {
6047 if (distance_sq < max_distance_sq && distance_sq < nvtd.
distance_sq) {
6057 const float max_distance_sq,
6058 const int island_id,
6062 for (
const BMVert *bm_vert :
6076 if (distance_sq < max_distance_sq && distance_sq < nvtd.
distance_sq) {
6085 const float max_distance_sq,
6094 switch (
pbvh.type()) {
6101 for (
const int vert : vert_positions.
index_range()) {
6106 const float3 &location = vert_positions[vert];
6135 if (nvtd.vert == -1) {
6138 fake_neighbors[vert] = nvtd.vert;
6139 fake_neighbors[nvtd.vert] = vert;
6153 const float3 &location = positions[vert];
6182 if (nvtd.vert == -1) {
6185 fake_neighbors[vert] = nvtd.vert;
6186 fake_neighbors[nvtd.vert] = vert;
6214 ss, location, max_distance_sq, island_id,
nodes[i], nvtd);
6219 if (nvtd.vert == -1) {
6222 fake_neighbors[vert] = nvtd.vert;
6223 fake_neighbors[nvtd.vert] = vert;
6270 float depth =
raycast_init(vc, mouse, ray_end, ray_start, ray_normal, original);
6272 ray_normal = ray_normal * -1.0f;
6273 ray_start =
position + ray_normal * 0.002f;
6286 const Mesh &
mesh = *id_cast<const Mesh *>(
object.
data);
6331 const int verts_num)
6335 if (islands_num == 1) {
6341 for (const int i : range) {
6342 island_ids[i] = uint8_t(island_indices[i]);
6365 [&](
const int face) {
6368 disjoint_set.
join(face_verts.
first(), face_verts[i]);
6385 for (const int grid : range) {
6386 SubdivCCGNeighbors neighbors;
6387 for (const short y : IndexRange(key.grid_size)) {
6388 for (const short x : IndexRange(key.grid_size)) {
6389 const SubdivCCGCoord coord{grid, x, y};
6390 SubdivCCGNeighbors neighbors;
6391 BKE_subdiv_ccg_neighbor_coords_get(subdiv_ccg, coord, true, neighbors);
6392 for (const SubdivCCGCoord neighbor : neighbors.coords) {
6393 disjoint_set.join(coord.to_index(key), neighbor.to_index(key));
6400 return vert_disjoint_set_to_islands(disjoint_set, subdiv_ccg.positions.size());
6416 for (
const BMFace *face :
6503 for (
const BMVert *vert : verts) {
6504 positions[i] = vert->co;
6521 for (
const BMVert *vert : verts) {
6522 normals[i] = vert->no;
6553 for (
const BMVert *vert : verts) {
6585 for (
const BMVert *vert : verts) {
6622 const float3 &plane_center,
6623 const float3 &view_normal,
6647 const float3 &plane_center,
6648 const float3 &view_normal,
6673 const float3 &plane_center,
6674 const float3 &view_normal,
6707 const float3 &plane_center,
6708 const float3 &view_normal,
6881 brush.curve_distance_falloff,
6966 brush.curve_distance_falloff,
7086 r_factors[i] = hide_vert[verts[i]] ? 0.0f : 1.0f;
7090 r_factors.
fill(1.0f);
7104 r_factors.
fill(1.0f);
7108 const BitSpan hidden = grid_hidden[grids[i]];
7111 r_factors[start + offset] = hidden[offset] ? 0.0f : 1.0f;
7122 for (
const BMVert *vert : verts) {
7136 if (!
mask.is_empty()) {
7138 r_factors[i] = 1.0f -
mask[verts[i]];
7142 r_factors.
fill(1.0f);
7147 if (hide_vert[verts[i]]) {
7148 r_factors[i] = 0.0f;
7164 for (
const BMVert *vert : verts) {
7167 r_factors[i] = 0.0f;
7187 dst[offset] = 1.0f - src[offset];
7192 r_factors.
fill(1.0f);
7198 const BitSpan hidden = grid_hidden[grids[i]];
7201 if (hidden[offset]) {
7202 r_factors[start + offset] = 0.0f;
7218 const float dot =
math::dot(view_normal, vert_normals[verts[i]]);
7219 factors[i] *= std::max(
dot, 0.0f);
7232 factors[i] *= std::max(
dot, 0.0f);
7248 for (
const int offset : grid_factors.
index_range()) {
7249 const float dot =
math::dot(view_normal, grid_normals[offset]);
7250 grid_factors[offset] *= std::max(
dot, 0.0f);
7263 for (
const BMVert *vert : verts) {
7265 factors[i] *= std::max(
dot, 0.0f);
7278 for (
const BMFace *face : faces) {
7280 factors[i] *= std::max(
dot, 0.0f);
7305 if (radial_symmetry_pass) {
7333 if (radial_symmetry_pass) {
7378 for (
float &value : r_distances) {
7379 value = std::sqrt(value);
7417 for (
float &value : r_distances) {
7418 value = std::sqrt(value);
7428 if (distances[i] >= radius) {
7442 const float roundness =
brush.tip_roundness;
7444 const float hardness = 1.0f - roundness;
7445 const T hardness_vec(hardness);
7452 r_distances[i] = 1.0f;
7456 const T excess =
math::max(local - hardness_vec, zero);
7458 r_distances[i] = 0.0f;
7474 const float hardness,
7478 if (hardness == 0.0f) {
7481 const float threshold = hardness * radius;
7482 if (hardness == 1.0f) {
7484 distances[i] = distances[i] < threshold ? 0.0f : radius;
7488 const float radius_inv =
math::rcp(radius);
7489 const float hardness_inv_rcp =
math::rcp(1.0f - hardness);
7491 if (distances[i] < threshold) {
7492 distances[i] = 0.0f;
7495 const float radius_factor = (distances[i] * radius_inv - hardness) * hardness_inv_rcp;
7496 distances[i] = radius_factor * radius;
7507 brush.curve_distance_falloff,
7530 if (factors[i] == 0.0f) {
7533 float texture_value;
7537 paint_mode, ss,
brush, vert_positions[verts[i]], thread_id, &texture_value, texture_rgba);
7539 factors[i] *= texture_value;
7559 if (factors[i] == 0.0f) {
7562 float texture_value;
7566 paint_mode, ss,
brush, positions[i], thread_id, &texture_value, texture_rgba);
7568 factors[i] *= texture_value;
7580 const float3 prev_translation = positions[i] - orig_positions[i];
7581 translations[i] -= prev_translation;
7588 return std::any_of(values.
begin(), values.
end(), [&](
const float v) { return std::isnan(v); });
7601 const int vert = verts[i];
7602 positions[vert] += translations[i];
7619 for (
const int offset : grid_positions.
index_range()) {
7620 grid_positions[offset] += grid_translations[offset];
7632 for (
BMVert *vert : verts) {
7643 if (len_sq < std::numeric_limits<float>::epsilon()) {
7646 const float dot_factor = -
math::rcp(len_sq);
7648 translations[i] += plane *
math::dot(translations[i], plane) * dot_factor;
7679 for (
float3 &translation : translations) {
7680 translation[axis] = 0.0f;
7692 const int vert = verts[i];
7700 co_mirror[axis] = 0.0f;
7702 translations[i][axis] = co_local[axis] - positions[vert][axis];
7721 for (
float3 &translation : translations) {
7722 translation[axis] = 0.0f;
7740 co_mirror[axis] = 0.0f;
7742 translations[i][axis] = co_local[axis] - positions[i][axis];
7752 return std::nullopt;
7754 const int active_index =
object.shapenr - 1;
7757 return std::nullopt;
7761 data.basis_key_active = active_key == keys->
refkey;
7766 for (
const auto [i, other_key] : keys->
block.enumerate()) {
7767 if ((&other_key != active_key) && (*dependent)[i]) {
7768 data.dependent_keys.append({
static_cast<float3 *
>(other_key.data), other_key.totelem});
7783 orig_ =
mesh.vert_positions_for_write();
7786 if (eval_mut.
data() != orig_.data()) {
7787 eval_mut_ = eval_mut;
7803 if (deform_imats_) {
7809 if (shape_key_data_) {
7810 if (!shape_key_data_->dependent_keys.is_empty()) {
7816 if (shape_key_data_->basis_key_active) {
7831 if (factors[i] == 0.0f) {
7832 translations[i] =
float3(0.0f);
7841 translations[i] *= factors[i];
7848 if (factor == 1.0f) {
7852 translations[i] *= factor;
7859 if (strength == 1.0f) {
7862 for (
float &factor : factors) {
7873 factors[i] *= strengths[i];
7885 r_translations[i] = offset * factors[i];
7897 translations[i] = new_positions[i] - old_positions[verts[i]];
7908 translations[i] = new_positions[i] - old_positions[i];
7919 [&](
const int i,
const int pos) { node_data[pos] =
nodes[i].verts().size(); });
7962 r_offset_data[i] = r_data.
size();
7965 r_offset_data.
last() = r_data.
size();
7982 const int grid = grids[i];
7983 const int node_verts_start = i * key.
grid_area;
7988 r_offset_data[node_verts_start + offset] = r_data.
size();
8001 r_offset_data.
last() = r_data.
size();
8015 for (
BMVert *vert : verts) {
8016 r_offset_data[i] = r_data.
size();
8020 r_offset_data.
last() = r_data.
size();
8024template<
bool use_factors>
8038 if constexpr (use_factors) {
8046 const int vert = verts[i];
8047 const int vert_start = r_data.
size();
8048 r_offset_data[i] = vert_start;
8049 if constexpr (use_factors) {
8050 if (factors[i] == 0.0f) {
8056 if (boundary_verts[vert]) {
8058 if (r_data.
size() == vert_start + 2) {
8059 r_data.
resize(vert_start);
8063 for (
int neighbor_i = r_data.
size() - 1; neighbor_i >= vert_start; neighbor_i--) {
8072 r_offset_data.
last() = r_data.
size();
8135 const int grid = grids[i];
8136 const int node_verts_start = i * key.
grid_area;
8143 const int node_vert_index = node_verts_start + offset;
8154 faces, corner_verts, boundary_verts, boundary_edges, subdiv_ccg, coord))
8164 faces, corner_verts, boundary_verts, boundary_edges, subdiv_ccg, coord);
8182 for (
BMVert *vert : verts) {
8184 result[i] = neighbor_data;
CustomData interface, see also DNA_customdata_types.h.
General operations, lookup, etc. for blender objects.
#define PAINT_SYMM_AREA_DEFAULT
A BVH for high poly meshes.
#define CLOG_WARN(clg_ref,...)
#define ID_REAL_USERS(id)
Object is a sort of wrapper for general info.
#define RV3D_CLIPPING_ENABLED(v3d, rv3d)
#define OPERATOR_RETVAL_CHECK(ret)
Read Blender memory allocation and freeing.
#define PRF_scope(category)
#define PRF_scope_set_dynamic_name(fmt,...)
#define BLI_assert_unreachable()
#define UNUSED_VARS_NDEBUG(...)
#define BLI_assert_msg(a, msg)
#define BM_ELEM_CD_SET_FLOAT(ele, offset, f)
#define BM_ELEM_CD_GET_FLOAT(ele, offset)
#define BM_ELEM_CD_GET_INT(ele, offset)
#define BM_elem_index_get(ele)
#define BM_elem_flag_test(ele, hflag)
#define BM_elem_flag_test_bool(ele, hflag)
#define BM_ITER_ELEM(ele, iter, data, itype)
SIMD_FORCE_INLINE btScalar angle(const btVector3 &v) const
Return the angle between this and another vector.
bool closest(btVector3 &v)
Span< T > as_span() const
IndexRange index_range() const
void reinitialize(const int64_t new_size)
int calc_reduced_ids(MutableSpan< int > result) const
const void * data() const
GSpan get_internal_span() const
static IndexMask from_predicate(const IndexMask &universe, LinearAllocator<> &memory, Fn &&predicate, exec_mode::Mode mode=exec_mode::parallel)
static IndexMask from_bools(Span< bool > bools, LinearAllocator<> &memory)
static IndexMask from_bools_inverse(Span< bool > bools, LinearAllocator<> &memory)
constexpr IndexRange()=default
constexpr IndexRange drop_front(int64_t n) const
constexpr int64_t size() const
constexpr MutableSpan slice(const int64_t start, const int64_t size) const
constexpr T * data() const
constexpr void fill(const T &value) const
constexpr IndexRange index_range() const
constexpr void copy_from(Span< T > values) const
bool contains(const Key &key) const
Span< NewT > constexpr cast() const
constexpr Span slice(int64_t start, int64_t size) const
constexpr const T & first() const
constexpr int64_t size() const
constexpr const T * end() const
constexpr IndexRange index_range() const
constexpr const T * begin() const
constexpr bool is_empty() const
constexpr bool contains(const T &value) const
void add_multiple(Span< Key > keys)
bool contains(const Key &key) const
Span< Key > as_span() const
void remove_and_reorder(const int64_t index)
int64_t remove_if(Predicate &&predicate)
void append(const T &value)
const T & last(const int64_t n=0) const
void resize(const int64_t new_size)
void extend(Span< T > array)
void append_non_duplicates(const T &value)
Span< T > as_span() const
void resize(const int64_t new_size_in_bits, const bool value=false)
GAttributeReader lookup(const StringRef name) const
GAttributeReader get() const
bool add(const StringRef name, const AttrDomain domain, const AttrType data_type, const AttributeInit &initializer)
GSpanAttributeWriter lookup_or_add_for_write_span(StringRef name, AttrDomain domain, AttrType data_type, const AttributeInit &initializer=AttributeInitDefaultValue())
bool remove(const StringRef name)
constexpr bool is_empty() const
void foreach_index_optimized(Fn &&fn, Mode mode=exec_mode::serial) const
IndexMask slice(IndexRange range) const
int64_t min_array_size() const
IndexRange index_range() const
void foreach_index(Fn &&fn, Mode mode=exec_mode::serial) const
IndexRange index_range() const
CCL_NAMESPACE_BEGIN ccl_device_inline float frac(const float x, ccl_private int *ix)
float dot(VecOp< float, D >, VecOp< float, D >) RET
float distance(float, float) RET
float2x2 invert(float2x2 mat)
float3x3 scale(float3x3 mat, float2 scale)
ccl_device_inline void copy_v3_v3(ccl_private float *r, const float3 val)
#define SCULPT_RAKE_BRUSH_FACTOR
#define FAKE_NEIGHBOR_NONE
void count_indices(Span< int > indices, MutableSpan< int > counts)
bool supports_auto_smooth_pressure(const Brush &brush)
bool supports_rake_factor(const Brush &brush)
bool supports_accumulate(const Brush &brush)
bool supports_gravity(const Brush &brush)
bool supports_hardness_pressure(const Brush &brush)
float normal_weight_get(const Brush &brush, bool invert)
void common_pressure_curves_init(Brush &brush)
bool supports_dyntopo(const Brush &brush)
bool supports_topology_rake(const Brush &brush)
bool supports_normal_weight(const Brush &brush)
IndexRange grid_range(const int grid_area, const int grid)
int2 face_find_adjacent_verts(const IndexRange face, const Span< int > corner_verts, const int vert)
pbvh::Tree * pbvh_get(Object &object)
void stroke_track_location(Paint &paint, float3 location)
void raycast(Tree &pbvh, FunctionRef< void(Node &node, float *tmin)> hit_fn, const float3 &ray_start, const float3 &ray_normal, bool original)
IndexMask search_nodes(const Tree &pbvh, IndexMaskMemory &memory, FunctionRef< bool(const Node &)> filter_fn)
void update_normals(const Depsgraph &depsgraph, Object &object_orig, Tree &pbvh)
IndexMask all_leaf_nodes(const Tree &pbvh, IndexMaskMemory &memory)
void clip_ray_ortho(Tree &pbvh, bool original, float ray_start[3], float ray_end[3], float ray_normal[3])
bool node_raycast_mesh(const MeshNode &node, Span< float3 > node_positions, Span< float3 > vert_positions, OffsetIndices< int > faces, Span< int > corner_verts, Span< int3 > corner_tris, Span< bool > hide_poly, const float3 &ray_start, const float3 &ray_normal, IsectRayPrecalc *isect_precalc, float *depth, int &r_active_vertex, int &r_active_face_index, float3 &r_face_normal)
void node_update_mask_bmesh(int mask_offset, BMeshNode &node)
void node_update_mask_mesh(Span< float > mask, MeshNode &node)
bool node_raycast_bmesh(BMeshNode &node, const float3 &ray_start, const float3 &ray_normal, const IsectRayPrecalc *isect_precalc, float *depth, bool use_original, BMVert **r_active_vertex, float3 &r_face_normal)
void node_update_mask_grids(const CCGKey &key, Span< float > masks, GridsNode &node)
bool node_raycast_grids(const SubdivCCG &subdiv_ccg, GridsNode &node, Span< float3 > node_positions, const float3 &ray_start, const float3 &ray_normal, const IsectRayPrecalc *isect_precalc, float *depth, SubdivCCGCoord &r_active_vertex, int &r_active_grid_index, float3 &r_face_normal)
Bounds< float3 > bounds_get(const Tree &pbvh)
Span< float3 > vert_normals_eval(const Depsgraph &depsgraph, const Object &object_orig)
MutableSpan< float3 > vert_positions_eval_for_write(const Depsgraph &depsgraph, Object &object_orig)
bool bmesh_update_topology(BMesh &bm, Tree &pbvh, BMLog &bm_log, PBVHTopologyUpdateMode mode, float min_edge_len, float max_edge_len, const float3 ¢er, const std::optional< float3 > &view_normal, float radius, bool use_frontface, bool use_projected)
bool find_nearest_to_ray_node(Tree &pbvh, Node &node, Span< float3 > node_positions, bool use_origco, Span< float3 > vert_positions, const OffsetIndices< int > faces, Span< int > corner_verts, Span< int3 > corner_tris, Span< bool > hide_poly, const SubdivCCG *subdiv_ccg, const float ray_start[3], const float ray_normal[3], float *depth, float *dist_sq)
void store_bounds_orig(Tree &pbvh)
Span< int > node_face_indices_calc_grids(const SubdivCCG &subdiv_ccg, const GridsNode &node, Vector< int > &faces)
Span< float3 > vert_positions_eval(const Depsgraph &depsgraph, const Object &object_orig)
void find_nearest_to_ray(Tree &pbvh, const FunctionRef< void(Node &node, float *tmin)> fn, const float3 &ray_start, const float3 &ray_normal, bool original)
Cache & stroke_cache_ensure(const Depsgraph &depsgraph, const Paint &paint, const Brush *brush, Object &ob)
bool is_enabled(const Paint &paint, const Object &object, const Brush *br)
void calc_vert_factors(const Depsgraph &depsgraph, const Object &object, const Cache &automasking, const bke::pbvh::MeshNode &node, Span< int > verts, MutableSpan< float > factors)
void calc_grids_factors(const Depsgraph &depsgraph, const Object &object, const Cache &automasking, const bke::pbvh::GridsNode &node, Span< int > grids, MutableSpan< float > factors)
SculptBoundaryInfoCache create_boundary_info(const Mesh &mesh)
void do_boundary_brush(const Depsgraph &depsgraph, const Sculpt &sd, Object &ob, const IndexMask &node_mask)
void ensure_boundary_info(Object &object)
bool vert_is_boundary(const GroupedSpan< int > vert_to_face_map, const Span< bool > hide_poly, const BitSpan boundary_verts, const int vert)
CursorSampleResult calc_node_mask(const Depsgraph &depsgraph, Object &ob, const Brush &brush, IndexMaskMemory &memory)
CursorSampleResult calc_node_mask(const Depsgraph &depsgraph, Object &ob, const Brush &brush, IndexMaskMemory &memory)
void do_snake_hook_brush(const Depsgraph &depsgraph, const Sculpt &sd, Object &object, const IndexMask &node_mask)
void do_smooth_brush(const Depsgraph &depsgraph, const Sculpt &sd, Object &object, const IndexMask &node_mask, float brush_strength)
void do_mask_brush(const Depsgraph &depsgraph, const Sculpt &sd, Object &object, const IndexMask &node_mask)
void do_draw_face_sets_brush(const Depsgraph &depsgraph, const Sculpt &sd, Object &object, const IndexMask &node_mask)
void do_blob_brush(const Depsgraph &depsgraph, const Sculpt &sd, Object &ob, const IndexMask &node_mask)
void do_draw_brush(const Depsgraph &depsgraph, const Sculpt &sd, Object &object, const IndexMask &node_mask)
void do_displacement_eraser_brush(const Depsgraph &depsgraph, const Sculpt &sd, Object &ob, const IndexMask &node_mask)
void do_elastic_deform_brush(const Depsgraph &depsgraph, const Sculpt &sd, Object &object, const IndexMask &node_mask)
void do_draw_vector_displacement_brush(const Depsgraph &depsgraph, const Sculpt &sd, Object &object, const IndexMask &node_mask)
void do_crease_brush(const Depsgraph &depsgraph, const Sculpt &sd, Object &ob, const IndexMask &node_mask)
void do_topology_relax_brush(const Depsgraph &depsgraph, const Sculpt &sd, Object &object, const IndexMask &node_mask)
void do_thumb_brush(const Depsgraph &depsgraph, const Sculpt &sd, Object &object, const IndexMask &node_mask)
void do_clay_thumb_brush(const Depsgraph &depsgraph, const Sculpt &sd, Object &ob, const IndexMask &node_mask)
void do_rotate_brush(const Depsgraph &depsgraph, const Sculpt &sd, Object &object, const IndexMask &node_mask)
void do_topology_slide_brush(const Depsgraph &depsgraph, const Sculpt &sd, Object &object, const IndexMask &node_mask)
void do_displacement_smear_brush(const Depsgraph &depsgraph, const Sculpt &sd, Object &ob, const IndexMask &node_mask)
void do_clay_strips_brush(const Depsgraph &depsgraph, const Sculpt &sd, Object &ob, const IndexMask &node_mask, const float3 &plane_normal, const float3 &plane_center)
void do_surface_smooth_brush(const Depsgraph &depsgraph, const Sculpt &sd, Object &object, const IndexMask &node_mask)
void do_plane_brush(const Depsgraph &depsgraph, const Sculpt &sd, Object &object, const IndexMask &node_mask, const float3 &plane_normal, const float3 &plane_center)
void do_enhance_details_brush(const Depsgraph &depsgraph, const Sculpt &sd, Object &object, const IndexMask &node_mask)
void do_bmesh_topology_rake_brush(const Depsgraph &depsgraph, const Sculpt &sd, Object &object, const IndexMask &node_mask, const float input_strength)
void do_layer_brush(const Depsgraph &depsgraph, const Sculpt &sd, Object &object, const IndexMask &node_mask)
void do_nudge_brush(const Depsgraph &depsgraph, const Sculpt &sd, Object &object, const IndexMask &node_mask)
void do_inflate_brush(const Depsgraph &depsgraph, const Sculpt &sd, Object &ob, const IndexMask &node_mask)
void do_relax_face_sets_brush(const Depsgraph &depsgraph, const Sculpt &sd, Object &object, const IndexMask &node_mask)
void do_draw_sharp_brush(const Depsgraph &depsgraph, const Sculpt &sd, Object &object, const IndexMask &node_mask)
void do_multiplane_scrape_brush(const Depsgraph &depsgraph, const Sculpt &sd, Object &object, const IndexMask &node_mask)
void do_pinch_brush(const Depsgraph &depsgraph, const Sculpt &sd, Object &object, const IndexMask &node_mask)
void do_smooth_mask_brush(const Depsgraph &depsgraph, const Sculpt &sd, Object &object, const IndexMask &node_mask, float brush_strength)
void do_gravity_brush(const Depsgraph &depsgraph, const Sculpt &sd, Object &ob, const IndexMask &node_mask)
float clay_thumb_get_stabilized_pressure(const StrokeCache &cache)
void do_clay_brush(const Depsgraph &depsgraph, const Sculpt &sd, Object &ob, const IndexMask &node_mask)
void do_scene_project_brush(const Depsgraph &depsgraph, const Sculpt &sd, Object &object, const IndexMask &node_mask)
void do_grab_brush(const Depsgraph &depsgraph, const Sculpt &sd, Object &ob, const IndexMask &node_mask)
bool is_cloth_deform_brush(const Brush &brush)
void brush_store_simulation_state(const Depsgraph &depsgraph, const Object &object, SimulationData &cloth_sim)
void ensure_nodes_constraints(const Sculpt &sd, Object &object, const IndexMask &node_mask, SimulationData &cloth_sim, const float3 &initial_location, const float radius)
void sim_activate_nodes(Object &object, SimulationData &cloth_sim, const IndexMask &node_mask)
IndexMask brush_affected_nodes_gather(const Object &object, const Brush &brush, IndexMaskMemory &memory)
void do_simulation_step(const Depsgraph &depsgraph, const Sculpt &sd, Object &object, SimulationData &cloth_sim, const IndexMask &node_mask)
std::unique_ptr< SimulationData > brush_simulation_create(const Depsgraph &depsgraph, Object &ob, const float cloth_mass, const float cloth_damping, const float cloth_softbody_strength, const bool use_collisions, const bool needs_deform_coords)
void do_cloth_brush(const Depsgraph &depsgraph, const Sculpt &sd, Object &ob, const IndexMask &node_mask)
bke::GSpanAttributeWriter active_color_attribute_for_write(Mesh &mesh)
void do_smear_brush(const Depsgraph &depsgraph, const Sculpt &sd, Object &ob, const IndexMask &node_mask)
void color_vert_set(OffsetIndices< int > faces, Span< int > corner_verts, GroupedSpan< int > vert_to_face_map, bke::AttrDomain color_domain, int vert, const float4 &color, GMutableSpan color_attribute)
void do_paint_brush(const Depsgraph &depsgraph, const Sculpt &sd, Object &ob, const IndexMask &node_mask)
void do_blur_brush(const Depsgraph &depsgraph, const Sculpt &sd, Object &ob, const IndexMask &node_mask)
float relative_to_detail_size(const float relative_detail, const float brush_radius, const float pixel_radius, const float pixel_size)
float constant_to_detail_size(const float constant_detail, const Object &ob)
float brush_to_detail_size(const float brush_percent, const float brush_radius)
constexpr float EDGE_LENGTH_MIN_FACTOR
bool stroke_is_dyntopo(const Object &object, const Brush &brush)
bool vert_has_unique_face_set(const GroupedSpan< int > vert_to_face_map, const Span< int > face_sets, int vert)
bool coord_has_face_set(const OffsetIndices< int > faces, const Span< int > corner_verts, const GroupedSpan< int > vert_to_face_map, const Span< int > face_sets, const SubdivCCG &subdiv_ccg, const SubdivCCGCoord coord, const int face_set)
bool vert_has_any_face_set(const GroupedSpan< int > vert_to_face_map, const Span< int > face_sets, int vert, const Set< int > &allowed_face_sets)
bool vert_has_face_set(const GroupedSpan< int > vert_to_face_map, const Span< int > face_sets, const int vert, const int face_set)
int vert_face_set_max_get(const GroupedSpan< int > vert_to_face_map, const Span< int > face_sets, const int vert)
bke::SpanAttributeWriter< int > ensure_face_sets_mesh(Mesh &mesh)
bool coord_has_any_face_set(const OffsetIndices< int > faces, const Span< int > corner_verts, const GroupedSpan< int > vert_to_face_map, const Span< int > face_sets, const SubdivCCG &subdiv_ccg, const SubdivCCGCoord coord, const Set< int > &allowed_face_sets)
Set< int > vert_face_sets_get(const GroupedSpan< int > vert_to_face_map, const Span< int > face_sets, const int vert)
int vert_face_set_get(const SubdivCCG &subdiv_ccg, const Span< int > face_sets, const int grid)
int active_face_set_get(const Object &object)
static bool sculpt_check_unique_face_set_for_edge_in_base_mesh(const GroupedSpan< int > vert_to_face_map, const Span< int > face_sets, const Span< int > corner_verts, const OffsetIndices< int > faces, int v1, int v2)
bool vert_all_faces_visible_get(const Span< bool > hide_poly, const GroupedSpan< int > vert_to_face_map, const int vert)
void ensure_cache(Object &object)
static SculptTopologyIslandCache calc_topology_islands_grids(const Object &object)
static SculptTopologyIslandCache vert_disjoint_set_to_islands(const AtomicDisjointSet &vert_sets, const int verts_num)
static SculptTopologyIslandCache calc_topology_islands_mesh(const Mesh &mesh)
static SculptTopologyIslandCache calculate_cache(const Object &object)
static SculptTopologyIslandCache calc_topology_islands_bmesh(const Object &object)
int vert_id_get(const SculptSession &ss, const int vert)
void invalidate(SculptSession &ss)
void do_pose_brush(const Depsgraph &depsgraph, const Sculpt &sd, Object &ob, const IndexMask &node_mask)
void push_end(Object &ob)
bool has_bmesh_log_entry()
void push_nodes(const Depsgraph &depsgraph, Object &object, const IndexMask &node_mask, const Type type)
static void restore_from_undo_step(const Depsgraph &depsgraph, const Sculpt &sd, Object &object)
static void restore_color_from_undo_step(Object &object)
static void restore_face_set_from_undo_step(Object &object)
void push_begin_ex(const Scene &, Object &ob, const char *name)
void restore_position_from_undo_step(const Depsgraph &depsgraph, Object &object)
void geometry_begin(const Scene &scene, Object &ob, const wmOperator *op)
void geometry_end(Object &ob)
static void restore_mask_from_undo_step(Object &object)
void push_begin(const Scene &scene, Object &ob, const wmOperator *op)
static void restore_from_undo_step_if_necessary(const Depsgraph &depsgraph, const Sculpt &sd, Object &ob)
static void calc_area_normal_and_center_node_mesh(const Object &object, const Span< float3 > vert_positions, const Span< float3 > vert_normals, const Span< bool > hide_vert, const Brush &brush, const AverageDataFlags flag, const bke::pbvh::MeshNode &node, AreaNormalCenterData &anctd)
bool shape_key_check(const Object &ob, ReportList *reports)
void fill_factor_from_hide_and_mask(Span< bool > hide_vert, Span< float > mask, Span< int > verts, MutableSpan< float > r_factors)
static void calc_local_from_screen(const ViewContext &vc, const float center[3], const float screen_dir[2], float r_local_dir[3])
std::optional< Span< float > > orig_mask_data_lookup_grids(const Object &object, const bke::pbvh::GridsNode &node)
static bool brush_needs_rake_rotation(const Brush &brush)
MutableSpan< float3 > gather_grids_positions(const SubdivCCG &subdiv_ccg, const Span< int > grids, Vector< float3 > &positions)
void face_set_overlay_check(bContext &C, wmOperator &op)
static void sculpt_raycast_cb(bke::pbvh::Node &node, RaycastData &rd, float *distance)
static float brush_dynamic_size_get(const Brush &brush, const StrokeCache &cache, float initial_size)
static void fake_neighbor_search_mesh(const SculptSession &ss, const Span< float3 > vert_positions, const Span< bool > hide_vert, const float3 &location, const float max_distance_sq, const int island_id, const bke::pbvh::MeshNode &node, NearestVertData &nvtd)
static bool attribute_matches(const bke::AttributeAccessor a, const bke::AttributeAccessor b, const StringRef name)
bool node_in_sphere(const bke::pbvh::Node &node, const float3 &location, const float radius_sq, const bool original)
void scatter_data_bmesh(Span< T > node_data, const Set< BMVert *, 0 > &verts, MutableSpan< T > dst)
bool node_in_cylinder(const DistRayAABB_Precalc &ray_dist_precalc, const bke::pbvh::Node &node, const float radius_sq, const bool original)
float4x4 cube_tip_init(const Object &ob, const Brush &brush)
static void brush_stroke_init(bContext *C, const wmOperator *op)
void calc_factors_common_from_orig_data_grids(const Depsgraph &depsgraph, const Brush &brush, const Object &object, Span< float3 > positions, Span< float3 > normals, const bke::pbvh::GridsNode &node, Vector< float > &r_factors, Vector< float > &r_distances)
void gather_bmesh_positions(const Set< BMVert *, 0 > &verts, MutableSpan< float3 > positions)
static void smooth_brush_toggle_off(Paint *paint, StrokeCache *cache)
bool brush_cursor_poll(bContext *C)
static GroupedSpan< int > calc_vert_neighbors_interior_impl(const OffsetIndices< int > faces, const Span< int > corner_verts, const GroupedSpan< int > vert_to_face, const BitSpan boundary_verts, const Set< OrderedEdge > &boundary_edges, const Span< bool > hide_poly, const Span< int > verts, const Span< float > factors, Vector< int > &r_offset_data, Vector< int > &r_data)
bool check_vertex_pivot_symmetry(const float vco[3], const float pco[3], const char symm)
static void tag_mesh_positions_changed(Object &object, const bool use_pbvh_draw)
void calc_brush_strength_factors(const StrokeCache &cache, const Brush &brush, Span< float > distances, MutableSpan< float > factors)
std::optional< Span< int > > orig_face_set_data_lookup_mesh(const Object &object, const bke::pbvh::MeshNode &node)
void gather_data_grids(const SubdivCCG &subdiv_ccg, Span< T > src, Span< int > grids, MutableSpan< T > node_data)
static void redo_empty_ui(bContext *, wmOperator *)
void vert_random_access_ensure(Object &object)
static void flip_qt_qt(float out[4], const float in[4], const ePaintSymmetryFlags symm)
std::optional< int > nearest_vert_calc_mesh(const bke::pbvh::Tree &pbvh, const Span< float3 > vert_positions, const Span< bool > hide_vert, const float3 &location, const float max_distance, const bool use_original)
void filter_below_plane_factors(Span< float3 > vert_positions, Span< int > verts, const float4 &plane, MutableSpan< float > factors)
void apply_hardness_to_distances(float radius, float hardness, MutableSpan< float > distances)
void calc_factors_common_grids(const Depsgraph &depsgraph, const Brush &brush, const Object &object, Span< float3 > positions, const bke::pbvh::GridsNode &node, Vector< float > &r_factors, Vector< float > &r_distances)
GroupedSpan< int > calc_vert_neighbors(OffsetIndices< int > faces, Span< int > corner_verts, GroupedSpan< int > vert_to_face, Span< bool > hide_poly, Span< int > verts, Vector< int > &r_offset_data, Vector< int > &r_data)
void gather_bmesh_normals(const Set< BMVert *, 0 > &verts, MutableSpan< float3 > normals)
static void pose_fake_neighbors_free(SculptSession &ss)
bool node_fully_masked_or_hidden(const bke::pbvh::Node &node)
float3 tilt_effective_normal_get(const SculptSession &ss, const Brush &brush)
void filter_translations(MutableSpan< float3 > translations, Span< float > factors)
static void stroke_cache_init(ViewContext &vc, const Sculpt &sd, const Brush &brush, Object &ob, const float mval[2])
Vector< BMVert *, 64 > BMeshNeighborVerts
void calc_factors_common_from_orig_data_mesh(const Depsgraph &depsgraph, const Brush &brush, const Object &object, const MeshAttributeData &attribute_data, Span< float3 > positions, Span< float3 > normals, const bke::pbvh::MeshNode &node, MutableSpan< float > r_factors, MutableSpan< float > r_distances)
ENUM_OPERATORS(AverageDataFlags)
void filter_distances_with_radius(float radius, Span< float > distances, MutableSpan< float > factors)
static const char * sculpt_brush_type_name(const Brush &brush)
int vertex_count_get(const Object &object)
std::optional< OrigPositionData > orig_position_data_lookup_grids(const Object &object, const bke::pbvh::GridsNode &node)
ePaintSymmetryAreas get_vertex_symm_area(const float co[3])
void stroke_modifiers_check(Depsgraph &depsgraph, Object &ob, const Brush *brush)
static bool over_mesh(bContext *C, wmOperator *, const float mval[2])
static const ImplicitSharingInfo * get_vertex_group_sharing_info(const Mesh &mesh)
static void cache_paint_brush_variants_update(StrokeCache &cache, const Brush &brush)
bool node_in_box_positive_z(const float4x4 &mat, const Bounds< float3 > &bounds)
void filter_region_clip_factors(const SculptSession &ss, Span< float3 > vert_positions, Span< int > verts, MutableSpan< float > factors)
void gather_data_bmesh(Span< T > src, const Set< BMVert *, 0 > &verts, MutableSpan< T > node_data)
static void fake_neighbor_init(Object &object, const float max_dist)
void reset_translations_to_original(MutableSpan< float3 > translations, Span< float3 > positions, Span< float3 > orig_positions)
bool stroke_is_first_brush_step_of_symmetry_pass(const StrokeCache &cache)
float3 symmetry_flip(const float3 &src, const ePaintSymmetryFlags symm)
static int sculpt_brush_needs_normal(const SculptSession &ss, const Brush &brush)
void orig_position_data_gather_bmesh(const BMLog &bm_log, const Set< BMVert *, 0 > &verts, MutableSpan< float3 > positions, MutableSpan< float3 > normals)
bool stroke_is_first_brush_step(const StrokeCache &cache)
static float area_normal_calc_weight(const float distance, const float radius_inv)
static void flip_qt(float quat[4], const ePaintSymmetryFlags symm)
void scale_translations(MutableSpan< float3 > translations, Span< float > factors)
GroupedSpan< int > calc_vert_neighbors_interior(OffsetIndices< int > faces, Span< int > corner_verts, GroupedSpan< int > vert_to_face, BitSpan boundary_verts, const Set< OrderedEdge > &boundary_edges, Span< bool > hide_poly, Span< int > verts, Vector< int > &r_offset_data, Vector< int > &r_data)
void calc_factors_common_mesh_indexed(const Depsgraph &depsgraph, const Brush &brush, const Object &object, const MeshAttributeData &attribute_data, Span< float3 > vert_positions, Span< float3 > vert_normals, const bke::pbvh::MeshNode &node, MutableSpan< float > factors, MutableSpan< float > distances)
static void brush_init_tex(const Sculpt &sd, SculptSession &ss)
static bool brush_type_needs_original(const char sculpt_brush_type)
bool paint_supports_dynamic_size(const Brush &br, PaintMode mode)
ePaintSymmetryFlags mesh_symmetry_xyz_get(const Object &object)
static void dynamic_topology_update(const Depsgraph &depsgraph, const Scene &scene, const Brush &brush, Object &ob, PaintModeData *)
bool sculpt_mode_poll(bContext *C)
static void sculpt_init_mirror_clipping(const Object &ob, const SculptSession &ss)
void calc_vertex_displacement(const SculptSession &ss, const Brush &brush, float translation[3])
void fake_neighbors_free(Object &ob)
float3 calc_motion_normal_from_angle(const ViewContext &vc, const float3 &tip_location, const float angle)
static void mask_brush_toggle_on(Main *bmain, Paint *paint, StrokeToggleSettings &toggle_settings)
static void brush_exit_tex(Sculpt &sd)
void calc_cube_tip_factors_common_bmesh(const Depsgraph &depsgraph, const Brush &brush, const Object &object, const float4x4 &mat, Span< float3 > positions, bke::pbvh::BMeshNode &node, Vector< float > &r_factors, Vector< float > &r_distances)
bool color_supported_check(const Scene &scene, Object &object, ReportList *reports)
static bool need_delta_from_anchored_origin(const Brush &brush)
static void calc_area_normal_and_center_node_grids(const Object &object, const Brush &brush, const AverageDataFlags flag, const bke::pbvh::GridsNode &node, SampleLocalData &tls, AreaNormalCenterData &anctd)
static wmOperatorStatus brush_stroke_modal(bContext *C, wmOperator *op, const wmEvent *event)
static void store_sculpt_entire_mesh(const wmOperator &op, const Scene &scene, Object &object, Mesh *new_mesh)
float raycast_init(ViewContext *vc, const float2 &mval, float3 &r_ray_start, float3 &r_ray_end, float3 &r_ray_normal, bool original)
static bool brush_type_needs_all_pbvh_nodes(const Brush &brush)
static float brush_flip(const Brush &brush, const StrokeCache &cache)
void filter_verts_outside_symmetry_area(Span< float3 > positions, const float3 &pivot, ePaintSymmetryFlags symm, MutableSpan< float > factors)
static void accumulate_area_center(const float3 &test_location, const float3 &position, const float distance, const float radius_inv, const int flip_index, AreaNormalCenterData &anctd)
static void rake_data_update(SculptRakeData *srd, const float co[3])
void calc_translations_to_plane(Span< float3 > vert_positions, Span< int > verts, const float4 &plane, MutableSpan< float3 > translations)
void scale_factors(MutableSpan< float > factors, float strength)
static void init_scene_project_brush_targets(const Depsgraph &depsgraph, ViewLayer &view_layer, const View3D &v3d, const Object &active_object, StrokeCache &cache)
float3 flip_v3_by_symm_area(const float3 &vector, const ePaintSymmetryFlags symm, const ePaintSymmetryAreas symmarea, const float3 &pivot)
static void brush_delta_update(const Depsgraph &depsgraph, Paint &paint, const Object &ob, const Brush &brush)
void do_symmetrical_brush_actions_with_tiling_and_feathering(const Depsgraph &depsgraph, const Scene &scene, const Paint &paint, Object &object, const BrushActionFn action_fn, PaintModeData *paint_mode_data)
static float3 calc_sculpt_normal(const Depsgraph &depsgraph, const Sculpt &sd, Object &ob, const IndexMask &node_mask)
bool brush_type_is_paint(const int tool)
void translations_from_new_positions(Span< float3 > new_positions, Span< int > verts, Span< float3 > old_positions, MutableSpan< float3 > translations)
static bool need_delta_for_tip_orientation(const Brush &brush)
void clip_and_lock_translations(const Sculpt &sd, const SculptSession &ss, Span< float3 > positions, Span< int > verts, MutableSpan< float3 > translations)
static void sculpt_brush_stroke_cancel(bContext *C, wmOperator *op)
IndexMask gather_nodes(const bke::pbvh::Tree &pbvh, const eBrushFalloffShape falloff_shape, const bool use_original, const float3 &location, const float radius_sq, const std::optional< float3 > &ray_direction, IndexMaskMemory &memory)
std::optional< float3 > stroke_get_location_bvh(Depsgraph &depsgraph, ViewContext &vc, const Sculpt &sd, const Brush *brush, const float mval[2], const bool force_original)
static void push_undo_nodes(const Depsgraph &depsgraph, Object &ob, const Brush &brush, const IndexMask &node_mask)
void calc_factors_common_mesh(const Depsgraph &depsgraph, const Brush &brush, const Object &object, const MeshAttributeData &attribute_data, Span< float3 > positions, Span< float3 > vert_normals, const bke::pbvh::MeshNode &node, MutableSpan< float > factors, MutableSpan< float > distances)
std::optional< Span< float4 > > orig_color_data_lookup_mesh(const Object &object, const bke::pbvh::MeshNode &node)
void scatter_data_mesh(Span< T > src, Span< int > indices, MutableSpan< T > dst)
static bool contains_nan(const Span< float > values)
bool sculpt_mode_poll_view3d(bContext *C)
void calc_brush_distances(const SculptSession &ss, Span< float3 > vert_positions, Span< int > vert, eBrushFalloffShape falloff_shape, MutableSpan< float > r_distances)
void SCULPT_OT_brush_stroke(wmOperatorType *ot)
void project_translations(MutableSpan< float3 > translations, const float3 &plane)
std::optional< ActiveElementInfo > active_element_info_get(ViewContext &vc, const float2 &mval)
void calc_brush_plane(const Depsgraph &depsgraph, const Brush &brush, Object &ob, const IndexMask &node_mask, float3 &r_area_no, float3 &r_area_co)
Span< BMVert * > vert_neighbors_get_interior_bmesh(BMVert &vert, BMeshNeighborVerts &r_neighbors)
static IndexMask pbvh_gather_generic_cube(Object &ob, const Brush &brush, const float4x4 &brush_local_mat, const bool use_original, IndexMaskMemory &memory)
void stroke_cache_common_init(ViewContext &vc, const Paint &paint, const Brush &brush, Object &object, const float2 mval)
std::optional< float3 > calc_area_normal(const Depsgraph &depsgraph, const Brush &brush, const Object &ob, const IndexMask &node_mask)
void filter_plane_trim_limit_factors(const Brush &brush, const StrokeCache &cache, Span< float3 > translations, MutableSpan< float > factors)
OffsetIndices< int > create_node_vert_offsets(Span< bke::pbvh::MeshNode > nodes, const IndexMask &node_mask, Array< int > &node_data)
Span< BMVert * > vert_neighbors_get_bmesh(BMVert &vert, BMeshNeighborVerts &r_neighbors)
void apply_translations(Span< float3 > translations, Span< int > verts, MutableSpan< float3 > positions)
bool node_in_box(const float4x4 &mat, const Bounds< float3 > &bounds, const float3 &brush_center, const float3 &brush_half_lengths, const bool test_z_axis)
const float * brush_frontface_normal_from_falloff_shape(const SculptSession &ss, char falloff_shape)
bool vertex_is_occluded(const Depsgraph &depsgraph, const Object &object, const float3 &position, bool original)
static void stroke_cache_update(ViewContext &vc, const Depsgraph &depsgraph, Paint &paint, Brush &brush, Object &object, const PaintStroke::StrokeStep &stroke_step)
void flush_update_step(bContext *C, const UpdateType update_type)
void calc_cube_tip_factors_common_grids(const Depsgraph &depsgraph, const Brush &brush, const Object &object, const float4x4 &mat, Span< float3 > positions, const bke::pbvh::GridsNode &node, Vector< float > &r_factors, Vector< float > &r_distances)
void flush_update_done(bContext *C, Object &ob, const UpdateType update_type)
static void fake_neighbor_search_bmesh(const SculptSession &ss, const float3 &location, const float max_distance_sq, const int island_id, const bke::pbvh::BMeshNode &node, NearestVertData &nvtd)
bool paint_brush_cursor_poll(bContext *C)
static bool is_brush_related_tool(bContext *C)
static void sculpt_fix_noise_tear(const Sculpt &sd, Object &ob)
static AreaNormalCenterData calc_area_normal_and_center_reduce(const AreaNormalCenterData &a, const AreaNormalCenterData &b)
void filter_above_plane_factors(Span< float3 > vert_positions, Span< int > verts, const float4 &plane, MutableSpan< float > factors)
void calc_area_center(const Depsgraph &depsgraph, const Brush &brush, const Object &ob, const IndexMask &node_mask, float r_area_co[3])
float object_space_radius_get(const ViewContext &vc, const Paint &paint, const Brush &brush, const float3 &location, const float scale_factor)
BLI_INLINE bool brush_type_is_attribute_only(const int tool)
static constexpr int plane_brush_max_rolling_average_num
float brush_plane_offset_get(const Brush &brush, const SculptSession &ss)
bool stroke_is_main_symmetry_pass(const StrokeCache &cache)
static void update_brush_local_mat(const Sculpt &sd, Object &ob)
static wmOperatorStatus sculpt_brush_stroke_exec(bContext *C, wmOperator *op)
static void calc_stabilized_plane(const Brush &brush, StrokeCache &cache, const float3 &plane_normal, const float3 &plane_center, float3 &r_stabilized_normal, float3 &r_stabilized_center)
float3 grab_delta_get(const Brush &brush, const StrokeCache &cache)
bool is_vertex_inside_brush_radius_symm(const float vertex[3], const float br_co[3], float radius, char symm)
void apply_crazyspace_to_translations(Span< float3x3 > deform_imats, Span< int > verts, MutableSpan< float3 > translations)
static void do_brush_action(const Depsgraph &depsgraph, const Scene &scene, const Brush &brush, Object &ob, PaintModeData *)
static void sculpt_find_nearest_to_ray_cb(bke::pbvh::Node &node, FindNearestToRayData &fntrd, float *tmin)
static bool topology_matches(const Mesh &a, const Mesh &b)
std::optional< BMVert * > nearest_vert_calc_bmesh(const bke::pbvh::Tree &pbvh, const float3 &location, const float max_distance, const bool use_original)
bool sculpt_mode_and_brush_poll(bContext *C)
Span< int > fake_neighbors_ensure(const Depsgraph &depsgraph, Object &ob, const float max_dist)
std::optional< CursorGeometryInfo > cursor_geometry_info_update(bContext *C, const float2 &mval, const bool use_sampled_normal)
static void fake_neighbor_search(const Depsgraph &depsgraph, const Object &ob, const float max_distance_sq, MutableSpan< int > fake_neighbors)
static float brush_strength(const Sculpt &sd, const StrokeCache &cache)
static wmOperatorStatus sculpt_brush_stroke_invoke(bContext *C, wmOperator *op, const wmEvent *event)
void calc_front_face(const float3 &view_normal, Span< float3 > normals, MutableSpan< float > factors)
void flip_quat_by_symm_area(float quat[4], const ePaintSymmetryFlags symm, const ePaintSymmetryAreas symmarea, const float pivot[3])
static void replace_attribute(const bke::AttributeAccessor src_attributes, const StringRef name, const bke::AttrDomain domain, const bke::AttrType data_type, bke::MutableAttributeAccessor dst_attributes)
static float3 area_center_calc_weighted(const float3 &test_location, const float distance, const float radius_inv, const float3 &co)
static void fake_neighbor_search_grids(const SculptSession &ss, const CCGKey &key, const Span< float3 > positions, const BitGroupVector<> &grid_hidden, const float3 &location, const float max_distance_sq, const int island_id, const bke::pbvh::GridsNode &node, NearestVertData &nvtd)
std::optional< Span< float > > orig_mask_data_lookup_mesh(const Object &object, const bke::pbvh::MeshNode &node)
static void calc_area_normal_and_center_node_bmesh(const Object &object, const Brush &brush, const AverageDataFlags flag, const bool has_bm_orco, const bke::pbvh::BMeshNode &node, SampleLocalData &tls, AreaNormalCenterData &anctd)
std::optional< SubdivCCGCoord > nearest_vert_calc_grids(const bke::pbvh::Tree &pbvh, const SubdivCCG &subdiv_ccg, const float3 &location, const float max_distance, const bool use_original)
std::optional< OrigPositionData > orig_position_data_lookup_mesh_all_verts(const Object &object, const bke::pbvh::MeshNode &node)
static IndexMask pbvh_gather_cursor_update(Object &ob, bool use_original, IndexMaskMemory &memory)
static bool brush_uses_topology_rake(const SculptSession &ss, const Brush &brush)
void calc_brush_distances_squared(const SculptSession &ss, Span< float3 > positions, Span< int > verts, eBrushFalloffShape falloff_shape, MutableSpan< float > r_distances)
void gather_grids_normals(const SubdivCCG &subdiv_ccg, Span< int > grids, MutableSpan< float3 > normals)
void calc_area_normal_and_center(const Depsgraph &depsgraph, const Brush &brush, const Object &ob, const IndexMask &node_mask, float r_area_no[3], float r_area_co[3])
void apply_brush_texture(const PaintMode paint_mode, const SculptSession &ss, const Brush &brush, const float brush_point[3], const int thread_id, float *r_value, float4 &r_rgba)
void calc_brush_local_mat(const float3 &tip_normal, const float3 &motion_normal_local, const float3 &tip_location, const float radius, float local_mat[4][4], float local_mat_inv[4][4])
void translations_from_offset_and_factors(const float3 &offset, Span< float > factors, MutableSpan< float3 > r_translations)
static StrokeToggleSettings create_toggle_settings(const wmOperator &op, Main &bmain, Paint &paint)
void calc_brush_cube_distances(const Brush &brush, const Span< T > positions, const MutableSpan< float > r_distances)
static float area_normal_and_center_get_normal_radius(const SculptSession &ss, const Brush &brush)
std::optional< OrigPositionData > orig_position_data_lookup_mesh(const Object &object, const bke::pbvh::MeshNode &node)
void store_mesh_from_eval(const wmOperator &op, const Scene &scene, const Depsgraph &depsgraph, const RegionView3D *rv3d, Object &object, Mesh *new_mesh)
void calc_local_positions(Span< float3 > vert_positions, Span< int > verts, const float4x4 &mat, const float3 &plane_center, const float3 &view_normal, eBrushFalloffShape falloff_shape, MutableSpan< float3 > local_positions)
void append_neighbors_to_vector(const OffsetIndices< int > faces, const Span< int > corner_verts, const GroupedSpan< int > vert_to_face, const Span< bool > hide_poly, const int vert, Vector< int > &r_data)
void calc_brush_texture_factors(PaintMode paint_mode, const SculptSession &ss, const Brush &brush, Span< float3 > vert_positions, Span< int > vert, MutableSpan< float > factors)
std::optional< Span< int > > orig_face_set_data_lookup_grids(const Object &object, const bke::pbvh::GridsNode &node)
static std::optional< float3 > stroke_get_location_bvh_ex(Depsgraph &depsgraph, ViewContext &vc, const Paint &paint, const Sculpt *sd, const float2 &mval, const bool force_original, const bool check_closest, const bool limit_closest_radius)
Span< int > vert_neighbors_get_mesh(const OffsetIndices< int > faces, const Span< int > corner_verts, const GroupedSpan< int > vert_to_face, const Span< bool > hide_poly, const int vert, Vector< int > &r_neighbors)
void fill_factor_from_hide(Span< bool > hide_vert, Span< int > verts, MutableSpan< float > r_factors)
static brushes::CursorSampleResult calc_brush_node_mask(const Depsgraph &depsgraph, const Sculpt &sd, Object &ob, const Brush &brush, IndexMaskMemory &memory)
void mask_overlay_check(bContext &C, wmOperator &op)
void scatter_data_grids(const SubdivCCG &subdiv_ccg, Span< T > node_data, Span< int > grids, MutableSpan< T > dst)
bool brush_uses_vector_displacement(const Brush &brush)
static void smooth_brush_toggle_on(Main *bmain, Paint *paint, StrokeToggleSettings &toggle_settings)
OffsetIndices< int > create_node_vert_offsets_bmesh(Span< bke::pbvh::BMeshNode > nodes, const IndexMask &node_mask, Array< int > &node_data)
void calc_factors_common_bmesh(const Depsgraph &depsgraph, const Brush &brush, const Object &object, Span< float3 > positions, bke::pbvh::BMeshNode &node, Vector< float > &r_factors, Vector< float > &r_distances)
static void update_sculpt_normal(const Depsgraph &depsgraph, const Sculpt &sd, Object &ob, const brushes::CursorSampleResult &cursor_sample_result)
void cache_calc_brushdata_symm(StrokeCache &cache, const ePaintSymmetryFlags symm, const char axis, const float angle)
bool brush_type_is_mask(const int tool)
static void accumulate_area_normal(const float3 &normal, const float distance, const float radius_inv, const int flip_index, AreaNormalCenterData &anctd)
bool paint_brush_tool_poll(bContext *C)
void tag_update_overlays(bContext *C)
void calc_factors_common_from_orig_data_bmesh(const Depsgraph &depsgraph, const Brush &brush, const Object &object, Span< float3 > positions, Span< float3 > normals, bke::pbvh::BMeshNode &node, Vector< float > &r_factors, Vector< float > &r_distances)
Span< float3 > vert_positions_for_grab_active_get(const Depsgraph &depsgraph, const Object &object)
static void mask_brush_toggle_off(Paint *paint, StrokeCache *cache)
float3 tilt_apply_to_normal(const Object &object, const float4x4 &view_inverse, const float3 &normal, const float2 &tilt, const float tilt_strength)
static float area_normal_and_center_get_position_radius(const SculptSession &ss, const Brush &brush)
static IndexMask pbvh_gather_generic(Object &ob, const Brush &brush, const bool use_original, const float radius_scale, IndexMaskMemory &memory)
static void sculpt_project_v3_normal_align(const StrokeCache &cache, const float normal_weight, float grab_delta[3])
bool is_symmetry_iteration_valid(const char i, const char symm)
constexpr ParallelGrainSize grain_size(int grain_size)
QuaternionBase< float > Quaternion
T length_squared(const VecBase< T, Size > &a)
VecBase< T, 3 > normal_tri(const VecBase< T, 3 > &v1, const VecBase< T, 3 > &v2, const VecBase< T, 3 > &v3)
T clamp(const T &a, const T &min, const T &max)
QuaternionBase< T > to_quaternion(const AxisAngleBase< T, AngleT > &axis_angle)
T safe_divide(const T &a, const T &b)
T reduce_max(const VecBase< T, Size > &a)
T distance(const T &a, const T &b)
T length(const VecBase< T, Size > &a)
AxisAngleBase< float, AngleRadianBase< float > > AxisAngle
QuaternionBase< T > normalize_and_get_length(const QuaternionBase< T > &q, T &out_length)
T dot(const QuaternionBase< T > &a, const QuaternionBase< T > &b)
T min(const T &a, const T &b)
CartesianBasis invert(const CartesianBasis &basis)
float3 rotate_direction_around_axis(const float3 &direction, const float3 &axis, float angle)
AxisSigned cross(const AxisSigned a, const AxisSigned b)
VectorT project_point(const MatT &mat, const VectorT &point)
MatT from_scale(const VecBase< typename MatT::base_type, ScaleDim > &scale)
T interpolate(const T &a, const T &b, const FactorT &t)
MatBase< T, NumCol, NumRow > normalize(const MatBase< T, NumCol, NumRow > &a)
T distance_squared(const VecBase< T, Size > &a, const VecBase< T, Size > &b)
T max(const T &a, const T &b)
VecBase< T, 3 > transform_direction(const MatBase< T, 3, 3 > &mat, const VecBase< T, 3 > &direction)
VecBase< T, 3 > transform_point(const CartesianBasis &basis, const VecBase< T, 3 > &v)
OffsetIndices< int > accumulate_counts_to_offsets(MutableSpan< int > counts_to_offsets, int start_offset=0)
void parallel_for(const IndexRange range, const int64_t grain_size, const Function &function, const TaskSizeHints &size_hints=detail::TaskSizeHints_Static(1))
auto isolate_task(const Function &function)
Value parallel_reduce(IndexRange range, int64_t grain_size, const Value &identity, const Function &function, const Reduction &reduction)
@ V3D_OVERLAY_SCULPT_SHOW_MASK
@ V3D_OVERLAY_SCULPT_SHOW_FACE_SETS
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
MINLINE float len_squared_v3v3(const float a[3], const float b[3]) ATTR_WARN_UNUSED_RESULT
float WM_event_tablet_data(const wmEvent *event, bool *r_pen_flip, float r_tilt[2])
struct bNodeTreeExec * ntreeTexBeginExecTree(struct bNodeTree *ntree)
void BKE_mesh_copy_parameters(Mesh *me_dst, const Mesh *me_src)
void BM_mesh_elem_index_ensure(BMesh *bm, const char htype)
ScrArea * CTX_wm_area(const bContext *C)
int RNA_enum_get(PointerRNA *ptr, const char *name)
void multires_mark_as_modified(Depsgraph *depsgraph, Object *object, MultiresModifiedFlags flags)
const Set< BMFace *, 0 > & BKE_pbvh_bmesh_node_faces(bke::pbvh::BMeshNode *node)
std::variant< std::monostate, int, BMVert * > ActiveVert
ViewContext ED_view3d_viewcontext_init(bContext *C, Depsgraph *depsgraph)
MultiresModifierData * BKE_sculpt_multires_active(const Scene *scene, Object *ob)
MINLINE void copy_v3_v3(float r[3], const float a[3])
float BKE_brush_sample_tex_3d(const Paint *paint, const Brush *br, const MTex *mtex, const float3 &point, float4 &rgba, int thread, ImagePool *pool)
void ED_view3d_win_to_origin(const ARegion *region, const float mval[2], float r_out[3])
ATTR_WARN_UNUSED_RESULT const BMLoop * l
void axis_angle_normalized_to_quat(float r[4], const float axis[3], float angle)
void BM_mesh_elem_table_ensure(BMesh *bm, const char htype)
bool BKE_base_is_visible(const View3D *v3d, const Base *base)
@ BRUSH_SNAKE_HOOK_DEFORM_ELASTIC
Depsgraph * CTX_data_depsgraph_pointer(const bContext *C)
void mul_v3_m4v3(float r[3], const float mat[4][4], const float vec[3])
MINLINE void copy_v2_v2(float r[2], const float a[2])
float BKE_brush_radius_get(const Paint *paint, const Brush *brush)
@ PAINT_FALLOFF_SHAPE_SPHERE
@ PAINT_FALLOFF_SHAPE_TUBE
void BKE_mesh_nomain_to_mesh(Mesh *mesh_src, Mesh *mesh_dst, Object *ob, bool process_shape_keys=true)
bool invert_m4_m4(float inverse[4][4], const float mat[4][4])
struct DistRayAABB_Precalc dist_squared_ray_to_aabb_v3_precalc(const float ray_origin[3], const float ray_direction[3])
void ED_paint_brush_type_update_sticky_shading_color(bContext *C, Object *ob)
float2 ED_view3d_project_float_v2_m4(const ARegion *region, const float co[3], const float4x4 &mat)
MINLINE void add_v3_fl(float r[3], float f)
MINLINE void copy_v4_fl(float r[4], float f)
void mul_m4_m4m4(float R[4][4], const float A[4][4], const float B[4][4])
void view3d_operator_needs_gpu(const bContext *C)
@ BRUSH_PLANE_SWAP_HEIGHT_AND_DEPTH
@ BRUSH_AREA_RADIUS_PRESSURE
@ BRUSH_SMOOTH_DEFORM_LAPLACIAN
@ BRUSH_SMOOTH_DEFORM_SURFACE
int CustomData_get_layer_index(const CustomData *data, eCustomDataType type)
ATTR_WARN_UNUSED_RESULT const BMVert * v
void BKE_brush_calc_curve_factors(eBrushCurvePreset preset, const CurveMapping *cumap, Span< float > distances, float brush_radius, MutableSpan< float > factors)
MatBase< float, 4, 4 > float4x4
void ED_region_tag_redraw(ARegion *region)
bool BKE_subdiv_ccg_coord_is_mesh_boundary(OffsetIndices< int > faces, Span< int > corner_verts, BitSpan boundary_verts, const Set< OrderedEdge > &boundary_edges, const SubdivCCG &subdiv_ccg, SubdivCCGCoord coord)
void closest_to_plane_normalized_v3(float r_close[3], const float plane[4], const float pt[3])
Base * CTX_data_active_base(const bContext *C)
void plane_from_point_normal_v3(float r_plane[4], const float plane_co[3], const float plane_no[3])
@ BRUSH_CLOTH_DEFORM_EXPAND
@ BRUSH_CLOTH_DEFORM_SNAKE_HOOK
@ BRUSH_CLOTH_DEFORM_GRAB
MINLINE float pow3f(float x)
bool BM_vert_is_boundary(const BMVert *v)
void BKE_sculptsession_free_pbvh(Object &object)
bool BKE_brush_use_alpha_pressure(const Brush *brush)
MINLINE float pow4f(float x)
void BKE_sculpt_mask_layers_ensure(Depsgraph *depsgraph, Main *bmain, Object *ob, MultiresModifierData *mmd)
std::optional< Array< bool > > BKE_keyblock_get_dependent_keys(const Key *key, int index)
MINLINE void mul_v3_fl(float r[3], float f)
MINLINE float pow2f(float x)
CCGKey BKE_subdiv_ccg_key_top_level(const SubdivCCG &subdiv_ccg)
void normalize_m4(float R[4][4]) ATTR_NONNULL()
@ SCULPT_BRUSH_TYPE_INFLATE
@ SCULPT_BRUSH_TYPE_SMEAR
@ SCULPT_BRUSH_TYPE_CLOTH
@ SCULPT_BRUSH_TYPE_SIMPLIFY
@ SCULPT_BRUSH_TYPE_SMOOTH
@ SCULPT_BRUSH_TYPE_CLAY_STRIPS
@ SCULPT_BRUSH_TYPE_CREASE
@ SCULPT_BRUSH_TYPE_DRAW_FACE_SETS
@ SCULPT_BRUSH_TYPE_PAINT
@ SCULPT_BRUSH_TYPE_PLANE
@ SCULPT_BRUSH_TYPE_SLIDE_RELAX
@ SCULPT_BRUSH_TYPE_PINCH
@ SCULPT_BRUSH_TYPE_ROTATE
@ SCULPT_BRUSH_TYPE_LAYER
@ SCULPT_BRUSH_TYPE_DISPLACEMENT_ERASER
@ SCULPT_BRUSH_TYPE_BOUNDARY
@ SCULPT_BRUSH_TYPE_DISPLACEMENT_SMEAR
@ SCULPT_BRUSH_TYPE_DRAW_SHARP
@ SCULPT_BRUSH_TYPE_SNAKE_HOOK
@ SCULPT_BRUSH_TYPE_CLAY_THUMB
@ SCULPT_BRUSH_TYPE_MULTIPLANE_SCRAPE
@ SCULPT_BRUSH_TYPE_SCENE_PROJECT
@ SCULPT_BRUSH_TYPE_THUMB
@ SCULPT_BRUSH_TYPE_NUDGE
@ SCULPT_BRUSH_TYPE_ELASTIC_DEFORM
float BKE_brush_unprojected_radius_get(const Paint *paint, const Brush *brush)
MINLINE void sub_v3_v3(float r[3], const float a[3])
void BKE_brush_unprojected_size_set(Paint *paint, Brush *brush, float unprojected_size)
VecBase< float, 4 > float4
void mul_m4_v3(const float M[4][4], float r[3])
void BKE_subdiv_ccg_neighbor_coords_get(const SubdivCCG &subdiv_ccg, const SubdivCCGCoord &coord, bool include_duplicates, SubdivCCGNeighbors &r_neighbors)
MINLINE void madd_v3_v3fl(float r[3], const float a[3], float f)
void BKE_curvemapping_init(CurveMapping *cumap)
KeyBlock * BKE_keyblock_find_by_index(Key *key, int index)
void BKE_pbvh_bmesh_node_save_orig(BMesh *bm, BMLog *log, bke::pbvh::BMeshNode *node, bool use_original)
@ BRUSH_PAINT_WET_MIX_PRESSURE_INVERT
@ BRUSH_PAINT_WET_PERSISTENCE_PRESSURE
@ BRUSH_PAINT_FLOW_PRESSURE_INVERT
@ BRUSH_PAINT_DENSITY_PRESSURE
@ BRUSH_PAINT_WET_MIX_PRESSURE
@ BRUSH_PAINT_DENSITY_PRESSURE_INVERT
@ BRUSH_PAINT_WET_PERSISTENCE_PRESSURE_INVERT
@ BRUSH_PAINT_FLOW_PRESSURE
VecBase< int32_t, 2 > int2
VecBase< float, 2 > float2
MINLINE void cross_v3_v3v3(float r[3], const float a[3], const float b[3])
void DEG_id_tag_update(ID *id, unsigned int flags)
void BKE_report(ReportList *reports, eReportType type, const char *message)
BMesh const char void * data
Mesh * BKE_mesh_from_object(Object *ob)
T * DEG_get_evaluated(const Depsgraph *depsgraph, T *id)
@ MULTIRES_COORDS_MODIFIED
wmWindowManager * CTX_wm_manager(const bContext *C)
Depsgraph * CTX_data_ensure_evaluated_depsgraph(const bContext *C, bool rna_write_check=false)
int CustomData_get_offset_named(const CustomData *data, eCustomDataType type, StringRef name)
float3 BKE_paint_seed_hsv_jitter()
void multires_stitch_grids(Object *)
int BM_mesh_elem_count(BMesh *bm, const char htype)
void BKE_pbvh_bmesh_after_stroke(BMesh &bm, bke::pbvh::Tree &pbvh)
int BKE_sculpt_get_grid_num_verts(const Object &object)
void quat_to_axis_angle(float axis[3], float *angle, const float q[4])
bool BKE_view_layer_synced_ensure(const Main &bmain, const Scene *scene, ViewLayer *view_layer)
void ntreeTexEndExecTree(struct bNodeTreeExec *exec)
MINLINE float plane_point_side_v3(const float plane[4], const float co[3])
int BKE_brush_size_get(const Paint *paint, const Brush *brush)
@ SCULPT_DYNTOPO_DETAIL_CONSTANT
@ SCULPT_DYNTOPO_COLLAPSE
@ SCULPT_DYNTOPO_SUBDIVIDE
@ SCULPT_DYNTOPO_DETAIL_MANUAL
@ SCULPT_DYNTOPO_DETAIL_BRUSH
BLI_INLINE bool BM_edge_is_boundary(const BMEdge *e) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
void interp_v3_v3v3(float r[3], const float a[3], const float b[3], float t)
float ED_view3d_calc_zfac(const RegionView3D *rv3d, const float co[3])
void isect_ray_tri_watertight_v3_precalc(struct IsectRayPrecalc *isect_precalc, const float ray_direction[3])
RegionView3D * CTX_wm_region_view3d(const bContext *C)
ToolSettings * CTX_data_tool_settings(const bContext *C)
bool BKE_paint_brush_set(Paint *paint, Brush *brush)
bool BKE_brush_use_locked_size(const Paint *paint, const Brush *brush)
bool paint_get_tex_pixel(const MTex *mtex, float u, float v, ImagePool *pool, int thread, float *r_intensity, float r_rgba[4])
int BLI_task_parallel_thread_id(const TaskParallelTLS *tls)
bool RNA_boolean_get(PointerRNA *ptr, const char *name)
void BKE_brush_size_set(Paint *paint, Brush *brush, int size)
const float * BM_log_find_original_vert_mask(BMLog *log, BMVert *v)
@ V3D_SHADING_VERTEX_COLOR
MINLINE void zero_v3(float r[3])
void BKE_id_free(Main *bmain, void *idv)
BLI_INLINE BMVert * BM_vert_at_index(BMesh *bm, const int index)
const MTex * BKE_brush_mask_texture_get(const Brush *brush, PaintMode paint_mode)
void WM_event_add_notifier(const bContext *C, uint type, void *reference)
void BKE_sculpt_color_layer_create_if_needed(Object *object)
int BKE_subdiv_ccg_grid_to_face_index(const SubdivCCG &subdiv_ccg, const int grid_index)
int CCG_grid_xy_to_index(const int grid_size, const int x, const int y)
void project_plane_v3_v3v3(float out[3], const float p[3], const float v_plane[3])
void mul_mat3_m4_v3(const float mat[4][4], float r[3])
MINLINE float normalize_v3_v3(float r[3], const float a[3])
@ BRUSH_AUTOMASKING_CAVITY_ALL
void paint_stroke_operator_properties(wmOperatorType *ot)
bool BKE_brush_use_size_pressure(const Brush *brush)
MINLINE void mul_v3_v3fl(float r[3], const float a[3], float f)
BMEdge * BM_edge_exists(BMVert *v_a, BMVert *v_b)
const Brush * BKE_paint_brush_for_read(const Paint *paint)
MINLINE float normalize_v3(float n[3])
wmOperatorType * WM_operatortype_find(const char *idname, bool quiet)
MINLINE void add_v3_v3(float r[3], const float a[3])
wmEventHandler_Op * WM_event_add_modal_handler(bContext *C, wmOperator *op)
void RNA_def_property_flag(PropertyRNA *prop, PropertyFlag flag)
MINLINE void sub_v3_v3v3(float r[3], const float a[3], const float b[3])
bool ED_view3d_clipping_test(const RegionView3D *rv3d, const float co[3], bool is_local)
void BKE_reportf(ReportList *reports, eReportType type, const char *format,...) ATTR_PRINTF_FORMAT(3
bool BKE_sculptsession_use_pbvh_draw(const Object *ob, const RegionView3D *rv3d)
void rotate_m4(float mat[4][4], char axis, float angle)
bool BKE_pbvh_node_fully_masked_get(const bke::pbvh::Node &node)
Main * CTX_data_main(const bContext *C)
void BLI_dial_free(Dial *dial)
ATTR_WARN_UNUSED_RESULT const BMVert * v2
Paint * BKE_paint_get_active_from_context(const bContext *C)
bool ED_view3d_win_to_segment_clipped(const Depsgraph *depsgraph, const ARegion *region, const View3D *v3d, const float mval[2], float r_ray_start[3], float r_ray_end[3], bool do_clip_planes)
bool BKE_brush_has_cube_tip(const Brush *brush, PaintMode paint_mode)
MINLINE float max_ff(float a, float b)
float paint_calc_object_space_radius(const ViewContext &vc, const float3 ¢er, float pixel_radius)
void closest_on_tri_to_point_v3(float r[3], const float p[3], const float v1[3], const float v2[3], const float v3[3])
@ BRUSH_DEFORM_TARGET_CLOTH_SIM
bool BKE_pbvh_node_fully_hidden_get(const bke::pbvh::Node &node)
Base * BKE_view_layer_base_find(ViewLayer *view_layer, Object *ob)
Dial * BLI_dial_init(const float start_position[2], float threshold)
MINLINE float square_f(float a)
void BKE_sculptsession_update_for_edit(Depsgraph *depsgraph, Object *ob_orig, bool is_paint_tool)
std::optional< BrushColorJitterSettings > BKE_brush_color_jitter_get_settings(const Paint *paint, const Brush *brush)
void BKE_subdiv_ccg_foreach_visible_grid_vert(const CCGKey &key, const BitGroupVector<> &grid_hidden, const int grid, const Fn &fn)
@ BRUSH_PROJECT_RAY_DIRECTION_PLANE_NORMAL
Brush * BKE_paint_brush(Paint *paint)
SubdivCCGAdjacencyType BKE_subdiv_ccg_coarse_mesh_adjacency_info_get(const SubdivCCG &subdiv_ccg, const SubdivCCGCoord &coord, Span< int > corner_verts, OffsetIndices< int > faces, int &r_v1, int &r_v2)
@ BRUSH_GRAB_ACTIVE_VERTEX
@ BRUSH_HARDNESS_PRESSURE
Scene * CTX_data_scene(const bContext *C)
ImagePool * BKE_image_pool_new()
float BLI_dial_angle(Dial *dial, const float current_position[2])
void copy_m4_m4(float m1[4][4], const float m2[4][4])
VecBase< float, 3 > float3
void BKE_pbvh_node_get_bm_orco_data(const bke::pbvh::BMeshNode &node, Span< float3 > &r_orig_positions, Span< int3 > &r_orig_tris)
void scale_m4_fl(float R[4][4], float scale)
PropertyRNA * RNA_def_boolean(StructOrFunctionRNA *cont_, const char *identifier, const bool default_value, const char *ui_name, const char *ui_description)
MINLINE float len_v3v3(const float a[3], const float b[3]) ATTR_WARN_UNUSED_RESULT
bool BKE_paint_brush_set_essentials(Main *bmain, Paint *paint, const char *name)
void ED_view3d_win_to_3d(const View3D *v3d, const ARegion *region, const float depth_pt[3], const float mval[2], float r_out[3])
void BKE_pbvh_node_mark_topology_update(bke::pbvh::Node &node)
bScreen * WM_window_get_active_screen(const wmWindow *win)
Object * CTX_data_active_object(const bContext *C)
MINLINE float dot_v3v3(const float a[3], const float b[3]) ATTR_WARN_UNUSED_RESULT
const float * BM_log_find_original_vert_co(BMLog *log, BMVert *v)
const Set< BMVert *, 0 > & BKE_pbvh_bmesh_node_unique_verts(bke::pbvh::BMeshNode *node)
ARegion * CTX_wm_region(const bContext *C)
float BKE_curvemapping_evaluateF(const CurveMapping *cumap, int cur, float value)
ListBaseT< Base > * BKE_view_layer_object_bases_get(ViewLayer *view_layer)
float dist_squared_ray_to_aabb_v3(const struct DistRayAABB_Precalc *data, const float bb_min[3], const float bb_max[3], float r_point[3], float *r_depth)
MINLINE bool is_zero_v3(const float v[3]) ATTR_WARN_UNUSED_RESULT
void ED_view3d_win_to_delta(const ARegion *region, const float xy_delta[2], float zfac, float r_out[3], bool precise=false)
View3D * CTX_wm_view3d(const bContext *C)
ATTR_WARN_UNUSED_RESULT const BMVert const BMEdge * e
float BKE_brush_alpha_get(const Paint *paint, const Brush *brush)
Mesh * BKE_object_get_evaluated_mesh(const Object *object_eval)
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
struct CurveMapping * curve_rand_value
struct CurveMapping * curve_rand_saturation
eBrushSculptType sculpt_brush_type
struct CurveMapping * curve_rand_hue
ListBaseT< KeyBlock > block
eMTex_BrushMapMode brush_map_mode
const c_style_mat & ptr() const
static MatBase identity()
bke::MeshRuntime * runtime
struct Object * mirror_ob
ListBaseT< ModifierData > modifiers
bke::ObjectRuntime * runtime
bke::PaintRuntime * runtime
struct ViewRender * view_render
struct ToolSettings * toolsettings
ListBaseT< ARegion > regionbase
ListBaseT< SpaceLink > spacedata
float current_max_distance
Array< int > fake_neighbor_index
std::unique_ptr< SculptBoundaryInfoCache > boundary_info_cache
ed::sculpt_paint::StrokeCache * cache
std::optional< int > active_face_index
KeyBlock * shapekey_active
void clear_active_elements(bool persist_last_active)
std::optional< float3 > cursor_sampled_normal
std::unique_ptr< SculptTopologyIslandCache > topology_island_cache
void set_active_vert(ActiveVert vert)
SculptFakeNeighbors fake_neighbors
float3 active_vert_position(const Depsgraph &depsgraph, const Object &object) const
std::optional< int > active_grid_index
ed::sculpt_paint::filter::Cache * filter_cache
Array< float3x3, 0 > deform_imats
MultiresModifierData * multires_modifier
ActiveVert active_vert() const
std::unique_ptr< bke::pbvh::Tree > pbvh
float3 cursor_view_normal
bool deform_modifiers_active
Array< uint8_t > vert_island_ids
struct Object * gravity_object
int to_index(const CCGKey &key) const
SubdivCCGNeighborCoords coords
Array< float3 > positions
BitGroupVector grid_hidden
struct bNodeTree * nodetree
float sculpt_mode_face_sets_opacity
float sculpt_mode_mask_opacity
eV3DShadingColorType color_type
bke::bNodeTreeRuntime * runtime
ListBaseT< struct ScrArea > areabase
const ImplicitSharingInfo * sharing_info
const ImplicitSharingInfo * face_offsets_sharing_info
SculptSession * sculpt_session
float initial_pixel_radius
float2 anchored_initial_mouse
std::array< float3, 2 > area_cos
std::array< int, 2 > count_no
std::array< int, 2 > count_co
std::array< float3, 2 > area_nos
OffsetIndices< int > faces
Span< float3 > vert_positions
VArraySpan< bool > hide_poly
const SubdivCCG * subdiv_ccg
MeshAttributeData(const Mesh &mesh)
VArraySpan< bool > hide_poly
VArraySpan< int > face_sets
VArraySpan< bool > hide_vert
static NearestVertData join(const NearestVertData &a, const NearestVertData &b)
float stroke_distance() const
wmOperatorStatus modal(bContext *C, wmOperator *op, const wmEvent *event)
wmOperatorStatus exec(bContext *C, wmOperator *op)
int active_face_grid_index
VArraySpan< bool > hide_poly
const SubdivCCG * subdiv_ccg
IsectRayPrecalc isect_precalc
OffsetIndices< int > faces
Span< float3 > vert_positions
Vector< float3 > positions
Vector< float > distances
std::optional< float3 > get_location(float2 mouse, bool force_original) override
SculptPaintStroke(bContext *C, wmOperator *op, const wmEvent *event)
bool test_start(wmOperator *op, float2 mouse) override
void redraw(bool final) override
void update_step(wmOperator *op, const StrokeStep &stroke_step) override
void done(bool is_cancel, bool stroke_started) override
bool test_cancel() override
static std::optional< ShapeKeyData > from_object(Object &object)
StrokeToggleSettings toggle_settings
std::optional< math::Quaternion > rake_rotation
struct blender::ed::sculpt_paint::StrokeCache::@152245166116023055361007250031254315334135310141 mirror_modifier_clip
float3 initial_normal_symm
Array< float > layer_displacement_factor
Vector< ProjectBrushTarget > project_targets
float3 gravity_direction_symm
float base_brush_strength
std::optional< float3 > initial_hsv_jitter
float4x4 brush_local_mat_inv
float3 sculpt_normal_symm
struct blender::ed::sculpt_paint::StrokeCache::@225223164012065274011166026353012314236244015262 plane_brush
std::unique_ptr< auto_mask::Cache > automasking
float dyntopo_pixel_radius
float3 initial_location_symm
struct blender::ed::sculpt_paint::StrokeCache::@211256062006232337057366306324060315203271114371 clay_thumb_brush
float4x4 symm_rot_mat_inv
struct blender::ed::sculpt_paint::StrokeCache::@346250254335162214324031351310170235363204044376 paint_brush
std::optional< math::Quaternion > rake_rotation_symm
float3 last_location_symm
ePaintSymmetryFlags mirror_symmetry_pass
float3 tip_motion_normal_symm
std::unique_ptr< cloth::SimulationData > cloth_sim
float3 orig_grab_location
bool initial_direction_flipped
Brush * original_active_brush
BrushMaskTool original_brush_mask_tool
void calc_cavity_factor(const Depsgraph &depsgraph, const Object &object, const IndexMask &node_mask)
std::optional< float3 > plane_normal
std::optional< float3 > plane_center
const AngleT & angle() const
const vec3_type & axis() const
wmOperatorStatus(*) exec(bContext *C, wmOperator *op) ATTR_WARN_UNUSED_RESULT
void(*) cancel(bContext *C, wmOperator *op)
void(*) ui(bContext *C, wmOperator *op)
bool(*) poll(bContext *C) ATTR_WARN_UNUSED_RESULT
wmOperatorStatus(*) invoke(bContext *C, wmOperator *op, const wmEvent *event) ATTR_WARN_UNUSED_RESULT
wmOperatorStatus(*) modal(bContext *C, wmOperator *op, const wmEvent *event) ATTR_WARN_UNUSED_RESULT
struct ReportList * reports
struct wmOperatorType * type