10#include <fmt/format.h>
48 for (
const std::string &message :
messages) {
53 void add(std::string message)
58 std::lock_guard
lock(mutex_);
59 this->messages.
append(std::move(message));
62 template<
typename...
T>
void add(fmt::format_string<T...> fmt,
T &&...args)
67 this->
add(fmt::format(fmt, std::forward<T>(args)...));
71template<
typename...
T>
73 fmt::format_string<T...> fmt,
76 fmt::memory_buffer buffer;
77 fmt::appender dst(buffer);
78 fmt::format_to(dst, fmt, std::forward<T>(args)...);
79 fmt::format_to(dst,
" at indices: ");
80 mask.foreach_index([&](
const int index,
const int pos) {
82 fmt::format_to(dst,
", ");
84 fmt::format_to(dst,
"{}",
index);
98 const int2 edge = edges[edge_i];
99 if (edge[0] == edge[1]) {
100 errors.add(
"Edge {} has equal vertex indices {}", edge_i, edge[0]);
104 errors.add(
"Edge {} has out of range vertex ({}, {})", edge_i, edge[0], edge[1]);
128 mask.foreach_index([&](
const int edge_i) {
129 const int2 edge = edges[edge_i];
130 if (!unique_edges.
add(edge)) {
131 errors.
add(fmt::runtime(
"Edge {} is a duplicate of {}"),
134 duplicate_edges[edge_i].set();
144 if (
mesh.faces_num == 0) {
149 if (face_offsets.
last() !=
mesh.corners_num) {
150 errors.
add(
"Face offsets last value is {}, expected {}. Considering all faces invalid",
155 if (face_offsets.
first() != 0) {
156 errors.
add(
"Faces offsets do not start at 0. Considering all faces invalid");
159 std::atomic<bool> non_monotonic =
false;
164 for (const int16_t i : universe_segment.base_span()) {
165 const int face_i = int(universe_segment.offset() + i);
166 const int face_start = face_offsets[face_i];
167 const int face_end = face_offsets[face_i + 1];
168 if (face_end < face_start) {
169 non_monotonic.store(true, std::memory_order_relaxed);
172 if (face_end - face_start < 3) {
173 errors.add(
"Face {} has invalid size {}", face_i, face_end - face_start);
177 return universe_segment.
offset();
179 if (non_monotonic.load(std::memory_order_relaxed)) {
180 errors.add(
"Face offsets must be monotonically increasing. Considering all faces invalid");
198 [&](
const int face_i) {
200 for (
const int vert : corner_verts.
slice(face)) {
202 errors.
add(
"Face {} has invalid vertex {}", face_i, vert);
223 [&](
const int face_i) {
226 for (
const int vert : corner_verts.
slice(face)) {
227 if (!set.
add(vert)) {
228 errors.
add(
"Face {} has duplicate vertex {}", face_i, vert);
251 [&](
const int face_i) {
253 for (
const int corner : face) {
255 const OrderedEdge actual_edge(corner_verts[corner], corner_verts[corner_next]);
256 if (!unique_edges.
contains(actual_edge)) {
257 errors.
add(
"Face {} has missing edge ({}, {})",
284 [&](
const int face_i) {
286 for (
const int corner : face) {
287 const int edge_index = corner_edges[corner];
288 if (!edges_range.
contains(edge_index)) {
289 errors.
add(
"Corner {} has out of range edge index {}", corner, edge_index);
293 const OrderedEdge actual_edge(corner_verts[corner], corner_verts[corner_next]);
294 if (
OrderedEdge(edges[edge_index]) != actual_edge) {
295 errors.
add(
"Corner {} has incorrect edge index {}", corner, edge_index);
313 [&](
const int face_i) {
321 const int face_verts_num = face_verts.
size();
323 for (
int i = 1; i < face_verts_num; i += 1) {
324 if (face_verts[i] < face_verts[i_min]) {
329 const int i_min_for_modulo = i_min + face_verts_num;
330 const int i_min_prev = (i_min_for_modulo - 1) % face_verts_num;
331 const int i_min_next = (i_min_for_modulo + 1) % face_verts_num;
332 const int sign = face_verts[i_min_next] < face_verts[i_min_prev] ? 1 : -1;
333 for (
int i = 0; i < face_verts_num; i += 1) {
334 ordered_face_verts[i] = face_verts[(i_min_for_modulo + (i *
sign)) % face_verts_num];
342 [&](
const int face_i,
const int pos) {
343 first_verts[pos] = ordered_corner_verts[faces[face_i].first()];
349 first_verts, first_verts.
index_range(), group_indices);
354 group_indices, groups_num, offset_data, index_data,
mask)
359 for (const int group_index : range) {
360 MutableSpan<int> group = index_data.as_mutable_span().slice(
361 faces_by_first_vert[group_index]);
362 if (group.size() < 2) {
367 const auto face_verts = [&](const int face_i) {
368 return ordered_corner_verts.as_span().slice(faces[face_i]);
370 std::ranges::sort(group, [&](const int a, const int b) {
371 const Span<int> verts_a = face_verts(a);
372 const Span<int> verts_b = face_verts(b);
373 if (verts_a == verts_b) {
376 return std::ranges::lexicographical_compare(verts_a, verts_b);
378 int original = group[0];
379 for (const int face_i : group.drop_front(1)) {
380 if (face_verts(face_i) != face_verts(original)) {
384 if (!r_originals.is_empty()) {
385 r_originals[face_i] = original;
387 duplicate_faces[face_i] = true;
406 faces,
mesh.corner_verts(),
mask, memory, originals);
409 [&](
const int face) { errors.
add(
"Face {} is a duplicate of {}", face, originals[face]); });
410 return duplicate_faces;
415 const int valid_faces_num = valid_faces.
size();
420 old_faces, valid_faces, new_face_offsets);
424 switch (attr.domain()) {
426 switch (attr.storage_type()) {
428 const auto &src_data = std::get<Attribute::ArrayData>(attr.data());
433 attr.assign_data(std::move(dst_data));
442 switch (attr.storage_type()) {
444 const auto &src_data = std::get<Attribute::ArrayData>(attr.data());
450 GSpan(type, src_data.data,
mesh.corners_num),
452 attr.assign_data(std::move(dst_data));
467 const Span src(
static_cast<const int *
>(
layer.data),
mesh.faces_num);
474 layer.sharing_info->remove_user_and_delete_if_last();
475 layer.data = dst_data;
490 const void *src =
layer.data;
499 new_faces[dst_i].size());
503 layer.sharing_info->remove_user_and_delete_if_last();
512 mesh.face_offset_indices = new_face_offsets.
release().data;
513 mesh.runtime->face_offsets_sharing_info->remove_user_and_delete_if_last();
515 mesh.face_offset_indices);
517 mesh.tag_topology_changed();
522 const int valid_edges_num = valid_edges.
size();
529 switch (attr.storage_type()) {
531 const auto &src_data = std::get<Attribute::ArrayData>(attr.data());
536 attr.assign_data(std::move(dst_data));
546 const Span src(
static_cast<const int *
>(
layer.data),
mesh.edges_num);
553 layer.sharing_info->remove_user_and_delete_if_last();
554 layer.data = dst_data;
559 mesh.edges_num = valid_edges.
size();
561 mesh.tag_topology_changed();
570 const int vertex_groups_num =
mesh.vertex_group_names.count();
575 for (const int vert : range) {
576 const MDeformVert &dvert = dverts[vert];
578 Vector<std::string> errors;
579 bool invalid = false;
580 Vector<MDeformWeight, 64> fixed_weights;
581 for (const MDeformWeight &dw : Span(dvert.dw, dvert.totweight)) {
582 const uint def_nr = dw.def_nr;
583 if (dw.def_nr >= vertex_groups_num) {
586 std::lock_guard lock(mutex);
587 errors.append(fmt::format(
"Vertex {} has invalid deform group {}", vert, def_nr));
591 if (!std::isfinite(dw.weight)) {
594 std::lock_guard lock(mutex);
595 errors.append(fmt::format(
596 "Vertex {} deform group {} has invalid weight {}", vert, def_nr, dw.weight));
599 fixed_weights.append({def_nr, 0.0f});
603 if (dw.weight < 0.0f || dw.weight > 1.0f) {
606 std::lock_guard lock(mutex);
607 errors.append(fmt::format(
608 "Vertex {} deform group {} has invalid weight {}", vert, def_nr, dw.weight));
611 fixed_weights.append({def_nr, std::clamp(dw.weight, 0.0f, 1.0f)});
616 fixed_weights.append(dw);
621 std::lock_guard lock(mutex);
622 all_errors.append({vert, std::move(errors)});
623 replacements.append({vert, std::move(fixed_weights)});
627 if (replacements.is_empty()) {
631 for (
const auto &[vert, errors] : all_errors) {
632 for (
const std::string &error : errors) {
638 MutableSpan<MDeformVert> dverts = mesh_mut->deform_verts_for_write();
639 for (
auto &[vert, weights] : replacements) {
640 MEM_delete(dverts[vert].dw);
641 dverts[
vert].totweight = weights.size();
642 dverts[
vert].dw = weights.release().data;
649 const bool only_check_negative,
653 const IndexRange materials_range(only_check_negative ? std::numeric_limits<int>::max() :
654 std::max(
int(
mesh.totcol), 1));
657 if (!material_indices) {
663 mesh_mut->attributes_for_write().remove(
"material_index");
672 material_indices.
index_range(), memory, [&](
const int face) {
673 return !materials_range.contains(material_indices_span[face]);
680 CLOG_ERROR(&
LOG,
"Face %d has invalid material index %d", face, material_indices_span[face]);
688 material_indices.
finish();
703 if (mselect[i].index < 0) {
706 const int domain_size = [&]() {
707 switch (mselect[i].type) {
709 return mesh.verts_num;
711 return mesh.edges_num;
713 return mesh.faces_num;
717 if (mselect[i].
index >= domain_size) {
722 if (invalid.is_empty()) {
727 invalid.foreach_index([&](
const int i) {
729 "Selection element (%d, %d) has invalid index, must not be negative",
735 MEM_SAFE_DELETE(mesh_mut->mselect);
742 const int floats_per_item,
745 if (floats_per_item == 0) {
748 const int num_items = values.
size() / floats_per_item;
752 return std::any_of(item_floats.
begin(), item_floats.
end(), [](
const float value) {
753 return !std::isfinite(value);
759 const int floats_per_item,
761 bool &all_attributes_valid,
775 all_attributes_valid =
false;
787 bool &all_attributes_valid,
794 int_span.index_range(), memory, [&](
const int i) { return !ELEM(int_span[i], 0, 1); });
801 all_attributes_valid =
false;
812 bool all_attributes_valid =
true;
853 return all_attributes_valid;
867 const Span<float> disps = Span(reinterpret_cast<const float3 *>(mdisps[i].disps),
871 disps.begin(), disps.end(), [&](const float &v) { return !std::isfinite(v); });
874 if (invalid.is_empty()) {
879 print_error_with_indices(invalid,
"Multires displacement has invalid values");
883 if (MDisps *mdisp_mut =
static_cast<MDisps *
>(
886 invalid.foreach_index(
888 MutableSpan<float> disps = MutableSpan(
reinterpret_cast<float3 *
>(mdisp_mut[i].disps),
889 mdisp_mut[i].totdisp)
891 for (
float &disp_component : disps) {
892 disp_component = std::isfinite(disp_component) ? disp_component : 0.0f;
895 exec_mode::grain_size(512));
903 const bool allow_missing_edges,
915 mesh, valid_edges, memory, verbose, unique_edges);
927 mesh, valid_faces, memory, verbose);
934 mesh, valid_faces, unique_edges, memory, verbose && !allow_missing_edges);
935 const IndexMask valid_and_missing_edge_faces = valid_faces;
940 const int64_t valid_faces_count = allow_missing_edges ? valid_and_missing_edge_faces.
size() :
942 bool valid = valid_edges.
size() ==
mesh.edges_num && valid_faces_count ==
mesh.faces_num &&
943 !any_corner_edges_bad;
947 if (valid_and_missing_edge_faces.
size() <
mesh.faces_num) {
951 const bool any_edges_removed = valid_edges.
size() <
mesh.edges_num;
952 if (any_edges_removed) {
957 if (any_corner_edges_bad || any_edges_removed || !faces_missing_edges.
is_empty()) {
CustomData interface, see also DNA_customdata_types.h.
#define CLOG_ERROR(clg_ref,...)
#define CLOG_INFO(clg_ref,...)
#define POINTER_OFFSET(v, ofs)
MutableSpan< T > as_mutable_span()
IndexRange index_range() const
void fill_assign_indices(const void *value, void *dst, const IndexMask &mask) const
const void * default_value() const
const CPPType & type() const
int64_t size_in_bytes() const
const void * data() 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_difference(const IndexMask &mask_a, const IndexMask &mask_b, LinearAllocator<> &memory)
static IndexMask from_bits(BitSpan bits, LinearAllocator<> &memory)
static IndexMask from_batch_predicate(const IndexMask &universe, LinearAllocator<> &memory, FunctionRef< int64_t(const IndexMaskSegment &universe_segment, IndexRangesBuilder< int16_t > &builder)> batch_predicate, exec_mode::Mode mode=exec_mode::parallel)
constexpr IndexRange()=default
constexpr bool contains(int64_t value) const
constexpr Span slice(int64_t start, int64_t size) const
constexpr const T & first() const
constexpr int64_t size() const
constexpr const T & last(const int64_t n=0) const
constexpr const T * end() const
constexpr IndexRange index_range() const
constexpr const T * begin() const
constexpr bool is_empty() const
std::optional< T > get_if_single() const
IndexRange index_range() const
int64_t index_of(const Key &key) const
bool contains(const Key &key) const
void append(const T &value)
VectorData< T, Allocator > release()
GAttributeReader lookup(const StringRef name) const
GAttributeReader get() const
void add(fmt::format_string< T... > fmt, T &&...args)
ErrorMessages(const bool verbose)
void add(std::string message)
Vector< std::string > messages
GSpanAttributeWriter lookup_for_write_span(StringRef name)
Span< NewT > constexpr cast() const
void foreach_index(Fn &&fn, Mode mode=exec_mode::serial) const
IndexRange index_range() const
ccl_device_inline float2 mask(const MaskType mask, const float2 a)
void gather(const GVArray &src, const IndexMask &indices, GMutableSpan dst, exec_mode::Mode mode=exec_mode::parallel)
int group_ids_to_indices(Span< int > ids, const IndexMask &mask, MutableSpan< int > r_group_indices, Vector< int > *r_first_indices=nullptr)
void gather_group_to_group(OffsetIndices< int > src_offsets, OffsetIndices< int > dst_offsets, const IndexMask &selection, GSpan src, GMutableSpan dst)
int face_corner_next(const IndexRange face, const int corner)
static bool validate_vertex_groups(const Mesh &mesh, const bool verbose, Mesh *mesh_mut)
bool mesh_validate_material_indices(Mesh &mesh)
IndexMask mesh_find_faces_duplicate_verts(const Mesh &mesh, IndexMaskMemory &memory)
static bool validate_selection_history(const Mesh &mesh, const bool verbose, Mesh *mesh_mut)
static bool mesh_validate_impl(const Mesh &mesh, const bool verbose, const bool allow_missing_edges, Mesh *mesh_mut)
bool mesh_is_valid(const Mesh &mesh, bool verbose=true)
static IndexMask get_invalid_float_mask(const Span< float > values, const int floats_per_item, IndexMaskMemory &memory)
static IndexMask find_faces_bad_offsets(const Mesh &mesh, IndexMaskMemory &memory, const bool verbose)
static bool validate_generic_attributes(const Mesh &mesh, const bool verbose, Mesh *mesh_mut)
static IndexMask find_faces_missing_edges(const Mesh &mesh, const IndexMask &mask, const EdgeMap &unique_edges, IndexMaskMemory &memory, const bool verbose)
IndexMask find_duplicate_faces(OffsetIndices< int > faces, Span< int > corner_verts, const IndexMask &mask, IndexMaskMemory &memory, MutableSpan< int > r_originals={})
static bool validate_mdisps(const Mesh &mesh, const bool verbose, Mesh *mesh_mut)
static IndexMask find_faces_bad_verts(const Mesh &mesh, const IndexMask &mask, IndexMaskMemory &memory, const bool verbose)
static void remove_invalid_edges(Mesh &mesh, const IndexMask &valid_edges)
void mesh_calc_edges(Mesh &mesh, bool keep_existing_edges, bool select_new_edges)
static bool find_faces_bad_edges(const Mesh &mesh, const IndexMask &mask, IndexMaskMemory &memory, const bool verbose)
bool mesh_validate(Mesh &mesh, bool verbose=false, bool allow_missing_edges=false)
static IndexMask find_edges_duplicates(const Mesh &mesh, const IndexMask &mask, IndexMaskMemory &memory, const bool verbose, EdgeMap &unique_edges)
static void remove_invalid_faces(Mesh &mesh, const IndexMask &valid_faces)
static void print_error_with_indices(const IndexMask &mask, fmt::format_string< T... > fmt, T &&...args)
static IndexMask find_edges_bad_verts(const Mesh &mesh, IndexMaskMemory &memory, const bool verbose)
static void validate_float_attribute(const bke::AttributeIter &iter, const int floats_per_item, const bool verbose, bool &all_attributes_valid, Mesh *mesh_mut)
VectorSet< OrderedEdge, 32, DefaultProbingStrategy, DefaultHash< OrderedEdge >, DefaultEquality< OrderedEdge >, SimpleVectorSetSlot< OrderedEdge, int >, GuardedAllocator > EdgeMap
static bool validate_material_indices(const Mesh &mesh, const bool only_check_negative, const bool verbose, Mesh *mesh_mut)
static IndexMask find_faces_duplicate_verts(const Mesh &mesh, const IndexMask &mask, IndexMaskMemory &memory, const bool verbose)
static void validate_bool_attribute(const bke::AttributeIter &iter, const bool verbose, bool &all_attributes_valid, Mesh *mesh_mut)
const CPPType & attribute_type_to_cpp_type(AttrType type)
constexpr ParallelGrainSize grain_size(int grain_size)
const ImplicitSharingInfo * info_for_mem_free(T *data)
void masked_fill(MutableSpan< T > data, const T &value, const IndexMask &mask)
GroupedSpan< int > build_groups_from_indices(Span< int > indices, int groups_num, Array< int > &offset_data, Array< int > &index_data)
OffsetIndices< int > gather_selected_offsets(OffsetIndices< int > src_offsets, const IndexMask &selection, int start_offset, MutableSpan< int > dst_offsets)
void parallel_for(const IndexRange range, const int64_t grain_size, const Function &function, const TaskSizeHints &size_hints=detail::TaskSizeHints_Static(1))
void CustomData_copy_elements(eCustomDataType type, const void *src_data, void *dst_data, int count)
void * MEM_new_array_uninitialized(size_t len, size_t size, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1
const ImplicitSharingInfo * CustomData_make_layer_sharing_info(eCustomDataType type, const void *data, int totelem)
int CustomData_sizeof(eCustomDataType type)
VecBase< int32_t, 2 > int2
void DEG_id_tag_update(ID *id, unsigned int flags)
const void * CustomData_get_layer(const CustomData *data, eCustomDataType type)
PythonProbingStrategy<> DefaultProbingStrategy
@ ID_RECALC_GEOMETRY_ALL_MODES
void * CustomData_get_layer_for_write(CustomData *data, eCustomDataType type, int totelem)
void vert(const int vert_id, float4 &position)
static ArrayData from_uninitialized(const CPPType &type, int64_t domain_size)
MutableVArraySpan< T > span