46# include "manifold/manifold.h"
48using manifold::Manifold;
49using manifold::MeshGL;
58template<
typename T>
static void dump_span(Span<T> span,
const std::string &name)
60 std::cout << name <<
":";
63 std::cout <<
"\n[" << i <<
"] ";
65 std::cout << span[i] <<
" ";
71static void dump_span_with_stride(Span<T> span,
int stride,
const std::string &name)
73 std::cout << name <<
":";
76 std::cout <<
"\n[" << i <<
"] ";
78 std::cout << span[i] <<
" ";
79 if (stride > 1 && (i % stride) == stride - 1) {
87static void dump_vector(
const std::vector<T> &vec,
int stride,
const std::string &name)
89 std::cout << name <<
":";
90 for (
int i = 0; i < vec.size(); i++) {
92 std::cout <<
"\n[" << i <<
"] ";
94 std::cout << vec[i] <<
" ";
95 if (stride > 1 && (i % stride) == stride - 1) {
103static void dump_vector_values(
const std::string indent,
104 const std::string &assign_to,
105 const std::vector<T> &vec)
107 std::cout << indent << assign_to <<
" = { ";
108 for (
int i = 0; i < vec.size(); i++) {
109 if (i > 0 && (i % 10) == 0) {
110 std::cout <<
"\n" << indent << indent;
113 if (i == vec.size() - 1) {
114 std::cout <<
" };\n";
122static void dump_meshgl(
const MeshGL &mgl,
const std::string &name)
124 std::cout <<
"\nMeshGL " << name <<
":\n"
125 <<
"num verts = " << mgl.NumVert() <<
"\nnum triangles = " << mgl.NumTri() <<
"\n"
127 dump_vector(mgl.vertProperties, mgl.numProp,
"vertProperties");
128 dump_vector(mgl.triVerts, 3,
"triVerts");
129 dump_vector(mgl.faceID, 1,
"faceID");
130 if (!mgl.mergeFromVert.empty()) {
131 dump_vector(mgl.mergeFromVert, 1,
"mergeFromVert");
132 dump_vector(mgl.mergeToVert, 1,
"mergeToVert");
134 dump_vector(mgl.runIndex, 1,
"runIndex");
135 dump_vector(mgl.runOriginalID, 1,
"runOrigiinalID");
138[[maybe_unused]]
static void dump_meshgl_for_debug(
const MeshGL &mgl)
140 std::string indent =
" ";
141 std::cout << indent <<
"MeshGL m;\n";
142 std::cout << std::setprecision(9);
143 std::cout << indent <<
"m.numProp = " << mgl.numProp <<
";\n";
144 dump_vector_values(indent,
"m.vertProperties", mgl.vertProperties);
145 dump_vector_values(indent,
"m.triVerts", mgl.triVerts);
146 if (!mgl.mergeFromVert.empty()) {
147 dump_vector_values(indent,
"m.mergeFromVert", mgl.mergeFromVert);
148 dump_vector_values(indent,
"m.mergeToVert", mgl.mergeToVert);
150 dump_vector_values(indent,
"m.runIndex", mgl.runIndex);
151 dump_vector_values(indent,
"m.runOriginalID", mgl.runOriginalID);
152 dump_vector_values(indent,
"m.faceID", mgl.faceID);
153 if (!mgl.runTransform.empty()) {
154 dump_vector_values(indent,
"m.runTransform", mgl.runTransform);
156 if (!mgl.halfedgeTangent.empty()) {
157 dump_vector_values(indent,
"m.halfedgeTangent", mgl.halfedgeTangent);
159 if (mgl.tolerance != 0) {
160 std::cout << indent <<
"m.tolerance = " << mgl.tolerance <<
";\n";
164[[maybe_unused]]
static void dump_meshgl_as_obj(
const MeshGL &mgl)
166 std::cout <<
"\n# Meshgl as OBJ\n";
167 std::cout << std::setprecision(9);
170 std::cout <<
"v " << mgl.vertProperties[k] <<
" " << mgl.vertProperties[k + 1] <<
" "
171 << mgl.vertProperties[k + 2] <<
"\n";
174 for (
const int t :
IndexRange(mgl.NumTri())) {
176 std::cout <<
"f " << mgl.triVerts[k] <<
" " << mgl.triVerts[k + 1] <<
" "
177 << mgl.triVerts[k + 2] <<
"\n";
182static const char *domain_names[] = {
183 "point",
"edge",
"face",
"corner",
"curve",
"instance",
"layer"};
185static void dump_mesh(
const Mesh *mesh,
const std::string &name)
187 std::cout <<
"\nMesh " << name <<
":\n"
188 <<
"verts_num = " << mesh->verts_num <<
"\nfaces_num = " << mesh->faces_num
189 <<
"\nedges_num = " << mesh->edges_num <<
"\ncorners_num = " << mesh->corners_num
191 dump_span(mesh->vert_positions(),
"verts");
192 dump_span(mesh->edges(),
"edges");
193 dump_span(mesh->corner_verts(),
"corner_verts");
194 dump_span(mesh->corner_edges(),
"corner_edges");
195 dump_span(mesh->face_offsets(),
"face_offsets");
196 std::cout <<
"triangulation:\n";
197 dump_span(mesh->corner_tris(),
"corner_tris");
198 dump_span(mesh->corner_tri_faces(),
"corner_tri_faces");
199 std::cout <<
"attributes:\n";
200 bke::AttributeAccessor attrs = mesh->
attributes();
201 attrs.foreach_attribute([&](
const bke::AttributeIter &iter) {
202 if (
ELEM(iter.name,
"position",
".edge_verts",
".corner_vert",
".corner_edge")) {
205 const int di =
int8_t(iter.domain);
206 const char *domain = (di >= 0 && di <
ATTR_DOMAIN_NUM) ? domain_names[di] :
"?";
207 std::string label = std::string(domain) +
": " + iter.name;
208 switch (iter.data_type) {
210 VArraySpan<float> floatspan(*attrs.lookup<
float>(iter.name));
211 dump_span(floatspan, label);
215 const VArraySpan<int> intspan(*attrs.lookup<
int>(iter.name));
216 dump_span(intspan, label);
219 const VArraySpan<float3> float3span(*attrs.lookup<
float3>(iter.name));
220 dump_span(float3span, label);
223 const VArraySpan<float2> float2span(*attrs.lookup<
float2>(iter.name));
224 dump_span(float2span, label);
227 std::cout << label <<
" attribute not dumped\n";
231 std::cout <<
"materials:\n";
232 for (
int i = 0; i < mesh->totcol; i++) {
233 std::cout <<
"[" << i <<
"]: " << (mesh->mat[i] ? mesh->mat[i]->id.
name + 2 :
"none") <<
"\n";
253static void get_manifold(
Manifold &manifold,
254 const Span<const Mesh *> meshes,
258 constexpr int dbg_level = 0;
260 std::cout <<
"get_manifold for mesh " << mesh_index <<
"\n";
265 const Mesh &mesh = *meshes[mesh_index];
266 const OffsetIndices<int> faces = mesh.faces();
267 const Span<int> corner_verts = mesh.corner_verts();
268 const Span<int3> corner_tris = mesh.corner_tris();
272 constexpr int props_num = 3;
273 meshgl.numProp = props_num;
274 meshgl.vertProperties.resize(
size_t(mesh.verts_num) * props_num);
280 constexpr bool use_runids =
false;
282 meshgl.runIndex.resize(mesh.faces_num);
283 meshgl.runOriginalID.resize(mesh.faces_num);
286 const int face_start = mesh_offsets.face_start[mesh_index];
288 meshgl.faceID.resize(corner_tris.
size());
292 for (const int i : range) {
293 const IndexRange face = faces[i];
294 const int start = poly_to_tri_count(int(i), int(face.start()));
295 const int num = bke::mesh::face_triangles_num(int(face.size()));
296 face_ids.slice(start, num).fill(uint32_t(i + face_start));
298 meshgl.runOriginalID[i] = face_start + i;
299 meshgl.runIndex[i] = start * 3;
304 meshgl.triVerts.resize(corner_tris.
size() * 3);
309 meshgl.runIndex.resize(2);
310 meshgl.runOriginalID.resize(1);
311 meshgl.runIndex[0] = 0;
312 meshgl.runIndex[1] = corner_tris.
size() * 3;
313 meshgl.runOriginalID[0] = mesh_index;
316 dump_meshgl(meshgl,
"converted result for mesh " + std::to_string(mesh_index));
318 dump_meshgl_for_debug(meshgl);
323 timeit::ScopedTimer mtimer(
"manifold constructor from meshgl");
333static void get_manifolds(MutableSpan<Manifold> manifolds,
336 const MeshOffsets &mesh_offsets)
338 constexpr int dbg_level = 0;
340 std::cout <<
"GET_MANIFOLDS\n";
341 std::cout <<
"\nMesh Offset (starts):\n";
342 dump_span(mesh_offsets.vert_start.as_span(),
"vert");
343 dump_span(mesh_offsets.face_start.as_span(),
"face");
344 dump_span(mesh_offsets.edge_start.as_span(),
"edge");
345 dump_span(mesh_offsets.corner_start.as_span(),
"corner");
347 const int meshes_num = manifolds.size();
352 Array<const Mesh *> transformed_meshes(meshes_num);
354 if (math::is_identity(transforms[i])) {
355 transformed_meshes[i] = meshes[i];
359 bke::mesh_transform(*transformed_mesh, transforms[i],
false);
360 transformed_meshes[i] = transformed_mesh;
365 for (
const int mesh_index : IndexRange(meshes_num)) {
366 get_manifold(manifolds[mesh_index], transformed_meshes, mesh_index, mesh_offsets);
370 threading::parallel_for_each(IndexRange(meshes_num), [&](
int mesh_index) {
371 get_manifold(manifolds[mesh_index], transformed_meshes, mesh_index, mesh_offsets);
375 for (
const int i : transformed_meshes.index_range()) {
376 if (transformed_meshes[i] != meshes[i]) {
387static void clean_meshgl(MeshGL &mgl)
392 const int numtri = mgl.NumTri();
393 const int numvert = mgl.NumVert();
394 auto bad_tri = [&mgl, numvert](
const int t) {
396 const uint32_t i0 = mgl.triVerts[k];
397 const uint32_t i1 = mgl.triVerts[k + 1];
398 const uint32_t i2 = mgl.triVerts[k + 2];
399 if (i0 >= numvert || i1 >= numvert || i2 >= numvert || i0 == i1 || i0 == i2 || i1 == i2) {
404 const bool any_bad_faces = threading::parallel_reduce(
408 [&](
const IndexRange range,
const bool init) {
412 for (
const int t : range) {
419 [](
const bool a,
const bool b) {
return a ||
b; });
420 if (!any_bad_faces) {
429 while (from_t < numtri) {
430 if (bad_tri(from_t)) {
435 mgl.triVerts[to_3t++] = mgl.triVerts[from_3t++];
436 mgl.triVerts[to_3t++] = mgl.triVerts[from_3t++];
437 mgl.triVerts[to_3t++] = mgl.triVerts[from_3t++];
438 mgl.faceID[to_t++] = mgl.faceID[from_t++];
441 const int num_deleted = from_t - to_t;
442 mgl.triVerts.resize(mgl.triVerts.size() - 3 * num_deleted);
443 mgl.faceID.resize(mgl.faceID.size() - num_deleted);
448constexpr int inline_outface_size = 8;
452 Vector<int, inline_outface_size> verts;
458 int find_vert_index(
int v)
const
460 return verts.first_index_of_try(v);
467 MutableSpan<float> vertpos;
468 int vertpos_stride = 3;
472 int output_verts_num;
474 Vector<OutFace> new_faces;
480 Vector<int> old_to_new_vert_map;
482 float3 vert_position(
const int v)
const
484 const int start = vertpos_stride *
v;
485 return float3(vertpos[start], vertpos[start + 1], vertpos[start + 2]);
488 int mapped_vert(
const int v)
const
490 if (!new_faces.is_empty()) {
491 return old_to_new_vert_map[
v];
504 Array<int> vertex_map_;
505 Array<int> face_map_;
506 Array<int> edge_map_;
507 Array<int> corner_map_;
509 const MeshAssembly *mesh_assembly_;
510 const Mesh *joined_mesh_;
511 const Mesh *output_mesh_;
512 const MeshOffsets *mesh_offsets_;
515 OutToInMaps(
const MeshAssembly *mesh_assembly,
516 const Mesh *joined_mesh,
517 const Mesh *output_mesh,
518 const MeshOffsets *mesh_offsets)
519 : mesh_assembly_(mesh_assembly),
520 joined_mesh_(joined_mesh),
521 output_mesh_(output_mesh),
522 mesh_offsets_(mesh_offsets)
526 Span<int> ensure_vertex_map();
527 Span<int> ensure_face_map();
528 Span<int> ensure_edge_map();
529 Span<int> ensure_corner_map();
534 if (!face_map_.is_empty()) {
539 timeit::ScopedTimer timer(
"filling face map");
541 face_map_.reinitialize(output_mesh_->faces_num);
542 BLI_assert(mesh_assembly_->new_faces.size() == face_map_.size());
544 threading::parallel_for(
545 mesh_assembly_->new_faces.index_range(), grain_size, [&](
const IndexRange range) {
546 for (const int i : range) {
547 face_map_[i] = mesh_assembly_->new_faces[i].face_id;
553Span<int> OutToInMaps::ensure_vertex_map()
555 if (!vertex_map_.is_empty()) {
562 const Span<int> face_map = this->ensure_face_map();
564 timeit::ScopedTimer timer(
"filling vertex map");
566 vertex_map_ = Array<int>(output_mesh_->verts_num, -1);
571 const OffsetIndices<int> in_faces = joined_mesh_->faces();
572 const OffsetIndices<int> out_faces = output_mesh_->faces();
573 const Span<int> in_corner_verts = joined_mesh_->corner_verts();
574 const Span<int> out_corner_verts = output_mesh_->corner_verts();
575 const Span<float3> out_vert_positions = output_mesh_->vert_positions();
576 const Span<float3> in_vert_positions = joined_mesh_->vert_positions();
577 for (
const int out_face_index : IndexRange(output_mesh_->faces_num)) {
578 const int in_face_index = face_map[out_face_index];
579 const IndexRange in_face = in_faces[in_face_index];
580 const IndexRange out_face = out_faces[out_face_index];
582 for (
const int out_v : out_corner_verts.
slice(out_face)) {
583 if (vertex_map_[out_v] != -1) {
586 float3 out_pos = out_vert_positions[out_v];
587 const auto *it = std::find_if(in_face_verts.
begin(), in_face_verts.
end(), [&](
int in_v) {
588 return out_pos == in_vert_positions[in_v];
590 if (it != in_face_verts.
end()) {
591 int in_v = in_face_verts[std::distance(in_face_verts.
begin(), it)];
592 vertex_map_[out_v] = in_v;
599Span<int> OutToInMaps::ensure_corner_map()
601 if (!corner_map_.is_empty()) {
609 const Span<int> face_map = this->ensure_face_map();
610 const Span<int> vert_map = this->ensure_vertex_map();
612 timeit::ScopedTimer timer(
"filling corner map");
614 corner_map_ = Array<int>(output_mesh_->corners_num, -1);
615 const OffsetIndices<int> in_faces = joined_mesh_->faces();
616 const OffsetIndices<int> out_faces = output_mesh_->faces();
617 const Span<int> in_corner_verts = joined_mesh_->corner_verts();
618 const Span<int> out_corner_verts = output_mesh_->corner_verts();
620 threading::parallel_for(
621 IndexRange(output_mesh_->faces_num), grain_size, [&](
const IndexRange range) {
622 for (const int out_face_index : range) {
623 const int in_face_index = face_map[out_face_index];
624 const IndexRange in_face = in_faces[in_face_index];
625 for (const int out_c : out_faces[out_face_index]) {
626 BLI_assert(corner_map_[out_c] == -1);
627 const int out_v = out_corner_verts[out_c];
628 const int in_v = vert_map[out_v];
632 const int in_face_i = in_corner_verts.slice(in_face).first_index_try(in_v);
633 if (in_face_i != -1) {
634 const int in_c = in_face[in_face_i];
635 corner_map_[out_c] = in_c;
647 float pq = math::length(p) * math::length(q);
651 float abs_cos_pq = math::abs(math::dot(p, q) / pq);
652 return (math::abs(abs_cos_pq - 1.0f) <= 1e-5f);
657 constexpr int dbg_level = 0;
658 if (!edge_map_.is_empty()) {
662 std::cout <<
"\nensure_edge_map\n";
664 dump_mesh(joined_mesh_,
"joined_mesh");
665 dump_mesh(output_mesh_,
"output_mesh");
679 const Span<int> face_map = this->ensure_face_map();
680 const Span<int> vert_map = this->ensure_vertex_map();
681 const Span<int> corner_map = this->ensure_corner_map();
687 timeit::ScopedTimer timer(
"filling edge map");
689 edge_map_ = Array<int>(output_mesh_->edges_num, -1);
690 const Span<int> out_corner_edges = output_mesh_->corner_edges();
691 const Span<int> out_corner_verts = output_mesh_->corner_verts();
692 const Span<int2> out_edges = output_mesh_->edges();
693 const Span<float3> out_positions = output_mesh_->vert_positions();
694 const Span<int> in_corner_edges = joined_mesh_->corner_edges();
695 const Span<int> in_corner_verts = joined_mesh_->corner_verts();
696 const Span<int2> in_edges = joined_mesh_->edges();
697 const Span<float3> in_positions = joined_mesh_->vert_positions();
698 const OffsetIndices<int> in_faces = joined_mesh_->faces();
699 const OffsetIndices<int> out_faces = output_mesh_->faces();
700 Array<bool> done_edge(output_mesh_->edges_num,
false);
701 for (
const int out_face_index : IndexRange(output_mesh_->faces_num)) {
702 const int in_face_index = face_map[out_face_index];
703 const IndexRange in_face = in_faces[in_face_index];
706 std::cout <<
"process out_face = " << out_face_index <<
", in_face = " << in_face_index
709 for (
const int out_c : out_faces[out_face_index]) {
710 const int in_c = corner_map[out_c];
712 std::cout <<
" out_c = " << out_c <<
", in_c = " << in_c <<
"\n";
718 const int out_e = out_corner_edges[out_c];
720 std::cout <<
" out_e = " << out_e <<
", done = " << done_edge[out_e] <<
"\n";
722 if (done_edge[out_e]) {
725 const int out_v = out_corner_verts[out_c];
726 const int in_e = in_corner_edges[in_c];
727 const int in_v = in_corner_verts[in_c];
730 int2 out_e_v = out_edges[out_e];
731 if (out_e_v[0] != out_v) {
732 out_e_v = {out_e_v[1], out_e_v[0]};
734 int2 in_e_v = in_edges[in_e];
735 if (in_e_v[0] != in_v) {
736 in_e_v = {in_e_v[1], in_e_v[0]};
739 std::cout <<
" out_v = " << out_v <<
", in_e = " << in_e <<
", in_v = " << in_v <<
"\n";
740 std::cout <<
" out_e_v = " << out_e_v <<
", in_e_v = " << in_e_v <<
"\n";
741 std::cout <<
" vertex_map(out_e_v) = " <<
int2(vert_map[out_e_v[0]], vert_map[out_e_v[1]])
748 BLI_assert(vert_map[out_e_v[0]] == in_e_v[0]);
750 if (vert_map[out_e_v[1]] == in_e_v[1]) {
753 std::cout <<
" case 1, edge_rep = in_e = " << in_e <<
"\n";
757 else if (!in_face_vert_range.contains(vert_map[out_e_v[1]])) {
761 if (same_dir(out_positions[out_e_v[0]],
762 out_positions[out_e_v[1]],
763 in_positions[in_e_v[0]],
764 in_positions[in_e_v[1]]))
767 std::cout <<
" case 2, edge_rep = in_e = " << in_e <<
"\n";
777 if (edge_rep == -1) {
778 const int in_c_prev = bke::mesh::face_corner_prev(in_face, in_c);
779 const int in_e_prev = in_corner_edges[in_c_prev];
780 const int in_v_prev = in_corner_verts[in_c_prev];
781 int2 in_e_v_prev = in_edges[in_e_prev];
782 if (in_e_v_prev[0] != in_v_prev) {
783 in_e_v_prev = {in_e_v_prev[1], in_e_v_prev[0]};
786 std::cout <<
" in_c_prev = " << in_c_prev <<
", in_e_prev = " << in_e_prev
787 <<
", in_v_prev = " << in_v_prev <<
"\n";
788 std::cout <<
" in_e_v_prev = " << in_e_v_prev <<
"\n";
790 if (vert_map[out_e_v[0]] == in_e_v_prev[1]) {
791 if (vert_map[out_e_v[1]] == in_e_v_prev[0]) {
793 std::cout <<
" case 3, edge_rep = in_e_prev = " << in_e_prev <<
"\n";
795 edge_rep = in_e_prev;
797 else if (vert_map[out_e_v[1]] == -1) {
798 if (same_dir(out_positions[out_e_v[0]],
799 out_positions[out_e_v[1]],
800 in_positions[in_e_v_prev[0]],
801 in_positions[in_e_v_prev[1]]))
804 std::cout <<
" case 4, edge_rep = in_e_prev = " << in_e_prev <<
"\n";
806 edge_rep = in_e_prev;
811 if (edge_rep != -1) {
813 std::cout <<
" found: set edge_map[" << out_e <<
"] = " << edge_rep <<
"\n";
815 edge_map_[out_e] = edge_rep;
816 done_edge[out_e] =
true;
824constexpr int face_group_inline = 4;
831static Array<Vector<int, face_group_inline>> get_face_groups(
const MeshGL &mgl,
835 timeit::ScopedTimer timer(
"get_face_groups");
837 constexpr int dbg_level = 0;
838 Array<Vector<int, face_group_inline>> fg(input_faces_num);
839 const int tris_num = mgl.NumTri();
841 for (
const int t : IndexRange(tris_num)) {
842 const int faceid = mgl.faceID[t];
843 fg[faceid].append(t);
846 std::cout <<
"face_groups\n";
847 for (
const int i : fg.index_range()) {
848 std::cout <<
"orig face " << i;
849 dump_span(fg[i].as_span(),
"");
863static uchar check_original_face(
const Vector<int, face_group_inline> &group,
868 BLI_assert(0 <= face_index && face_index < mesh->faces_num);
869 const IndexRange orig_face = mesh->faces()[face_index];
872 int orig_face_size = orig_face.size();
873 if (orig_face_size != group.size() + 2) {
876 Span<int> orig_face_verts = mesh->corner_verts().slice(mesh->faces()[face_index]);
879 Array<uchar, 20> edge_value(orig_face_size, 0);
880 int stride = mgl.numProp;
881 for (
const int t : group) {
885 Array<int, 3> face_vert_index(3);
886 for (
const int i : IndexRange(3)) {
887 int v = mgl.triVerts[3 * t + i];
888 int prop_offset =
v * stride;
889 float3 pos(mgl.vertProperties[prop_offset],
890 mgl.vertProperties[prop_offset + 1],
891 mgl.vertProperties[prop_offset + 2]);
892 auto it = std::find_if(orig_face_verts.
begin(), orig_face_verts.
end(), [&](
int orig_v) {
893 return pos == mesh->vert_positions()[orig_v];
895 face_vert_index[i] = it == orig_face_verts.
end() ?
897 std::distance(orig_face_verts.
begin(), it);
900 for (
const int i : IndexRange(3)) {
901 const int a = face_vert_index[i];
902 const int b = face_vert_index[(i + 1) % 3];
903 if (a != -1 &&
b != -1) {
904 if ((a + 1) % orig_face_size ==
b) {
907 else if ((
b + 1) % orig_face_size == a) {
913 if (std::all_of(edge_value.begin(), edge_value.end(), [](
int x) { return x == 1; })) {
916 else if (std::all_of(edge_value.begin(), edge_value.end(), [](
int x) { return x == -1; })) {
923static OutFace make_out_face(
const MeshGL &mgl,
int tri_index,
int orig_face)
926 ans.verts = Vector<int, inline_outface_size>(3);
927 const int k = 3 * tri_index;
928 ans.verts[0] = mgl.triVerts[k];
929 ans.verts[1] = mgl.triVerts[k + 1];
930 ans.verts[2] = mgl.triVerts[k + 2];
931 ans.face_id = orig_face;
952 SharedEdge(
int e1,
int e2,
int v1,
int v2) : e1(e1), e2(e2), v1(v1),
v2(
v2) {}
956 int2 outface_group_face_indices()
const
958 return int2(e1 / 3, e2 / 3);
963static inline SharedEdge canon_shared_edge(
int e1,
int e2,
int v1,
int v2)
966 return SharedEdge(e1, e2, v1, v2);
968 return SharedEdge(e2, e1, v2, v1);
976static SharedEdge get_shared_edge_from_pair(
const OutFace &tri1,
const OutFace &tri2)
979 SharedEdge shared_edge(-1, -1, -1, -1);
980 for (
const int i1 : IndexRange(3)) {
981 for (
const int i2 : IndexRange(3)) {
982 const int v1 = tri1.verts[i1];
983 const int v2 = tri2.verts[i2];
985 const int v1_next = tri1.verts[(i1 + 1) % 3];
986 const int v2_prev = tri2.verts[(i2 + 2) % 3];
987 if (v1_next == v2_prev) {
988 shared_edge = SharedEdge(i1, 3 + ((i2 + 2) % 3), v1, v1_next);
991 const int v1_prev = tri1.verts[(i1 + 2) % 3];
992 const int v2_next = tri2.verts[(i2 + 1) % 3];
993 if (v1_prev == v2_next) {
994 shared_edge = SharedEdge((i1 + 2) % 3, 3 + i2, v1_prev, v1);
999 if (shared_edge.e1 != -1) {
1011static Vector<SharedEdge> get_shared_edges(
Span<OutFace> faces)
1013 Vector<SharedEdge> ans;
1016 Map<int2, int> edge_verts_to_tri;
1017 for (
const int face_index : faces.
index_range()) {
1018 const OutFace &f = faces[face_index];
1019 for (
const int i : IndexRange(3)) {
1020 int v1 = f.verts[i];
1021 int v2 = f.verts[(i + 1) % 3];
1022 int this_e = face_index * 3 + i;
1023 edge_verts_to_tri.add_new(
int2(v1, v2), this_e);
1024 int other_e = edge_verts_to_tri.lookup_default(
int2(v2, v1), -1);
1025 if (other_e != -1) {
1026 ans.append(canon_shared_edge(this_e, other_e, v1, v2));
1038static bool is_legal_merge(
const OutFace &f1,
const OutFace &f2,
int v1,
int v2)
1044 for (
const int v : f1.verts) {
1045 if (!
ELEM(v, v1, v2)) {
1046 if (f2.find_vert_index(v) != -1) {
1051 for (
const int v : f2.verts) {
1052 if (!
ELEM(v, v1, v2)) {
1053 if (f1.find_vert_index(v) != -1) {
1069static bool try_merge_out_face_pair(OutFace &f1,
const OutFace &f2,
const SharedEdge &se)
1072 constexpr int dbg_level = 0;
1073 if (dbg_level > 0) {
1074 std::cout <<
"try_merge_out_face_pair\n";
1075 dump_span(f1.verts.as_span(),
"f1");
1076 dump_span(f2.verts.as_span(),
"f2");
1077 std::cout <<
"shared edge: "
1078 <<
"(e" << se.e1 <<
",e" << se.e2 <<
";v" << se.v1 <<
",v" << se.v2 <<
")\n";
1080 const int f1_len = f1.verts.size();
1081 const int f2_len = f2.verts.size();
1082 const int v1 = se.v1;
1083 const int v2 = se.v2;
1086 const int i1 = f1.find_vert_index(v1);
1088 const int i1_next = (i1 + 1) % f1_len;
1089 const int i2 = f2.find_vert_index(v2);
1091 const int i2_next = (i2 + 1) % f2_len;
1092 BLI_assert(f1.verts[i1] == v1 && f1.verts[i1_next] == v2);
1093 BLI_assert(f2.verts[i2] == v2 && f2.verts[i2_next] == v1);
1094 const bool can_merge = is_legal_merge(f1, f2, v1, v2);
1095 if (dbg_level > 0) {
1096 std::cout <<
"i1 = " << i1 <<
", i2 = " << i2 <<
", can_merge = " << can_merge <<
"\n";
1107 const int i2_prev = (i2 + f2_len - 1) % f2_len;
1108 const int i2_next_next = (i2_next + 1) % f2_len;
1109 const auto *f2_start_it = f2.verts.begin() + i2_next_next;
1110 const auto *f2_end_it = f2.verts.begin() + i2_prev + 1;
1111 if (f2_end_it > f2_start_it) {
1112 f1.verts.insert(i1_next, f2_start_it, f2_end_it);
1115 const int n1 = std::distance(f2_start_it, f2.verts.end());
1117 f1.verts.insert(i1_next, f2_start_it, f2.verts.end());
1119 if (n1 < f2_len - 2) {
1120 f1.verts.insert(i1_next + n1, f2.verts.begin(), f2_end_it);
1123 if (dbg_level > 0) {
1124 dump_span(f1.verts.as_span(),
"merge result");
1130static void merge_out_face_pair(Vector<OutFace> &faces)
1132 constexpr int dbg_level = 0;
1134 OutFace &tri1 = faces[0];
1135 OutFace &tri2 = faces[1];
1136 if (dbg_level > 0) {
1137 std::cout <<
"\nmerge_out_face_pair for faceid " << faces[0].face_id <<
"\n";
1138 dump_span(tri1.verts.as_span(),
"tri1");
1139 dump_span(tri2.verts.as_span(),
"tri2");
1141 const SharedEdge shared_edge = get_shared_edge_from_pair(tri1, tri2);
1142 if (shared_edge.e1 == -1) {
1146 const int va = shared_edge.v1;
1147 const int vb = shared_edge.v2;
1148 const int e1 = shared_edge.e1;
1149 const int e2 = shared_edge.e2;
1150 if (dbg_level > 0) {
1151 std::cout <<
"shared_edge = e" << e1 <<
", e" << e2 <<
"; " << va <<
", " << vb <<
"\n";
1158 const int vc = tri1.verts[(e1 + 2) % 3];
1159 const int vd = tri2.verts[(e2 - 3 + 2) % 3];
1160 BLI_assert(tri1.verts[e1] == va && tri1.verts[(e1 + 1) % 3] == vb && tri2.verts[e2 - 3] == vb &&
1161 tri2.verts[(e2 - 3 + 1) % 3] == va);
1166 tri1.verts.resize(4);
1171 if (dbg_level > 0) {
1172 dump_span(tri1.verts.as_span(),
"merged quad");
1182static void merge_out_faces(Vector<OutFace> &faces)
1184 constexpr int dbg_level = 0;
1185 if (faces.size() <= 1) {
1188 if (faces.size() == 2) {
1189 merge_out_face_pair(faces);
1192 if (dbg_level > 0) {
1193 std::cout <<
"\nmerge_out_faces for faceid " << faces[0].face_id <<
"\n";
1194 for (
const int i : faces.index_range()) {
1195 const OutFace &f = faces[i];
1196 dump_span(f.verts.as_span(), std::to_string(i));
1199 Vector<SharedEdge> shared_edges = get_shared_edges(faces);
1200 if (dbg_level > 0) {
1201 std::cout <<
"shared edges:\n";
1202 for (
const SharedEdge &se : shared_edges) {
1203 std::cout <<
"(e" << se.e1 <<
",e" << se.e2 <<
";v" << se.v1 <<
",v" << se.v2 <<
")";
1208 if (shared_edges.is_empty()) {
1212 Array<bool> shared_edge_valid(shared_edges.size(),
true);
1215 Array<int> merged_to(faces.size(), -1);
1217 auto final_merged_to = [&](
int f_orig) {
1219 int f_mapped = f_orig;
1221 if (merged_to[f_mapped] != -1) {
1222 f_mapped = merged_to[f_mapped];
1224 }
while (merged_to[f_mapped] != -1);
1228 for (
const int i : shared_edges.index_range()) {
1229 if (!shared_edge_valid[i]) {
1232 const SharedEdge se = shared_edges[i];
1233 const int2 orig_faces = se.outface_group_face_indices();
1234 const int2 cur_faces =
int2(final_merged_to(orig_faces[0]), final_merged_to(orig_faces[1]));
1235 const int f1 = cur_faces[0];
1236 const int f2 = cur_faces[1];
1237 if (f1 == -1 || f2 == -2) {
1240 if (dbg_level > 0) {
1241 std::cout <<
"try merge of faces " << f1 <<
" and " << f2 <<
"\n";
1243 if (try_merge_out_face_pair(faces[f1], faces[f2], se)) {
1244 if (dbg_level > 0) {
1245 std::cout <<
"successful merge\n";
1246 dump_span(faces[f1].verts.as_span(),
"new f1");
1254 const int orig_faces_num = faces.size();
1255 while (move_from < orig_faces_num) {
1257 while (move_from < orig_faces_num && merged_to[move_from] != -1) {
1260 if (move_from >= orig_faces_num) {
1263 if (move_to < move_from) {
1264 faces[move_to] = faces[move_from];
1269 if (move_to < orig_faces_num) {
1270 faces.resize(move_to);
1272 if (dbg_level > 0) {
1273 std::cout <<
"final faces:\n";
1274 for (
const int i : faces.index_range()) {
1275 dump_span(faces[i].verts.as_span(), std::to_string(i));
1281static inline bool approx_in_line(
const float3 &p0,
const float3 &p1,
const float3 &p2)
1283 float cos_ang = math::dot(math::normalize(p1 - p0), math::normalize(p2 - p1));
1284 return math::abs(cos_ang - 1.0) < 1
e-4;
1298static void dissolve_valence2_verts(MeshAssembly &ma)
1300 const int vnum = ma.output_verts_num;
1301 Array<bool> dissolve(vnum,
false);
1303 Array<std::pair<int, int>> neighbors(ma.output_verts_num, std::pair<int, int>(-1, -1));
1305 for (
const int f : ma.new_faces.index_range()) {
1306 const OutFace &face = ma.new_faces[f];
1307 const int fsize = face.verts.size();
1308 for (
const int i : IndexRange(fsize)) {
1309 const int vprev = face.verts[(i - 1 + fsize) % fsize];
1310 const int v = face.verts[i];
1311 const int vnext = face.verts[(i + 1) % fsize];
1312 std::pair<int, int> &v_nbrs = neighbors[
v];
1313 if (v_nbrs.first == -1) {
1315 v_nbrs.first = vprev;
1316 v_nbrs.second = vnext;
1318 dissolve[
v] = fsize <= 3 ?
false :
true;
1324 if (fsize == 3 || !(vprev == v_nbrs.second && vnext == v_nbrs.first)) {
1325 dissolve[
v] =
false;
1334 for (
const int f : ma.new_faces.index_range()) {
1335 const OutFace &face = ma.new_faces[f];
1336 const int fsize = face.verts.size();
1337 int num_dissolved = 0;
1338 for (
const int i : IndexRange(fsize)) {
1339 if (dissolve[face.verts[i]]) {
1343 if (fsize - num_dissolved < 3) {
1344 for (
const int i : IndexRange(fsize)) {
1345 dissolve[face.verts[i]] =
false;
1351 bool any_dissolve =
false;
1352 threading::parallel_for(IndexRange(vnum), grain_size, [&](
const IndexRange range) {
1353 bool range_any_dissolve =
false;
1354 for (
const int v : range) {
1356 std::pair<int, int> &v_nbrs = neighbors[
v];
1357 BLI_assert(v_nbrs.first != -1 && v_nbrs.second != -1);
1358 const float3 p0 = ma.vert_position(v_nbrs.first);
1359 const float3 p1 = ma.vert_position(v);
1360 const float3 p2 = ma.vert_position(v_nbrs.second);
1361 if (!approx_in_line(p0, p1, p2)) {
1362 dissolve[
v] =
false;
1365 range_any_dissolve =
true;
1369 if (range_any_dissolve) {
1371 any_dissolve =
true;
1374 if (!any_dissolve) {
1382 IndexMaskMemory memory;
1383 IndexMask keep = IndexMask::from_bools_inverse(
1384 dissolve.index_range(), dissolve.as_span(), memory);
1385 const int new_vnum = keep.size();
1386 ma.old_to_new_vert_map.reinitialize(vnum);
1387 ma.old_to_new_vert_map.fill(-1);
1388 index_mask::build_reverse_map<int>(keep, ma.old_to_new_vert_map);
1391 float *vpos_data = ma.vertpos.data();
1393 for (
const int old_v : IndexRange(vnum)) {
1394 const int new_v = ma.old_to_new_vert_map[old_v];
1397 std::copy_n(vpos_data + 3 * old_v, 3, vpos_data + 3 * new_v);
1400 ma.vertpos = ma.vertpos.take_front(new_vnum * ma.vertpos_stride);
1401 ma.output_verts_num = new_vnum;
1404 threading::parallel_for(ma.new_faces.index_range(), 10000, [&](IndexRange range) {
1405 for (const int f : range) {
1406 OutFace &face = ma.new_faces[f];
1408 for (const int i_from : face.verts.index_range()) {
1409 const int mapped_v_from = ma.mapped_vert(face.verts[i_from]);
1410 if (mapped_v_from >= 0) {
1411 face.verts[i_to++] = mapped_v_from;
1414 if (i_to < face.verts.size()) {
1415 BLI_assert(i_to >= 3);
1416 face.verts.resize(i_to);
1431static MeshAssembly assemble_mesh_from_meshgl(MeshGL &mgl,
const MeshOffsets &mesh_offsets)
1434 timeit::ScopedTimer timer(
"calculating assemble_mesh_from_meshgl");
1436 constexpr int dbg_level = 0;
1437 if (dbg_level > 0) {
1438 std::cout <<
"assemble_mesh_from_meshgl\n";
1441 ma.vertpos = MutableSpan<float>(&*mgl.vertProperties.begin(), mgl.vertProperties.size());
1442 ma.vertpos_stride = mgl.numProp;
1443 ma.input_verts_num = mesh_offsets.vert_start.last();
1444 ma.output_verts_num = ma.vertpos.size() / ma.vertpos_stride;
1445 const int input_faces_num = mesh_offsets.face_start.last();
1448 Array<Vector<int, face_group_inline>> face_groups = get_face_groups(mgl, input_faces_num);
1449 if (dbg_level > 1) {
1450 std::cout <<
"groups:\n";
1451 for (
const int i : face_groups.index_range()) {
1452 std::cout <<
"orig (offset) face " << i <<
": ";
1453 dump_span(face_groups[i].as_span(),
"");
1458 timeit::ScopedTimer timer(
"face merging");
1460 Vector<Vector<OutFace>> new_groups(face_groups.size());
1462 threading::parallel_for(face_groups.index_range(), grain_size, [&](
const IndexRange range) {
1463 for (const int gid : range) {
1464 const Span<int> group = face_groups[gid].as_span();
1465 Vector<OutFace> &group_faces = new_groups[gid] = Vector<OutFace, 4>(group.size());
1466 for (const int i : group_faces.index_range()) {
1467 int tri_index = group[i];
1468 group_faces[i] = make_out_face(mgl, tri_index, gid);
1470 merge_out_faces(group_faces);
1474 timeit::ScopedTimer xtimer(
"copying groups at end");
1476 for (
const int i : new_groups.index_range()) {
1477 ma.new_faces.extend(new_groups[i].as_span());
1482 timeit::ScopedTimer timer(
"valence-2-vertex dissolving");
1484 dissolve_valence2_verts(ma);
1485 if (ma.old_to_new_vert_map.size() > 0) {
1488 mgl.vertProperties.resize(ma.vertpos.size());
1491 if (dbg_level > 0) {
1492 std::cout <<
"mesh_assembly result:\n";
1493 std::cout <<
"input_verts_num = " << ma.input_verts_num
1494 <<
", output_verts_num = " << ma.output_verts_num <<
"\n";
1495 dump_span_with_stride(ma.vertpos.as_span(), ma.vertpos_stride,
"vertpos");
1496 std::cout <<
"new_faces:\n";
1497 for (
const int i : ma.new_faces.index_range()) {
1498 std::cout << i <<
": face_id = " << ma.new_faces[i].face_id <<
"\nverts ";
1499 dump_span(ma.new_faces[i].verts.as_span(),
"");
1509static void get_intersecting_edges(Vector<int> *r_intersecting_edges,
1511 OutToInMaps &out_to_in,
1512 const MeshOffsets &mesh_offsets)
1518 timeit::ScopedTimer timer(
"get_intersecting_edges");
1520 const OffsetIndices<int> faces = mesh->faces();
1521 const Span<int> corner_edges = mesh->corner_edges();
1522 const Span<int> face_map = out_to_in.ensure_face_map();
1523 Array<int> edge_first_face(mesh->edges_num, -1);
1524 for (
int face_i : faces.index_range()) {
1525 for (
const int edge_i : corner_edges.
slice(faces[face_i])) {
1526 int face2_i = edge_first_face[edge_i];
1527 if (face2_i == -1) {
1528 edge_first_face[edge_i] = face_i;
1531 int in_face_i = face_map[face_i];
1532 int in_face2_i = face_map[face2_i];
1537 r_intersecting_edges->append(edge_i);
1549static bool is_plane(
const Mesh *mesh,
1552 float *r_origin_offset)
1554 if (mesh->faces_num != 1 || mesh->verts_num != 4) {
1559 const Span<int> f_corners = mesh->corner_verts().slice(mesh->faces()[0]);
1560 for (
int i = 0; i < 4; i++) {
1563 float3 norm1 = math::normal_tri(vpos[0], vpos[1], vpos[2]);
1564 float3 norm2 = math::normal_tri(vpos[0], vpos[2], vpos[3]);
1565 if (math::almost_equal_relative(norm1, norm2, 1e-5f)) {
1567 *r_origin_offset = math::dot(norm1, vpos[0]);
1579static MeshGL mesh_trim_manifold(Manifold &manifold0,
1581 float origin_offset,
1582 const MeshOffsets &mesh_offsets,
1583 BooleanError *r_error)
1585 Manifold man_result = manifold0.TrimByPlane(manifold::vec3(normal[0], normal[1], normal[2]),
1586 double(origin_offset));
1587 MeshGL meshgl = man_result.GetMeshGL();
1588 if (man_result.Status() != Manifold::Error::NoError) {
1589 if (man_result.Status() == Manifold::Error::ResultTooLarge) {
1590 r_error->type = BooleanErrorType::ResultTooBig;
1592 else if (man_result.Status() == Manifold::Error::NotManifold) {
1593 r_error->type = BooleanErrorType::NonManifold;
1596 r_error->type = BooleanErrorType::UnknownError;
1603 if (!meshgl.vertProperties.empty()) {
1604 BLI_assert(meshgl.runOriginalID.size() == 2 && meshgl.runOriginalID[1] > 0);
1605 meshgl.runOriginalID[1] = 1;
1607 int plane_face_start = meshgl.runIndex[1] / 3;
1608 int plane_face_end = meshgl.runIndex[2] / 3;
1609 for (
int i = plane_face_start; i < plane_face_end; i++) {
1610 meshgl.faceID[i] = mesh_offsets.face_offsets[1][0];
1622static Mesh *meshgl_to_mesh(MeshGL &mgl,
1623 const Mesh *joined_mesh,
1625 const Span<Array<short>> material_remaps,
1626 const MeshOffsets &mesh_offsets,
1627 Vector<int> *r_intersecting_edges)
1629 constexpr int dbg_level = 0;
1630 if (dbg_level > 0) {
1631 std::cout <<
"MESHGL_TO_MESH\n";
1634 timeit::ScopedTimer timer(
"meshgl to mesh from joined_mesh");
1638 if (mgl.vertProperties.empty() || mgl.triVerts.empty()) {
1644 MeshAssembly ma = assemble_mesh_from_meshgl(mgl, mesh_offsets);
1645 const int verts_num = ma.output_verts_num;
1646 const int faces_num = ma.new_faces.size();
1651 Mesh *mesh = bke::mesh_new_no_attributes(verts_num, 0, faces_num, 0);
1656 MutableSpan<int> face_offsets = mesh->face_offsets_for_write();
1657 threading::parallel_for(IndexRange(faces_num), 10'000, [&](
const IndexRange range) {
1658 for (
const int face : range) {
1659 face_offsets[face] = ma.new_faces[face].verts.size();
1662 const OffsetIndices<int> faces = offset_indices::accumulate_counts_to_offsets(face_offsets);
1663 mesh->corners_num = faces.total_size();
1665 bke::MutableAttributeAccessor output_attrs = mesh->attributes_for_write();
1670 timeit::ScopedTimer timer_c(
"calculate faces");
1672 output_attrs.add<
int>(
".corner_vert", bke::AttrDomain::Corner, bke::AttributeInitConstruct());
1673 MutableSpan<int> corner_verts = mesh->corner_verts_for_write();
1674 threading::parallel_for(IndexRange(faces_num), 10'000, [&](
const IndexRange range) {
1675 for (
const int face : range) {
1676 corner_verts.slice(faces[face]).copy_from(ma.new_faces[face].verts);
1684 timeit::ScopedTimer timer_c(
"set positions");
1686 BLI_assert(!output_attrs.contains(
"position"));
1688 auto *sharing_info =
new ImplicitSharedValue<std::vector<float>>(
1689 std::move(mgl.vertProperties));
1690 const bke::AttributeInitShared
init(sharing_info->data.data(), *sharing_info);
1691 output_attrs.add<
float3>(
"position", bke::AttrDomain::Point,
init);
1692 sharing_info->remove_user_and_delete_if_last();
1697 timeit::ScopedTimer timer_e(
"calculating edges");
1699 bke::mesh_calc_edges(*mesh,
false,
false);
1704 OutToInMaps out_to_in(&ma, joined_mesh, mesh, &mesh_offsets);
1708 timeit::ScopedTimer timer_a(
"copying and interpolating attributes");
1719 bke::AttributeAccessor join_attrs = joined_mesh->
attributes();
1721 join_attrs.foreach_attribute([&](
const bke::AttributeIter &iter) {
1722 if (iter.domain == bke::AttrDomain::Corner) {
1735 const GVArray src = *iter.get();
1736 const CommonVArrayInfo info = src.common_info();
1737 if (info.type == CommonVArrayInfo::Type::Single) {
1738 const bke::AttributeInitValue
init(GPointer(src.type(), info.data));
1739 output_attrs.add(iter.name, iter.domain, iter.data_type,
init);
1742 const GVArraySpan src_span = src;
1743 bke::GSpanAttributeWriter dst = output_attrs.lookup_or_add_for_write_only_span(
1744 iter.name, iter.domain, iter.data_type);
1745 switch (iter.domain) {
1746 case bke::AttrDomain::Point: {
1750 case bke::AttrDomain::Face: {
1754 case bke::AttrDomain::Edge: {
1766 if (join_attrs.contains(
"material_index")) {
1771 bke::SpanAttributeWriter dst = output_attrs.lookup_or_add_for_write_only_span<
int>(
1772 "material_index", bke::AttrDomain::Face);
1773 if (material_remaps.is_empty()) {
1774 const VArraySpan src = *join_attrs.lookup<
int>(
"material_index");
1779 out_to_in.ensure_face_map(), material_remaps, meshes, mesh_offsets, dst.span);
1788 out_to_in.ensure_corner_map(),
1789 out_to_in.ensure_face_map());
1791 if (r_intersecting_edges !=
nullptr) {
1792 get_intersecting_edges(r_intersecting_edges, mesh, out_to_in, mesh_offsets);
1796 mesh->tag_loose_verts_none();
1797 mesh->tag_overlapping_none();
1806 const Span<Array<short>> material_remaps,
1807 const BooleanOpParameters op_params,
1808 Vector<int> *r_intersecting_edges,
1809 BooleanError *r_error)
1811 constexpr int dbg_level = 0;
1812 if (dbg_level > 0) {
1813 std::cout <<
"\nMESH_BOOLEAN_MANIFOLD with " << meshes.
size() <<
" args\n";
1815 r_error->type = BooleanErrorType::NoError;
1818 timeit::ScopedTimer timer(
"MANIFOLD BOOLEAN");
1821 const int meshes_num = meshes.
size();
1824 const Mesh *joined_mesh = joined_meshes_set.get_mesh();
1825 if (joined_mesh ==
nullptr) {
1829 const MeshOffsets mesh_offsets(meshes);
1830 std::vector<Manifold> manifolds(meshes_num);
1831 get_manifolds(manifolds, meshes, transforms, mesh_offsets);
1833 MeshGL meshgl_result;
1835 if (std::any_of(manifolds.begin(),
1837 [](
const Manifold &m) { return m.Status() != Manifold::Error::NoError; }))
1841 float origin_offset;
1842 if (meshes_num == 2 && op == Operation::Difference &&
1843 manifolds[0].Status() == Manifold::Error::NoError &&
1844 is_plane(meshes[1], transforms[1], &normal, &origin_offset))
1847 timeit::ScopedTimer timer_trim(
"DOING BOOLEAN SLICE, GETTING MESH_GL RESULT");
1849 meshgl_result = mesh_trim_manifold(
1850 manifolds[0], normal, origin_offset, mesh_offsets, r_error);
1851 if (r_error->type != BooleanErrorType::NoError) {
1856 for (
int i = 0; i < manifolds.size(); i++) {
1857 if (manifolds[i].Status() == Manifold::Error::NotManifold) {
1858 r_error->type = BooleanErrorType::NonManifold;
1859 r_error->non_manifold_mesh_indices.append(i);
1863 if (r_error->non_manifold_mesh_indices.is_empty()) {
1864 r_error->type = BooleanErrorType::UnknownError;
1870 manifold::OpType mop = op == Operation::Intersect ?
1871 manifold::OpType::Intersect :
1872 (op == Operation::Union ? manifold::OpType::Add :
1873 manifold::OpType::Subtract);
1875 timeit::ScopedTimer timer_bool(
"DOING BOOLEAN, GETTING MESH_GL RESULT");
1877 Manifold man_result = Manifold::BatchBoolean(manifolds, mop);
1878 meshgl_result = man_result.GetMeshGL();
1880 if (man_result.Status() != Manifold::Error::NoError) {
1881 if (man_result.Status() == Manifold::Error::ResultTooLarge) {
1882 r_error->type = BooleanErrorType::ResultTooBig;
1885 r_error->type = BooleanErrorType::UnknownError;
1887 if (dbg_level > 0) {
1888 std::cout <<
"manifold boolean returned with error status\n";
1893 if (dbg_level > 0) {
1894 std::cout <<
"boolean result has " << meshgl_result.NumTri() <<
" tris\n";
1895 dump_meshgl(meshgl_result,
"boolean result meshgl");
1896 if (dbg_level > 1) {
1897 dump_meshgl_as_obj(meshgl_result);
1900 clean_meshgl(meshgl_result);
1904 timeit::ScopedTimer timer_out(
"MESHGL RESULT TO MESH");
1906 mesh_result = meshgl_to_mesh(
1907 meshgl_result, joined_mesh, meshes, material_remaps, mesh_offsets, r_intersecting_edges);
1911 catch (
const std::exception &e) {
1912 std::cout <<
"mesh_boolean_manifold: exception: " <<
e.what() <<
"\n";
1915 std::cout <<
"mesh_boolean_manifold: unknown exception\n";
1917 r_error->type = BooleanErrorType::UnknownError;
#define BLI_assert_unreachable()
SIMD_FORCE_INLINE btVector3 transform(const btVector3 &point) const
constexpr Span slice(int64_t start, int64_t size) const
constexpr int64_t size() const
constexpr const T * end() const
constexpr IndexRange index_range() const
constexpr const T * begin() const
constexpr IndexRange()=default
constexpr MutableSpan()=default
VecBase< float, 3 > float3
void copy(const GVArray &src, GMutableSpan dst, exec_mode::Mode mode=exec_mode::parallel)
void vert_tris_from_corner_tris(Span< int > corner_verts, Span< int3 > corner_tris, MutableSpan< int3 > vert_tris)
constexpr ParallelGrainSize grain_size(int grain_size)
void copy_attribute_using_map(GSpan src, Span< int > out_to_in_map, GMutableSpan dst)
int mesh_id_for_face(int face_id, const MeshOffsets &mesh_offsets)
Mesh * mesh_boolean_manifold(Span< const Mesh * > meshes, Span< float4x4 > transforms, Span< Array< short > > material_remaps, BooleanOpParameters op_params, Vector< int > *r_intersecting_edges, BooleanError *r_error)
void interpolate_corner_attributes(bke::MutableAttributeAccessor output_attrs, bke::AttributeAccessor input_attrs, Mesh *output_mesh, const Mesh *input_mesh, Span< int > out_to_in_corner_map, Span< int > out_to_in_face_map)
IndexRange vertex_range_for_face(int face_id, const MeshOffsets &mesh_offsets)
void set_material_from_map(Span< int > out_to_in_map, Span< Array< short > > material_remaps, Span< const Mesh * > meshes, const MeshOffsets &mesh_offsets, MutableSpan< int > dst)
bke::GeometrySet join_meshes_with_transforms(Span< const Mesh * > meshes, Span< float4x4 > transforms)
void parallel_for(const IndexRange range, const int64_t grain_size, const Function &function, const TaskSizeHints &size_hints=detail::TaskSizeHints_Static(1))
Mesh * BKE_mesh_copy_for_eval(const Mesh &source)
void mul_v3_m4v3(float r[3], const float mat[4][4], const float vec[3])
ATTR_WARN_UNUSED_RESULT const BMVert * v
void BKE_mesh_copy_parameters_for_eval(Mesh *me_dst, const Mesh *me_src)
VecBase< float, 2 > float2
VecBase< int32_t, 3 > int3
Mesh * BKE_mesh_new_nomain(int verts_num, int edges_num, int faces_num, int corners_num)
void BKE_id_free(Main *bmain, void *idv)
ATTR_WARN_UNUSED_RESULT const BMVert * v2
VecBase< float, 3 > float3
ATTR_WARN_UNUSED_RESULT const BMVert const BMEdge * e