Blender V5.3
mesh_attributes.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2024 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
11#include "BLI_virtual_array.hh"
12
13#include "BKE_attribute_math.hh"
14#include "BKE_deform.hh"
15#include "BKE_mesh.hh"
16
17#include "DNA_meshdata_types.h"
18#include "DNA_object_types.h"
19
20#include "BLI_listbase.hh"
21
23
25
26namespace blender::bke {
27
28template<typename T>
30 const VArray<T> &src,
31 MutableSpan<T> r_dst)
32{
33 BLI_assert(r_dst.size() == mesh.verts_num);
34 const GroupedSpan<int> vert_to_face_map = mesh.vert_to_face_map();
35 const Span<int> corner_verts = mesh.corner_verts();
36 const OffsetIndices<int> faces = mesh.faces();
37
38 threading::parallel_for(vert_to_face_map.index_range(), 2048, [&](const IndexRange range) {
39 for (const int64_t vert : range) {
40 const Span<int> vert_faces = vert_to_face_map[vert];
41
42 attribute_math::DefaultMixer<T> mixer({&r_dst[vert], 1});
43 for (const int face : vert_faces) {
44 const int corner = mesh::face_find_corner_from_vert(faces[face], corner_verts, int(vert));
45 mixer.mix_in(0, src[corner]);
46 }
47 mixer.finalize();
48 }
49 });
50}
51
52/* A vertex is selected if all connected face corners were selected and it is not loose. */
53template<>
55 const VArray<bool> &src,
57{
58 BLI_assert(r_dst.size() == mesh.verts_num);
59 const Span<int> corner_verts = mesh.corner_verts();
60
61 r_dst.fill(true);
62 threading::parallel_for(IndexRange(mesh.corners_num), 4096, [&](const IndexRange range) {
63 for (const int corner : range) {
64 const int vert = corner_verts[corner];
65 if (!src[corner]) {
66 r_dst[vert] = false;
67 }
68 }
69 });
70
71 /* Deselect loose vertices without corners that are still selected from the 'true' default. */
72 index_mask::masked_fill(r_dst, false, mesh.loose_verts());
73}
74
76{
77 GArray<> values(varray.type(), mesh.verts_num);
78 attribute_math::to_static_type(varray.type(), [&]<typename T>() {
79 if constexpr (!std::is_void_v<attribute_math::DefaultMixer<T>>) {
80 /* We compute all interpolated values at once, because for this interpolation, one has to
81 * iterate over all loops anyway. */
82 adapt_mesh_domain_corner_to_point_impl<T>(
83 mesh, varray.typed<T>(), values.as_mutable_span().typed<T>());
84 }
85 });
86 return GVArray::from_garray(std::move(values));
87}
88
93{
94 const Span<int> corner_verts = mesh.corner_verts();
95
96 GVArray new_varray;
97 attribute_math::to_static_type(varray.type(), [&]<typename T>() {
98 new_varray = VArray<T>::from_func(
99 mesh.corners_num, [corner_verts, varray = varray.typed<T>()](const int64_t corner) {
100 return varray[corner_verts[corner]];
101 });
102 });
103 return new_varray;
104}
105
107{
108 const OffsetIndices faces = mesh.faces();
109
110 GVArray new_varray;
111 attribute_math::to_static_type(varray.type(), [&]<typename T>() {
112 if constexpr (!std::is_void_v<attribute_math::DefaultMixer<T>>) {
113 if constexpr (std::is_same_v<T, bool>) {
114 new_varray = VArray<T>::from_func(
115 faces.size(), [faces, varray = varray.typed<bool>()](const int face_index) {
116 /* A face is selected if all of its corners were selected. */
117 for (const int corner : faces[face_index]) {
118 if (!varray[corner]) {
119 return false;
120 }
121 }
122 return true;
123 });
124 }
125 else {
126 new_varray = VArray<T>::from_func(
127 faces.size(), [faces, varray = varray.typed<T>()](const int face_index) {
128 T return_value;
129 attribute_math::DefaultMixer<T> mixer({&return_value, 1});
130 for (const int corner : faces[face_index]) {
131 const T value = varray[corner];
132 mixer.mix_in(0, value);
133 }
134 mixer.finalize();
135 return return_value;
136 });
137 }
138 }
139 });
140 return new_varray;
141}
142
143template<typename T>
145 const VArray<T> &old_values,
146 MutableSpan<T> r_values)
147{
148 BLI_assert(r_values.size() == mesh.edges_num);
149 const OffsetIndices faces = mesh.faces();
150 const Span<int> corner_edges = mesh.corner_edges();
151
152 attribute_math::DefaultMixer<T> mixer(r_values);
153
154 for (const int face_index : faces.index_range()) {
155 const IndexRange face = faces[face_index];
156
157 /* For every edge, mix values from the two adjacent corners (the current and next corner). */
158 for (const int corner : face) {
159 const int next_corner = mesh::face_corner_next(face, corner);
160 const int edge_index = corner_edges[corner];
161 mixer.mix_in(edge_index, old_values[corner]);
162 mixer.mix_in(edge_index, old_values[next_corner]);
163 }
164 }
165
166 mixer.finalize();
167}
168
169/* An edge is selected if all corners on adjacent faces were selected. */
170template<>
172 const VArray<bool> &old_values,
173 MutableSpan<bool> r_values)
174{
175 BLI_assert(r_values.size() == mesh.edges_num);
176 const OffsetIndices faces = mesh.faces();
177 const Span<int> corner_edges = mesh.corner_edges();
178
179 r_values.fill(true);
180 for (const int face_index : faces.index_range()) {
181 const IndexRange face = faces[face_index];
182
183 for (const int corner : face) {
184 const int next_corner = mesh::face_corner_next(face, corner);
185 const int edge_index = corner_edges[corner];
186 if (!old_values[corner] || !old_values[next_corner]) {
187 r_values[edge_index] = false;
188 }
189 }
190 }
191
192 index_mask::masked_fill(r_values, false, mesh.loose_edges());
193}
194
196{
197 GArray<> values(varray.type(), mesh.edges_num);
198 attribute_math::to_static_type(varray.type(), [&]<typename T>() {
199 if constexpr (!std::is_void_v<attribute_math::DefaultMixer<T>>) {
200 adapt_mesh_domain_corner_to_edge_impl<T>(
201 mesh, varray.typed<T>(), values.as_mutable_span().typed<T>());
202 }
203 });
204 return GVArray::from_garray(std::move(values));
205}
206
208{
209 GVArray new_varray;
210 attribute_math::to_static_type(varray.type(), [&]<typename T>() {
211 if constexpr (!std::is_void_v<attribute_math::DefaultMixer<T>>) {
212 VArray<T> src = varray.typed<T>();
213 const GroupedSpan<int> vert_to_face_map = mesh.vert_to_face_map();
214 if constexpr (std::is_same_v<T, bool>) {
215 new_varray = VArray<T>::from_func(
216 mesh.verts_num, [vert_to_face_map, src](const int point_i) {
217 const Span<int> vert_faces = vert_to_face_map[point_i];
218 /* A vertex is selected if any of the connected faces were selected. */
219 return std::any_of(
220 vert_faces.begin(), vert_faces.end(), [&](const int face) { return src[face]; });
221 });
222 }
223 else {
224 new_varray = VArray<T>::from_func(
225 mesh.verts_num, [vert_to_face_map, src](const int point_i) {
226 const Span<int> vert_faces = vert_to_face_map[point_i];
227 T return_value;
228 attribute_math::DefaultMixer<T> mixer({&return_value, 1});
229 for (const int face : vert_faces) {
230 mixer.mix_in(0, src[face]);
231 }
232 mixer.finalize();
233 return return_value;
234 });
235 }
236 }
237 });
238 return new_varray;
239}
240
241/* Each corner's value is simply a copy of the value at its face. */
243{
244 const OffsetIndices faces = mesh.faces();
245 GArray<> values(varray.type(), mesh.corners_num);
246 attribute_math::gather_to_groups(faces, faces.index_range(), GVArraySpan(varray), values);
247 return GVArray::from_garray(std::move(values));
248}
249
250template<typename T>
252 const VArray<T> &old_values,
253 MutableSpan<T> r_values)
254{
255 BLI_assert(r_values.size() == mesh.edges_num);
256 const OffsetIndices faces = mesh.faces();
257 const Span<int> corner_edges = mesh.corner_edges();
258
259 attribute_math::DefaultMixer<T> mixer(r_values);
260
261 for (const int face_index : faces.index_range()) {
262 const T value = old_values[face_index];
263 for (const int edge : corner_edges.slice(faces[face_index])) {
264 mixer.mix_in(edge, value);
265 }
266 }
267 mixer.finalize();
268}
269
270/* An edge is selected if any connected face was selected. */
271template<>
273 const VArray<bool> &old_values,
274 MutableSpan<bool> r_values)
275{
276 BLI_assert(r_values.size() == mesh.edges_num);
277 const OffsetIndices faces = mesh.faces();
278 const Span<int> corner_edges = mesh.corner_edges();
279
280 r_values.fill(false);
281 threading::parallel_for(faces.index_range(), 2048, [&](const IndexRange range) {
282 for (const int face_index : range) {
283 if (old_values[face_index]) {
284 for (const int edge : corner_edges.slice(faces[face_index])) {
285 r_values[edge] = true;
286 }
287 }
288 }
289 });
290}
291
293{
294 GArray<> values(varray.type(), mesh.edges_num);
295 attribute_math::to_static_type(varray.type(), [&]<typename T>() {
296 if constexpr (!std::is_void_v<attribute_math::DefaultMixer<T>>) {
297 adapt_mesh_domain_face_to_edge_impl<T>(
298 mesh, varray.typed<T>(), values.as_mutable_span().typed<T>());
299 }
300 });
301 return GVArray::from_garray(std::move(values));
302}
303
305{
306 const OffsetIndices faces = mesh.faces();
307 const Span<int> corner_verts = mesh.corner_verts();
308
309 GVArray new_varray;
310 attribute_math::to_static_type(varray.type(), [&]<typename T>() {
311 if constexpr (!std::is_void_v<attribute_math::DefaultMixer<T>>) {
312 if constexpr (std::is_same_v<T, bool>) {
313 new_varray = VArray<T>::from_func(
314 mesh.faces_num,
315 [corner_verts, faces, varray = varray.typed<bool>()](const int face_index) {
316 /* A face is selected if all of its vertices were selected. */
317 for (const int vert : corner_verts.slice(faces[face_index])) {
318 if (!varray[vert]) {
319 return false;
320 }
321 }
322 return true;
323 });
324 }
325 else {
326 new_varray = VArray<T>::from_func(
327 mesh.faces_num,
328 [corner_verts, faces, varray = varray.typed<T>()](const int face_index) {
329 T return_value;
330 attribute_math::DefaultMixer<T> mixer({&return_value, 1});
331 for (const int vert : corner_verts.slice(faces[face_index])) {
332 mixer.mix_in(0, varray[vert]);
333 }
334 mixer.finalize();
335 return return_value;
336 });
337 }
338 }
339 });
340 return new_varray;
341}
342
344{
345 const Span<int2> edges = mesh.edges();
346
347 GVArray new_varray;
348 attribute_math::to_static_type(varray.type(), [&]<typename T>() {
349 if constexpr (!std::is_void_v<attribute_math::DefaultMixer<T>>) {
350 if constexpr (std::is_same_v<T, bool>) {
351 /* An edge is selected if both of its vertices were selected. */
352 new_varray = VArray<bool>::from_func(
353 edges.size(), [edges, varray = varray.typed<bool>()](const int edge_index) {
354 const int2 &edge = edges[edge_index];
355 return varray[edge[0]] && varray[edge[1]];
356 });
357 }
358 else {
359 new_varray = VArray<T>::from_func(
360 edges.size(), [edges, varray = varray.typed<T>()](const int edge_index) {
361 const int2 &edge = edges[edge_index];
362 return attribute_math::mix2(0.5f, varray[edge[0]], varray[edge[1]]);
363 });
364 }
365 }
366 });
367 return new_varray;
368}
369
370template<typename T>
372 const VArray<T> &old_values,
373 MutableSpan<T> r_values)
374{
375 BLI_assert(r_values.size() == mesh.corners_num);
376 const OffsetIndices faces = mesh.faces();
377 const Span<int> corner_edges = mesh.corner_edges();
378
379 attribute_math::DefaultMixer<T> mixer(r_values);
380
381 for (const int face_index : faces.index_range()) {
382 const IndexRange face = faces[face_index];
383
384 /* For every corner, mix the values from the adjacent edges on the face. */
385 for (const int corner : face) {
386 const int corner_prev = mesh::face_corner_prev(face, corner);
387 const int edge = corner_edges[corner];
388 const int edge_prev = corner_edges[corner_prev];
389 mixer.mix_in(corner, old_values[edge]);
390 mixer.mix_in(corner, old_values[edge_prev]);
391 }
392 }
393
394 mixer.finalize();
395}
396
397/* A corner is selected if its two adjacent edges were selected. */
398template<>
400 const VArray<bool> &old_values,
401 MutableSpan<bool> r_values)
402{
403 BLI_assert(r_values.size() == mesh.corners_num);
404 const OffsetIndices faces = mesh.faces();
405 const Span<int> corner_edges = mesh.corner_edges();
406
407 r_values.fill(false);
408
409 threading::parallel_for(faces.index_range(), 2048, [&](const IndexRange range) {
410 for (const int face_index : range) {
411 const IndexRange face = faces[face_index];
412 for (const int corner : face) {
413 const int corner_prev = mesh::face_corner_prev(face, corner);
414 const int edge = corner_edges[corner];
415 const int edge_prev = corner_edges[corner_prev];
416 if (old_values[edge] && old_values[edge_prev]) {
417 r_values[corner] = true;
418 }
419 }
420 }
421 });
422}
423
425{
426 GArray<> values(varray.type(), mesh.corners_num);
427 attribute_math::to_static_type(varray.type(), [&]<typename T>() {
428 if constexpr (!std::is_void_v<attribute_math::DefaultMixer<T>>) {
429 adapt_mesh_domain_edge_to_corner_impl<T>(
430 mesh, varray.typed<T>(), values.as_mutable_span().typed<T>());
431 }
432 });
433 return GVArray::from_garray(std::move(values));
434}
435
436template<typename T>
438 const VArray<T> &old_values,
439 MutableSpan<T> r_values)
440{
441 BLI_assert(r_values.size() == mesh.verts_num);
442 const Span<int2> edges = mesh.edges();
443
444 attribute_math::DefaultMixer<T> mixer(r_values);
445
446 for (const int edge_index : IndexRange(mesh.edges_num)) {
447 const int2 &edge = edges[edge_index];
448 const T value = old_values[edge_index];
449 mixer.mix_in(edge[0], value);
450 mixer.mix_in(edge[1], value);
451 }
452
453 mixer.finalize();
454}
455
456/* A vertex is selected if any connected edge was selected. */
457template<>
459 const VArray<bool> &old_values,
460 MutableSpan<bool> r_values)
461{
462 BLI_assert(r_values.size() == mesh.verts_num);
463 const Span<int2> edges = mesh.edges();
464
465 /* Multiple threads can write to the same index here, but they are only
466 * writing true, and writing to single bytes is expected to be threadsafe. */
467 r_values.fill(false);
468 threading::parallel_for(edges.index_range(), 4096, [&](const IndexRange range) {
469 for (const int edge_index : range) {
470 if (old_values[edge_index]) {
471 const int2 &edge = edges[edge_index];
472 r_values[edge[0]] = true;
473 r_values[edge[1]] = true;
474 }
475 }
476 });
477}
478
480{
481 GArray<> values(varray.type(), mesh.verts_num);
482 attribute_math::to_static_type(varray.type(), [&]<typename T>() {
483 if constexpr (!std::is_void_v<attribute_math::DefaultMixer<T>>) {
484 adapt_mesh_domain_edge_to_point_impl<T>(
485 mesh, varray.typed<T>(), values.as_mutable_span().typed<T>());
486 }
487 });
488 return GVArray::from_garray(std::move(values));
489}
490
492{
493 const OffsetIndices faces = mesh.faces();
494 const Span<int> corner_edges = mesh.corner_edges();
495
496 GVArray new_varray;
497 attribute_math::to_static_type(varray.type(), [&]<typename T>() {
498 if constexpr (!std::is_void_v<attribute_math::DefaultMixer<T>>) {
499 if constexpr (std::is_same_v<T, bool>) {
500 /* A face is selected if all of its edges are selected. */
501 new_varray = VArray<bool>::from_func(
502 faces.size(), [corner_edges, faces, varray = varray.typed<T>()](const int face_index) {
503 for (const int edge : corner_edges.slice(faces[face_index])) {
504 if (!varray[edge]) {
505 return false;
506 }
507 }
508 return true;
509 });
510 }
511 else {
512 new_varray = VArray<T>::from_func(
513 faces.size(), [corner_edges, faces, varray = varray.typed<T>()](const int face_index) {
514 T return_value;
515 attribute_math::DefaultMixer<T> mixer({&return_value, 1});
516 for (const int edge : corner_edges.slice(faces[face_index])) {
517 mixer.mix_in(0, varray[edge]);
518 }
519 mixer.finalize();
520 return return_value;
521 });
522 }
523 }
524 });
525 return new_varray;
526}
527
529 const AttrDomain from_domain,
530 const AttrDomain to_domain)
531{
532 /* For some domain combinations, a single value will always map directly. For others, there may
533 * be loose elements on the result domain that should have the default value rather than the
534 * single value from the source. */
535 switch (from_domain) {
537 /* All other domains are always connected to points. */
538 return true;
539 case AttrDomain::Edge:
540 if (to_domain == AttrDomain::Point) {
541 return mesh.loose_verts().is_empty();
542 }
543 return true;
544 case AttrDomain::Face:
545 if (to_domain == AttrDomain::Point) {
546 return mesh.verts_no_face().is_empty();
547 }
548 if (to_domain == AttrDomain::Edge) {
549 return mesh.loose_edges().is_empty();
550 }
551 return true;
553 if (to_domain == AttrDomain::Point) {
554 return mesh.verts_no_face().is_empty();
555 }
556 if (to_domain == AttrDomain::Edge) {
557 return mesh.loose_edges().is_empty();
558 }
559 return true;
560 default:
562 return false;
563 }
564}
565
567 const GVArray &varray,
568 const AttrDomain from_domain,
569 const AttrDomain to_domain)
570{
571 if (!varray) {
572 return {};
573 }
574 if (varray.is_empty()) {
575 return {};
576 }
577 if (from_domain == to_domain) {
578 return varray;
579 }
580 if (varray.is_single()) {
581 if (can_simple_adapt_for_single(mesh, from_domain, to_domain)) {
582 BUFFER_FOR_CPP_TYPE_VALUE(varray.type(), value);
583 varray.get_internal_single(value);
584 return GVArray::from_single(varray.type(), mesh.attributes().domain_size(to_domain), value);
585 }
586 }
587
588 switch (from_domain) {
589 case AttrDomain::Corner: {
590 switch (to_domain) {
593 case AttrDomain::Face:
595 case AttrDomain::Edge:
597 default:
598 break;
599 }
600 break;
601 }
602 case AttrDomain::Point: {
603 switch (to_domain) {
606 case AttrDomain::Face:
608 case AttrDomain::Edge:
610 default:
611 break;
612 }
613 break;
614 }
615 case AttrDomain::Face: {
616 switch (to_domain) {
621 case AttrDomain::Edge:
622 return adapt_mesh_domain_face_to_edge(mesh, varray);
623 default:
624 break;
625 }
626 break;
627 }
628 case AttrDomain::Edge: {
629 switch (to_domain) {
634 case AttrDomain::Face:
635 return adapt_mesh_domain_edge_to_face(mesh, varray);
636 default:
637 break;
638 }
639 break;
640 }
641 default:
642 break;
643 }
644
645 return {};
646}
647
648static void tag_positions_changed(void *owner)
649{
650 Mesh *mesh = static_cast<Mesh *>(owner);
651 mesh->tag_positions_changed();
652}
653
654static void tag_sharpness_changed(void *owner)
655{
656 Mesh *mesh = static_cast<Mesh *>(owner);
657 mesh->tag_sharpness_changed();
658}
659
660static void tag_material_index_changed(void *owner)
661{
662 Mesh *mesh = static_cast<Mesh *>(owner);
663 mesh->tag_material_index_changed();
664}
665
666static void tag_visibility_changed(void *owner)
667{
668 Mesh &mesh = *static_cast<Mesh *>(owner);
669 mesh.tag_visibility_changed();
670}
671
672static void tag_custom_normals_changed(void *owner)
673{
674 Mesh &mesh = *static_cast<Mesh *>(owner);
675 mesh.tag_custom_normals_changed();
676}
677
678static const auto &changed_tags()
679{
680 static Map<StringRef, AttrUpdateOnChange> attributes{
681 {"position", tag_positions_changed},
682 {"sharp_edge", tag_sharpness_changed},
683 {"sharp_face", tag_sharpness_changed},
684 {"material_index", tag_material_index_changed},
685 {".hide_vert", tag_visibility_changed},
686 {".hide_edge", tag_visibility_changed},
687 {".hide_poly", tag_visibility_changed},
688 {"custom_normal", tag_custom_normals_changed},
689 };
690 return attributes;
691}
692
693static const auto &array_storage_required()
694{
695 static Set<StringRef> attributes{"position", ".edge_verts", ".corner_vert", ".corner_edge"};
696 return attributes;
697}
698
699static int get_domain_size(const void *owner, const AttrDomain domain)
700{
701 const Mesh *mesh = static_cast<const Mesh *>(owner);
702 switch (domain) {
704 return mesh->verts_num;
705 case AttrDomain::Edge:
706 return mesh->edges_num;
707 case AttrDomain::Face:
708 return mesh->faces_num;
710 return mesh->corners_num;
711 default:
712 return 0;
713 }
714}
715
717 const Span<MDeformVert> dverts,
718 const int vertex_group_index)
719{
720 BLI_assert(vertex_group_index >= 0);
721 if (dverts.is_empty()) {
722 return {VArray<float>::from_single(0.0f, mesh.verts_num), AttrDomain::Point};
723 }
724 return {varray_for_deform_verts(dverts, vertex_group_index), AttrDomain::Point};
725}
726
727static GAttributeReader try_get_vertex_group(const void *owner, const StringRef name)
728{
729 const Mesh *mesh = static_cast<const Mesh *>(owner);
730 if (mesh == nullptr) {
731 return {};
732 }
733 const int vertex_group_index = BKE_defgroup_name_index(&mesh->vertex_group_names, name);
734 if (vertex_group_index < 0) {
735 return {};
736 }
737 const Span<MDeformVert> dverts = mesh->deform_verts();
738 return reader_for_vertex_group_index(*mesh, dverts, vertex_group_index);
739}
740
742{
743 Mesh *mesh = static_cast<Mesh *>(owner);
744 if (mesh == nullptr) {
745 return {};
746 }
747 const int vertex_group_index = BKE_defgroup_name_index(&mesh->vertex_group_names, name);
748 if (vertex_group_index < 0) {
749 return {};
750 }
751 MutableSpan<MDeformVert> dverts = mesh->deform_verts_for_write();
752 return {varray_for_mutable_deform_verts(dverts, vertex_group_index), AttrDomain::Point};
753}
754
755static bool foreach_vertex_group(const void *owner, FunctionRef<void(const AttributeIter &)> fn)
756{
757 const Mesh *mesh = static_cast<const Mesh *>(owner);
758 if (mesh == nullptr) {
759 return true;
760 }
761 const AttributeAccessor accessor = mesh->attributes();
762 const Span<MDeformVert> dverts = mesh->deform_verts();
763
764 for (const auto [group_index, group] : mesh->vertex_group_names.enumerate()) {
765 const int index = group_index;
766 const auto get_fn = [&]() { return reader_for_vertex_group_index(*mesh, dverts, index); };
767 AttributeIter iter{group.name, AttrDomain::Point, bke::AttrType::Float, get_fn};
768 iter.is_builtin = false;
769 iter.accessor = &accessor;
770 fn(iter);
771 if (iter.is_stopped()) {
772 return false;
773 }
774 }
775 return true;
776}
777
778static const auto &builtin_attributes()
779{
780 static auto attributes = []() {
782
784 position.deletable = false;
785 map.add_new("position", std::move(position));
786
787 static const auto material_index_clamp = mf::build::SI1_SO<int, int>(
788 "Material Index Validate",
789 [](int value) {
790 /* Use #short for the maximum since many areas still use that type for indices. */
791 return std::clamp<int>(value, 0, std::numeric_limits<short>::max());
792 },
793 mf::build::exec_presets::AllSpanOrSingle());
795 material_index.validator = AttributeValidator{&material_index_clamp};
796 map.add_new("material_index", std::move(material_index));
797
798 static const auto int2_index_clamp = mf::build::SI1_SO<int2, int2>(
799 "Index Validate",
800 [](int2 value) { return math::max(value, int2(0)); },
801 mf::build::exec_presets::AllSpanOrSingle());
803 edge_verts.validator = AttributeValidator{&int2_index_clamp};
804 map.add_new(".edge_verts", std::move(edge_verts));
805
806 /* NOTE: This clamping is more of a last resort, since it's quite easy to make an
807 * invalid mesh that will crash Blender by arbitrarily editing this attribute. */
808 static const auto int_index_clamp = mf::build::SI1_SO<int, int>(
809 "Index Validate",
810 [](int value) { return std::max(value, 0); },
811 mf::build::exec_presets::AllSpanOrSingle());
813 corner_vert.validator = AttributeValidator{&int_index_clamp};
814 map.add_new(".corner_vert", std::move(corner_vert));
815
817 corner_edge.validator = AttributeValidator{&int_index_clamp};
818 map.add_new(".corner_edge", std::move(corner_edge));
819
821 map.add_new("sharp_face", std::move(sharp_face));
822
824 map.add_new("sharp_edge", std::move(sharp_edge));
825
826 return map;
827 }();
828 return attributes;
829}
830
832{
834 fn.domain_supported = [](const void * /*owner*/, const AttrDomain domain) {
836 };
837 fn.domain_size = get_domain_size;
838 fn.builtin_domain_and_type = [](const void * /*owner*/,
839 const StringRef name) -> std::optional<AttributeDomainAndType> {
840 const AttrBuiltinInfo *info = builtin_attributes().lookup_ptr(name);
841 if (!info) {
842 return std::nullopt;
843 }
844 return AttributeDomainAndType{info->domain, info->type};
845 };
846 fn.get_builtin_default = [](const void * /*owner*/, StringRef name) -> GPointer {
847 const AttrBuiltinInfo &info = builtin_attributes().lookup(name);
848 return info.default_value;
849 };
850 fn.lookup_meta_data = [](const void *owner, StringRef name) -> std::optional<AttributeMetaData> {
851 const Mesh &mesh = *static_cast<const Mesh *>(owner);
852 if (BKE_defgroup_name_index(&mesh.vertex_group_names, name) != -1) {
854 }
855 const AttributeStorage &storage = mesh.attribute_storage.wrap();
856 const Attribute *attr = storage.lookup(name);
857 if (!attr) {
858 return std::nullopt;
859 }
860 return AttributeMetaData{attr->domain(), attr->data_type()};
861 };
862 fn.lookup = [](const void *owner, const StringRef name) -> GAttributeReader {
863 const Mesh &mesh = *static_cast<const Mesh *>(owner);
864
865 if (GAttributeReader vertex_group = try_get_vertex_group(owner, name)) {
866 return vertex_group;
867 }
868
869 const AttributeStorage &storage = mesh.attribute_storage.wrap();
870 const Attribute *attr = storage.lookup(name);
871 if (!attr) {
872 return {};
873 }
874 const int domain_size = get_domain_size(owner, attr->domain());
875 return attribute_to_reader(*attr, attr->domain(), domain_size);
876 };
877 fn.adapt_domain = [](const void *owner,
878 const GVArray &varray,
879 const AttrDomain from_domain,
880 const AttrDomain to_domain) -> GVArray {
881 const Mesh &mesh = *static_cast<const Mesh *>(owner);
882 return adapt_mesh_attribute_domain(mesh, varray, from_domain, to_domain);
883 };
884 fn.foreach_attribute = [](const void *owner,
885 const FunctionRef<void(const AttributeIter &)> fn,
886 const AttributeAccessor &accessor) {
887 const Mesh &mesh = *static_cast<const Mesh *>(owner);
888
889 const bool should_continue = foreach_vertex_group(owner, fn);
890 if (!should_continue) {
891 return;
892 }
893
894 const AttributeStorage &storage = mesh.attribute_storage.wrap();
895 for (const Attribute &attr : storage) {
896 const auto get_fn = [&]() {
897 const int domain_size = get_domain_size(owner, attr.domain());
898 return attribute_to_reader(attr, attr.domain(), domain_size);
899 };
900 AttributeIter iter(attr.name(), attr.domain(), attr.data_type(), get_fn);
901 iter.is_builtin = builtin_attributes().contains(attr.name());
902 iter.storage_type = attr.storage_type();
903 iter.accessor = &accessor;
904 fn(iter);
905 if (iter.is_stopped()) {
906 break;
907 }
908 }
909 };
910 fn.lookup_validator = [](const void * /*owner*/, const StringRef name) -> AttributeValidator {
911 const AttrBuiltinInfo *info = builtin_attributes().lookup_ptr(name);
912 if (!info) {
913 return {};
914 }
915 return info->validator;
916 };
917 fn.lookup_for_write = [](void *owner, const StringRef name) -> GAttributeWriter {
918 Mesh &mesh = *static_cast<Mesh *>(owner);
919
920 if (GAttributeWriter vertex_group = try_get_vertex_group_for_write(owner, name)) {
921 return vertex_group;
922 }
923
924 AttributeStorage &storage = mesh.attribute_storage.wrap();
925 Attribute *attr = storage.lookup(name);
926 if (!attr) {
927 return {};
928 }
929 const int domain_size = get_domain_size(owner, attr->domain());
930 return attribute_to_writer(&mesh, changed_tags(), domain_size, *attr);
931 };
932 fn.remove = [](void *owner, const StringRef name) -> bool {
933 Mesh &mesh = *static_cast<Mesh *>(owner);
934
936 mesh.vertex_group_names, name, [&]() { return mesh.deform_verts_for_write(); }))
937 {
938 return true;
939 }
940
941 AttributeStorage &storage = mesh.attribute_storage.wrap();
942 if (const AttrBuiltinInfo *info = builtin_attributes().lookup_ptr(name)) {
943 if (!info->deletable) {
944 return false;
945 }
946 }
947 const std::optional<AttrUpdateOnChange> fn = changed_tags().lookup_try(name);
948 const bool removed = storage.remove(name);
949 if (!removed) {
950 return false;
951 }
952 if (fn) {
953 (*fn)(owner);
954 }
955 return true;
956 };
957 fn.add = [](void *owner,
958 const StringRef name,
959 const AttrDomain domain,
960 const AttrType type,
961 const AttributeInit &initializer) {
962 Mesh &mesh = *static_cast<Mesh *>(owner);
963 const int domain_size = get_domain_size(owner, domain);
964 AttributeStorage &storage = mesh.attribute_storage.wrap();
965 if (const AttrBuiltinInfo *info = builtin_attributes().lookup_ptr(name)) {
966 if (info->domain != domain || info->type != type) {
967 return false;
968 }
969 }
970 if (storage.lookup(name)) {
971 return false;
972 }
973 const bool array = array_storage_required().contains(name);
974 Attribute::DataVariant data = attribute_init_to_data(type, domain_size, initializer, array);
975 storage.add(name, domain, type, std::move(data));
976 if (initializer.type != AttributeInit::Type::Construct) {
977 if (const std::optional<AttrUpdateOnChange> fn = changed_tags().lookup_try(name)) {
978 (*fn)(owner);
979 }
980 }
981 return true;
982 };
983 fn.rename = [](void *owner, const Map<StringRef, StringRef> &name_map, bool overwrite) {
984 Mesh &mesh = *static_cast<Mesh *>(owner);
985 return rename_attributes(
986 mesh.attribute_storage.wrap(),
987 name_map,
988 overwrite,
991 [&](const bke::AttrDomain domain) { return get_domain_size(owner, domain); },
992 &mesh.vertex_group_names,
993 [&]() { return mesh.deform_verts_for_write(); });
994 };
995 fn.assign_data = [](void *owner, StringRef name, const AttributeInit &initializer) {
996 Mesh &mesh = *static_cast<Mesh *>(owner);
997 AttributeStorage &storage = mesh.attribute_storage.wrap();
998 Attribute *attr = storage.lookup(name);
999 if (!attr) {
1000 return false;
1001 }
1003 get_domain_size(owner, attr->domain()),
1004 initializer,
1005 array_storage_required().contains(name));
1006 attr->assign_data(std::move(data));
1007 if (initializer.type != AttributeInit::Type::Construct) {
1008 if (const std::optional<AttrUpdateOnChange> fn = changed_tags().lookup_try(name)) {
1009 (*fn)(owner);
1010 }
1011 }
1012 return true;
1013 };
1014
1015 return fn;
1016}
1017
1023
1024} // namespace blender::bke
support for deformation groups and hooks.
#define BUFFER_FOR_CPP_TYPE_VALUE(type, variable_name)
Object is a sort of wrapper for general info.
#define BLI_assert_unreachable()
#define ELEM(...)
void get_internal_single(void *r_value) const
static GVArray from_garray(GArray<> array)
static GVArray from_single(const CPPType &type, int64_t size, const void *value)
void add_new(const Key &key, const Value &value)
Definition BLI_map.hh:265
constexpr int64_t size() const
Definition BLI_span.hh:499
constexpr void fill(const T &value) const
Definition BLI_span.hh:523
constexpr Span slice(int64_t start, int64_t size) const
Definition BLI_span.hh:141
constexpr IndexRange index_range() const
Definition BLI_span.hh:405
constexpr bool is_empty() const
Definition BLI_span.hh:264
static VArray from_single(T value, const int64_t size)
std::optional< AttrStorageType > storage_type
const AttributeAccessor * accessor
std::variant< ArrayData, SingleData > DataVariant
void assign_data(DataVariant &&data)
#define storage(slot, qualifiers)
#define position
#define T
void gather_to_groups(OffsetIndices< int > dst_offsets, const IndexMask &src_selection, GSpan src, GMutableSpan dst)
typename DefaultMixerStruct< T >::type DefaultMixer
void to_static_type(const CPPType &cpp_type, Fn &&fn)
int face_corner_prev(const IndexRange face, const int corner)
Definition BKE_mesh.hh:306
int face_corner_next(const IndexRange face, const int corner)
Definition BKE_mesh.hh:315
static AttributeAccessorFunctions get_mesh_accessor_functions()
static void adapt_mesh_domain_edge_to_point_impl(const Mesh &mesh, const VArray< T > &old_values, MutableSpan< T > r_values)
static GVArray adapt_mesh_domain_face_to_edge(const Mesh &mesh, const GVArray &varray)
static void tag_custom_normals_changed(void *owner)
static bool can_simple_adapt_for_single(const Mesh &mesh, const AttrDomain from_domain, const AttrDomain to_domain)
static GVArray adapt_mesh_domain_corner_to_point(const Mesh &mesh, const GVArray &varray)
static GAttributeReader reader_for_vertex_group_index(const Mesh &mesh, const Span< MDeformVert > dverts, const int vertex_group_index)
const AttributeAccessorFunctions & mesh_attribute_accessor_functions()
static GVArray adapt_mesh_domain_face_to_corner(const Mesh &mesh, const GVArray &varray)
GAttributeReader attribute_to_reader(const Attribute &attribute, const AttrDomain domain, const int64_t domain_size)
static GVArray adapt_mesh_domain_edge_to_point(const Mesh &mesh, const GVArray &varray)
static void adapt_mesh_domain_corner_to_point_impl(const Mesh &mesh, const VArray< T > &src, MutableSpan< T > r_dst)
static const auto & array_storage_required()
Set< StringRef > rename_attributes(AttributeStorage &storage, const Map< StringRef, StringRef > &name_map, const bool overwrite, const Map< StringRef, AttrBuiltinInfo > &builtin_attributes, const Set< StringRef > &array_storage_required, const FunctionRef< int(AttrDomain)> domain_size_fn, std::optional< ListBaseT< bDeformGroup > * > vertex_groups, FunctionRef< MutableSpan< MDeformVert >()> get_mutable_dverts)
static void tag_visibility_changed(void *owner)
static int get_domain_size(const Mesh &mesh, const AttrDomain domain)
static GVArray adapt_mesh_domain_point_to_corner(const Mesh &mesh, const GVArray &varray)
GAttributeWriter attribute_to_writer(void *owner, const Map< StringRef, AttrUpdateOnChange > &changed_tags, const int64_t domain_size, Attribute &attribute)
void adapt_mesh_domain_face_to_edge_impl(const Mesh &mesh, const VArray< T > &old_values, MutableSpan< T > r_values)
static GAttributeReader try_get_vertex_group(const void *owner, const StringRef name)
static GVArray adapt_mesh_domain_corner_to_edge(const Mesh &mesh, const GVArray &varray)
static void tag_positions_changed(void *owner)
bool try_delete_vertex_group(ListBaseT< bDeformGroup > &vertex_groups, const StringRef name, FunctionRef< MutableSpan< MDeformVert >()> get_mutable_dverts)
static const auto & builtin_attributes()
static GAttributeWriter try_get_vertex_group_for_write(void *owner, const StringRef name)
static void tag_material_index_changed(void *owner)
static void tag_sharpness_changed(void *owner)
static void adapt_mesh_domain_corner_to_edge_impl(const Mesh &mesh, const VArray< T > &old_values, MutableSpan< T > r_values)
static GVArray adapt_mesh_domain_point_to_edge(const Mesh &mesh, const GVArray &varray)
static GVArray adapt_mesh_domain_face_to_point(const Mesh &mesh, const GVArray &varray)
void adapt_mesh_domain_edge_to_corner_impl(const Mesh &mesh, const VArray< T > &old_values, MutableSpan< T > r_values)
Attribute::DataVariant attribute_init_to_data(const bke::AttrType data_type, const int64_t domain_size, const AttributeInit &initializer, const bool require_array_data)
static GVArray adapt_mesh_attribute_domain(const Mesh &mesh, const GVArray &varray, const AttrDomain from_domain, const AttrDomain to_domain)
static GVArray adapt_mesh_domain_corner_to_face(const Mesh &mesh, const GVArray &varray)
static GVArray adapt_mesh_domain_edge_to_face(const Mesh &mesh, const GVArray &varray)
static GVArray adapt_mesh_domain_edge_to_corner(const Mesh &mesh, const GVArray &varray)
static const auto & changed_tags()
static GVArray adapt_mesh_domain_point_to_face(const Mesh &mesh, const GVArray &varray)
VMutableArray< float > varray_for_mutable_deform_verts(MutableSpan< MDeformVert > dverts, int defgroup_index)
Definition deform.cc:1752
static bool foreach_vertex_group(const void *owner, FunctionRef< void(const AttributeIter &)> fn)
VArray< float > varray_for_deform_verts(Span< MDeformVert > dverts, int defgroup_index)
Definition deform.cc:1748
void masked_fill(MutableSpan< T > data, const T &value, const IndexMask &mask)
T max(const T &a, const T &b)
void parallel_for(const IndexRange range, const int64_t grain_size, const Function &function, const TaskSizeHints &size_hints=detail::TaskSizeHints_Static(1))
Definition BLI_task.hh:69
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
int BKE_defgroup_name_index(const ListBaseT< bDeformGroup > *defbase, StringRef name)
Definition deform.cc:544
VecBase< int32_t, 2 > int2
BMesh const char void * data