44 const bool flush_selection,
45 const bool flush_hidden)
48 const int *index_array =
nullptr;
52 if (
mesh ==
nullptr) {
60 if (flush_selection) {
67 if (ob_eval ==
nullptr) {
78 if (me_orig !=
nullptr && mesh_eval !=
nullptr && me_orig->
faces_num ==
mesh->faces_num) {
87 hide_poly_orig.finish();
89 if (flush_selection) {
96 select_poly_orig.finish();
100 if ((index_array =
static_cast<const int *
>(
110 const int orig_face_index = index_array[i];
112 hide_poly_eval.span[i] = hide_poly_orig[orig_face_index];
117 if (flush_selection) {
124 const int orig_face_index = index_array[i];
126 select_poly_eval.span[i] = select_poly_orig[orig_face_index];
129 select_poly_eval.
finish();
156 if (
mesh ==
nullptr ||
mesh->faces_num == 0) {
166 for (
int i = 0; i <
mesh->faces_num; i++) {
167 if (!hide_poly.
span[i]) {
168 if (!select_poly.span[i] == unselected) {
169 hide_poly.
span[i] =
true;
173 if (hide_poly.
span[i]) {
174 select_poly.span[i] =
false;
179 select_poly.finish();
189 if (
mesh ==
nullptr ||
mesh->faces_num == 0) {
202 select_poly.span[i] =
true;
208 attributes.
remove(
".hide_poly");
223 const bool skip_seams =
true)
237 for (const int face_index : range) {
238 if (hide_poly[face_index]) {
241 const Span<int> face_edges = corner_edges.slice(faces[face_index]);
243 for (const int poly_loop_index : face_edges.index_range()) {
244 const int outer_edge = face_edges[poly_loop_index];
245 if (skip_seams && uv_seams[outer_edge]) {
249 for (const int inner_edge :
250 face_edges.slice(poly_loop_index, face_edges.size() - poly_loop_index))
252 if (outer_edge == inner_edge) {
255 if (skip_seams && uv_seams[inner_edge]) {
258 islands.join(inner_edge, outer_edge);
283 for (
const int i : face_indices) {
284 for (
const int edge : corner_edges.
slice(faces[i])) {
285 if (uv_seams[edge]) {
288 const int root =
islands.find_root(edge);
289 selected_roots.add(root);
294 for (const int face_index : range) {
295 for (const int edge : corner_edges.slice(faces[face_index])) {
296 const int root = islands.find_root(edge);
297 if (selected_roots.contains(root)) {
298 select_poly.span[face_index] = select;
305 select_poly.finish();
311 if (
mesh ==
nullptr ||
mesh->faces_num == 0) {
329 indices.append(
index);
333 for (
const int i : select_poly.
span.index_range()) {
334 if (!select_poly.
span[i]) {
349 const int current_edge_index)
351 const int index_in_poly = corner_edges.
slice(face).
first_index(current_edge_index);
353 if (index_in_poly >= 2) {
354 return corner_edges[face[index_in_poly - 2]];
357 return corner_edges[face[index_in_poly + 2]];
365 const int edge_start_index,
372 int current_face_index = face_start_index;
373 int current_edge_index = edge_start_index;
375 while (current_edge_index > 0) {
376 int next_face_index = -1;
378 for (
const int face_index : edge_to_face_map[current_edge_index]) {
379 if (face_index != current_face_index) {
380 next_face_index = face_index;
386 if (next_face_index == -1) {
391 if (faces[next_face_index].size() != 4) {
396 if (r_loop_faces.
contains(next_face_index)) {
401 if (hide_poly[next_face_index]) {
405 r_loop_faces.
add(next_face_index);
407 const IndexRange next_face = faces[next_face_index];
409 current_face_index = next_face_index;
430 if (closest_edge_index == -1) {
445 faces, corner_edges,
mesh->edges_num, edge_to_face_offsets, edge_to_face_indices);
453 const Span<int> faces_to_closest_edge = edge_to_face_map[closest_edge_index];
456 if (faces_to_closest_edge.is_empty()) {
468 if (!traced_full_loop && faces_to_closest_edge.size() > 1) {
484 bool any_adjacent_poly_selected =
false;
485 for (
const int i : faces_to_closest_edge) {
486 any_adjacent_poly_selected |= select_poly.
span[i];
488 const bool select_toggle =
select && !any_adjacent_poly_selected;
489 select_poly.
span.fill_indices(faces_to_select.
as_span(), select_toggle);
500 for (
const int edge_index : face_edges) {
501 const int2 &edge = edges[edge_index];
505 if (select_vert[edge[0]] || select_vert[edge[1]]) {
510 if (select_vert[edge[0]] && select_vert[edge[1]]) {
533 for (const int i : range) {
534 if (select_poly.span[i] || hide_poly[i]) {
537 const IndexRange face = faces[i];
538 if (poly_has_selected_neighbor(corner_edges.slice(face), edges, select_vert.span, face_step))
540 select_poly.span[i] = true;
545 select_poly.finish();
546 select_vert.finish();
551 BitSpan verts_of_unselected_faces,
554 for (
const int edge_index : face_edges) {
555 const int2 &edge = edges[edge_index];
557 if (verts_of_unselected_faces[edge[0]] || verts_of_unselected_faces[edge[1]]) {
562 if (verts_of_unselected_faces[edge[0]] && verts_of_unselected_faces[edge[1]]) {
586 for (
const int i : faces.index_range()) {
587 if (select_poly.
span[i]) {
591 for (
const int vert : corner_verts.
slice(face)) {
592 verts_of_unselected_faces[vert].set(
true);
597 for (const int i : range) {
598 if (!select_poly.span[i] || hide_poly[i]) {
601 const IndexRange face = faces[i];
602 if (poly_has_unselected_neighbor(
603 corner_edges.slice(face), edges, verts_of_unselected_faces, face_step))
605 select_poly.span[i] = false;
610 select_poly.finish();
616 if (
mesh ==
nullptr) {
629 for (
int i = 0; i <
mesh->faces_num; i++) {
630 if (!hide_poly[i] && select_poly.span[i]) {
637 bool changed =
false;
639 for (
int i = 0; i <
mesh->faces_num; i++) {
643 const bool old_selection = select_poly.span[i];
646 select_poly.span[i] =
true;
649 select_poly.span[i] =
false;
652 select_poly.span[i] = !select_poly.span[i];
656 if (old_selection != select_poly.span[i]) {
674 float vec[3], bmat[3][3];
681 copy_m3_m4(bmat, ob->object_to_world().ptr());
692 for (
int i = 0; i <
mesh->faces_num; i++) {
693 if (hide_poly[i] || !select_poly[i]) {
697 for (
const int vert : corner_verts.
slice(faces[i])) {
699 add_v3_v3v3(vec, vec, ob->object_to_world().location());
715 bool changed =
false;
729 if (!hide_poly[
index]) {
751 select_poly.varray.set(
index,
true);
754 select_poly.varray.set(
index,
false);
757 select_poly.varray.set(
index, !select_poly.varray[
index]);
771 return changed || found;
778 if (
mesh ==
nullptr) {
786 if (mesh_eval ==
nullptr) {
793 const int *orig_indices =
static_cast<const int *
>(
802 for (
const int i : hide_vert_eval.span.index_range()) {
804 hide_vert_eval.span[i] = hide_vert_orig[orig_indices[i]];
819 for (
const int i : select_vert_eval.span.index_range()) {
821 select_vert_eval.span[i] = select_vert_orig[orig_indices[i]];
826 select_vert_orig.
materialize(select_vert_eval.span);
828 select_vert_eval.
finish();
839 if (
mesh ==
nullptr ||
mesh->faces_num == 0) {
850 for (const int2 &edge : edges.slice(range)) {
851 islands.join(edge[0], edge[1]);
855 bke::MutableAttributeAccessor attributes = mesh->attributes_for_write();
856 bke::SpanAttributeWriter<bool> select_vert = attributes.lookup_or_add_for_write_span<
bool>(
857 ".select_vert", bke::AttrDomain::Point);
859 Set<int> selected_roots;
861 for (
const int i : vertex_indices) {
862 const int root = islands.find_root(i);
863 selected_roots.add(root);
866 threading::parallel_for(select_vert.span.index_range(), 1024, [&](
const IndexRange range) {
867 for (const int i : range) {
868 const int root = islands.find_root(i);
869 if (selected_roots.contains(root)) {
870 select_vert.span[i] = select;
875 select_vert.finish();
883 const int region_coordinates[2],
898 if (
mesh ==
nullptr ||
mesh->faces_num == 0) {
907 for (
const int i : select_vert.
span.index_range()) {
908 if (!select_vert.
span[i]) {
937 faces, corner_edges,
mesh->edges_num, edge_to_face_offsets, edge_to_face_indices);
942 for (
int i = 0; i <
mesh->verts_num; i++) {
943 select_vert_original[i].set(select_vert.
span[i]);
949 const int2 &edge = edges[i];
950 if ((!select_vert_original[edge[0]] && !select_vert_original[edge[1]]) || hide_edge[i]) {
953 select_vert.
span[edge[0]] =
true;
954 select_vert.
span[edge[1]] =
true;
958 const Span<int> neighbor_polys = edge_to_face_map[i];
959 for (
const int face_i : neighbor_polys) {
960 if (hide_poly[face_i]) {
964 for (
const int vert : corner_verts.
slice(face)) {
965 select_vert.
span[vert] =
true;
993 faces, corner_edges, edges.
size(), edge_to_face_offsets, edge_to_face_indices);
998 for (
int i = 0; i <
mesh->verts_num; i++) {
999 select_vert_original[i].set(select_vert.
span[i]);
1003 const int2 &edge = edges[i];
1004 if ((select_vert_original[edge[0]] && select_vert_original[edge[1]]) && !hide_edge[i]) {
1007 select_vert.
span[edge[0]] =
false;
1008 select_vert.
span[edge[1]] =
false;
1013 for (
const int face_i : edge_to_face_map[i]) {
1014 if (hide_poly[face_i]) {
1018 for (
const int vert : corner_verts.
slice(face)) {
1019 select_vert.
span[vert] =
false;
1035 if (
mesh ==
nullptr) {
1048 for (
int i = 0; i <
mesh->verts_num; i++) {
1049 if (!hide_vert[i] && select_vert.span[i]) {
1056 bool changed =
false;
1057 for (
int i = 0; i <
mesh->verts_num; i++) {
1061 const bool old_selection = select_vert.span[i];
1064 select_vert.span[i] =
true;
1067 select_vert.span[i] =
false;
1070 select_vert.span[i] = !select_vert.span[i];
1073 if (old_selection != select_vert.span[i]) {
1102 if (
mesh ==
nullptr) {
1120 for (
const int i : select_vert.span.index_range()) {
1121 if (!hide_vert[i]) {
1122 if (dverts[i].dw ==
nullptr) {
1124 select_vert.span[i] =
true;
1139 if (
mesh ==
nullptr ||
mesh->verts_num == 0) {
1149 for (
const int i : hide_vert.
span.index_range()) {
1150 if (!hide_vert.
span[i]) {
1151 if (!select_vert.span[i] == unselected) {
1152 hide_vert.
span[i] =
true;
1156 if (hide_vert.
span[i]) {
1157 select_vert.span[i] =
false;
1161 select_vert.finish();
1172 if (
mesh ==
nullptr ||
mesh->verts_num == 0) {
1182 for (
const int i : select_vert.span.index_range()) {
1184 select_vert.span[i] =
select;
1191 attributes.
remove(
".hide_vert");
1202 const int vert_start_index,
1209 int current_edge_index = edge_start_index;
1210 int current_vert_index = vert_start_index;
1216 if (hide_vert[current_vert_index]) {
1221 const Span<int> connected_edges = vert_to_edge_map[current_vert_index];
1222 if (connected_edges.
size() != 4) {
1227 int next_edge_index = -1;
1228 const Span<int> current_edge_faces = edge_to_face_map[current_edge_index];
1230 for (
const int edge_index : connected_edges) {
1231 if (edge_index == current_edge_index) {
1236 const Span<int> other_edge_faces = edge_to_face_map[edge_index];
1240 next_edge_index = edge_index;
1245 if (next_edge_index == -1) {
1250 if (r_loop_edges.
contains(next_edge_index)) {
1254 r_loop_edges.
add(next_edge_index);
1257 const int2 next_edge_verts = edges[next_edge_index];
1259 current_edge_index = next_edge_index;
1275 uint closest_edge_index =
uint(-1);
1279 if (closest_edge_index ==
uint(-1)) {
1292 faces, corner_edges,
mesh->edges_num, edge_to_face_offsets, edge_to_face_indices);
1297 edges,
mesh->verts_num, vert_to_edge_offsets, vert_to_edge_indices);
1305 edges_in_loop.
add(closest_edge_index);
1308 const int2 start_verts = edges[closest_edge_index];
1332 for (
int e_idx : edges_in_loop) {
1333 verts_to_select.add(edges[e_idx][0]);
1334 verts_to_select.add(edges[e_idx][1]);
1337 const bool any_vert_selected = std::any_of(
1338 verts_to_select.begin(), verts_to_select.end(), [&](
const int vert) {
1339 return select_vert.span[vert];
1341 const bool select_toggle =
select && !any_vert_selected;
1342 select_vert.
span.fill_indices(verts_to_select.as_span(), select_toggle);
CustomData interface, see also DNA_customdata_types.h.
General operations, lookup, etc. for blender objects.
Object is a sort of wrapper for general info.
#define ED_MESH_PICK_DEFAULT_VERT_DIST
#define ED_MESH_PICK_DEFAULT_FACE_DIST
#define BLI_assert_unreachable()
constexpr IndexRange()=default
constexpr Span slice(int64_t start, int64_t size) const
constexpr int64_t first_index(const T &search_value) const
constexpr int64_t size() const
constexpr IndexRange index_range() const
constexpr bool is_empty() const
constexpr bool intersects__linear_search(Span other) const
IndexRange index_range() const
void materialize(MutableSpan< T > r_span) const
bool contains(const Key &key) const
Span< Key > as_span() const
GAttributeReader lookup_or_default(StringRef name, AttrDomain domain, AttrType data_type, const void *default_value=nullptr) const
GSpanAttributeWriter lookup_or_add_for_write_span(StringRef name, AttrDomain domain, AttrType data_type, const AttributeInit &initializer=AttributeInitDefaultValue())
bool remove(const StringRef name)
GAttributeWriter lookup_or_add_for_write(StringRef name, AttrDomain domain, AttrType data_type, const AttributeInit &initializer=AttributeInitDefaultValue())
GSpanAttributeWriter lookup_or_add_for_write_only_span(StringRef name, AttrDomain domain, AttrType data_type)
IndexRange index_range() const
int edge_other_vert(const int2 edge, const int vert)
GroupedSpan< int > build_edge_to_face_map(OffsetIndices< int > faces, Span< int > corner_edges, int edges_num, Array< int > &r_offsets, Array< int > &r_indices)
GroupedSpan< int > build_vert_to_edge_map(Span< int2 > edges, int verts_num, Array< int > &r_offsets, Array< int > &r_indices)
void mesh_select_vert_flush(Mesh &mesh)
void mesh_hide_vert_flush(Mesh &mesh)
void mesh_hide_face_flush(Mesh &mesh)
void mesh_select_face_flush(Mesh &mesh)
void parallel_for(const IndexRange range, const int64_t grain_size, const Function &function, const TaskSizeHints &size_hints=detail::TaskSizeHints_Static(1))
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
void paintface_hide(bContext *C, Object *ob, bool unselected)
void paintvert_hide(bContext *C, Object *ob, bool unselected)
ViewContext ED_view3d_viewcontext_init(bContext *C, Depsgraph *depsgraph)
static bool follow_edge_loop(const int edge_start_index, const int vert_start_index, const Span< int2 > edges, const VArray< bool > &hide_vert, const GroupedSpan< int > vert_to_edge_map, const GroupedSpan< int > edge_to_face_map, VectorSet< int > &r_loop_edges)
void paintvert_tag_select_update(bContext *C, Object *ob)
void copy_m3_m4(float m1[3][3], const float m2[4][4])
void minmax_v3v3_v3(float min[3], float max[3], const float vec[3])
MINLINE void add_v3_v3v3(float r[3], const float a[3], const float b[3])
static void paintvert_select_linked_vertices(bContext *C, Object *ob, const Span< int > vertex_indices, const bool select)
void BKE_mesh_mselect_clear(Mesh *mesh)
static void build_poly_connections(AtomicDisjointSet &islands, Mesh &mesh, const bool skip_seams=true)
void paintface_select_less(Mesh *mesh, bool face_step)
bool paintvert_deselect_all_visible(Object *ob, int action, bool flush_flags)
void ED_region_tag_redraw(ARegion *region)
void paintvert_select_loop(bContext *C, Object *ob, const int mval[2], const bool select)
void paintface_select_more(Mesh *mesh, bool face_step)
void paintface_reveal(bContext *C, Object *ob, bool select)
VecBase< int32_t, 2 > int2
bool ED_mesh_pick_face(bContext *C, Object *ob, const int mval[2], uint dist_px, uint *r_index)
void paintvert_select_more(Mesh *mesh, bool face_step)
bool paintface_minmax(Object *ob, float r_min[3], float r_max[3])
void DEG_id_tag_update(ID *id, unsigned int flags)
static void paintface_select_linked_faces(Mesh &mesh, const Span< int > face_indices, const bool select)
void BKE_mesh_mselect_validate(Mesh *mesh)
Mesh * BKE_mesh_from_object(Object *ob)
void BKE_mesh_batch_cache_dirty_tag(Mesh *mesh, eMeshBatchDirtyMode mode)
T * DEG_get_evaluated(const Depsgraph *depsgraph, T *id)
Depsgraph * CTX_data_ensure_evaluated_depsgraph(const bContext *C, bool rna_write_check=false)
static bool follow_face_loop(const int face_start_index, const int edge_start_index, const OffsetIndices< int > faces, const VArray< bool > &hide_poly, const Span< int > corner_edges, const GroupedSpan< int > edge_to_face_map, VectorSet< int > &r_loop_faces)
bool ED_mesh_pick_edge(bContext *C, Object *ob, const int mval[2], uint dist_px, uint *r_index)
bool paintface_deselect_all_visible(bContext *C, Object *ob, int action, bool flush_flags)
const void * CustomData_get_layer(const CustomData *data, eCustomDataType type)
void ED_view3d_init_mats_rv3d(const Object *ob, RegionView3D *rv3d)
static int get_opposing_edge_index(const IndexRange face, const Span< int > corner_edges, const int current_edge_index)
void paintvert_flush_flags(Object *ob)
void WM_event_add_notifier(const bContext *C, uint type, void *reference)
void ED_view3d_select_id_validate(const ViewContext *vc)
void paintvert_select_linked(bContext *C, Object *ob)
void paintface_select_loop(bContext *C, Object *ob, const int mval[2], bool select)
void paintface_select_linked(bContext *C, Object *ob, const int mval[2], bool select)
void paintvert_select_ungrouped(Object *ob, bool extend, bool flush_flags)
void paintface_flush_flags(bContext *C, Object *ob, bool flush_selection, bool flush_hidden)
static bool poly_has_selected_neighbor(Span< int > face_edges, Span< int2 > edges, Span< bool > select_vert, const bool face_step)
bool paintface_mouse_select(bContext *C, const int mval[2], const SelectPick_Params ¶ms, Object *ob)
bool ED_mesh_pick_vert(bContext *C, Object *ob, const int mval[2], uint dist_px, bool use_zbuf, uint *r_index)
@ BKE_MESH_BATCH_DIRTY_ALL
@ BKE_MESH_BATCH_DIRTY_SELECT_PAINT
void mul_v3_m3v3(float r[3], const float M[3][3], const float a[3])
void paintvert_reveal(bContext *C, Object *ob, bool select)
static bool poly_has_unselected_neighbor(Span< int > face_edges, Span< int2 > edges, BitSpan verts_of_unselected_faces, const bool face_step)
void paintvert_select_linked_pick(bContext *C, Object *ob, const int region_coordinates[2], bool select)
void paintvert_select_less(Mesh *mesh, bool face_step)
ARegion * CTX_wm_region(const bContext *C)
Mesh * BKE_object_get_evaluated_mesh(const Object *object_eval)
static BMFace * face_step(BMEdge *edge, BMFace *f)
bke::ObjectRuntime * runtime
MutableVArraySpan< T > span