Blender V5.3
MOD_boolean.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2005 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
9#include <fmt/format.h>
10
11#include "BLI_utildefines.hh"
12
13#include "BLI_array.hh"
14#include "BLI_math_geom_c.hh"
15#include "BLI_math_matrix_c.hh"
17#include "BLI_vector.hh"
18#include "BLI_vector_set.hh"
19
20#include "BLT_translation.hh"
21
22#include "DNA_layer_types.h"
23#include "DNA_mesh_types.h"
24#include "DNA_object_types.h"
25#include "DNA_scene_types.h"
26#include "DNA_screen_types.h"
27
28#include "BKE_collection.hh"
29#include "BKE_global.hh" /* only to check G.debug */
30#include "BKE_lib_id.hh"
31#include "BKE_lib_query.hh"
32#include "BKE_material.hh"
33#include "BKE_mesh.hh"
34#include "BKE_mesh_wrapper.hh"
35#include "BKE_modifier.hh"
36
38#include "UI_resources.hh"
39
40#include "RNA_access.hh"
41#include "RNA_prototypes.hh"
42
43#include "MOD_ui_common.hh"
44
45#include "MEM_guardedalloc.h"
46
47#include "GEO_mesh_boolean.hh"
48#include "GEO_randomize.hh"
49
50#include "bmesh.hh"
52
53// #define DEBUG_TIME
54
55#ifdef DEBUG_TIME
56# include "BLI_timeit.hh"
57#endif
58
59namespace blender {
60
61static void init_data(ModifierData *md)
62{
63 BooleanModifierData *bmd = reinterpret_cast<BooleanModifierData *>(md);
65}
66
67static bool is_disabled(const Scene * /*scene*/, ModifierData *md, bool /*use_render_params*/)
68{
69 BooleanModifierData *bmd = reinterpret_cast<BooleanModifierData *>(md);
70 Collection *col = bmd->collection;
71
73 return !bmd->object || bmd->object->type != OB_MESH;
74 }
76 /* The Exact solver tolerates an empty collection. */
77 return !col && bmd->solver != eBooleanModifierSolver_Mesh_Arr;
78 }
79 return false;
80}
81
82static void foreach_ID_link(ModifierData *md, Object *ob, IDWalkFunc walk, void *user_data)
83{
84 BooleanModifierData *bmd = reinterpret_cast<BooleanModifierData *>(md);
85
86 walk(user_data, ob, reinterpret_cast<ID **>(&bmd->collection), IDWALK_CB_USER);
87 walk(user_data, ob, reinterpret_cast<ID **>(&bmd->object), IDWALK_CB_NOP);
88}
89
91{
92 BooleanModifierData *bmd = reinterpret_cast<BooleanModifierData *>(md);
93 if ((bmd->flag & eBooleanModifierFlag_Object) && bmd->object != nullptr) {
94 DEG_add_object_relation(ctx->node, bmd->object, DEG_OB_COMP_TRANSFORM, "Boolean Modifier");
95 DEG_add_object_relation(ctx->node, bmd->object, DEG_OB_COMP_GEOMETRY, "Boolean Modifier");
96 }
97
98 Collection *col = bmd->collection;
99
100 if ((bmd->flag & eBooleanModifierFlag_Collection) && col != nullptr) {
101 DEG_add_collection_geometry_relation(ctx->node, col, "Boolean Modifier");
102 }
103 /* We need own transformation as well. */
104 DEG_add_depends_on_transform_relation(ctx->node, "Boolean Modifier");
105}
106
108 Object *ob_self, Mesh *mesh_self, Object *ob_operand_ob, Mesh *mesh_operand_ob, int operation)
109{
110 Mesh *result = nullptr;
111
112 if (mesh_self->faces_num == 0 || mesh_operand_ob->faces_num == 0) {
113 switch (operation) {
115 result = BKE_mesh_new_nomain(0, 0, 0, 0);
116 break;
117
119 if (mesh_self->faces_num != 0) {
120 result = mesh_self;
121 }
122 else {
123 result = id_cast<Mesh *>(
124 BKE_id_copy_ex(nullptr, &mesh_operand_ob->id, nullptr, LIB_ID_COPY_LOCALIZE));
125
126 float imat[4][4];
127 float omat[4][4];
128 invert_m4_m4(imat, ob_self->object_to_world().ptr());
129 mul_m4_m4m4(omat, imat, ob_operand_ob->object_to_world().ptr());
130
131 MutableSpan<float3> positions = result->vert_positions_for_write();
132 for (const int i : positions.index_range()) {
133 mul_m4_v3(omat, positions[i]);
134 }
135
136 result->tag_positions_changed();
137 }
138
139 break;
140
142 result = mesh_self;
143 break;
144 }
145 }
146
147 return result;
148}
149
150/* has no meaning for faces, do this so we can tell which face is which */
151#define BM_FACE_TAG BM_ELEM_SELECT_UV
152
156static int bm_face_isect_pair(BMFace *f, void * /*user_data*/)
157{
158 return BM_elem_flag_test(f, BM_FACE_TAG) ? 1 : 0;
159}
160
161static bool BMD_error_messages(const Object *ob, ModifierData *md)
162{
163 BooleanModifierData *bmd = reinterpret_cast<BooleanModifierData *>(md);
164 Collection *col = bmd->collection;
165
166 bool error_returns_result = false;
167
168 const bool operand_collection = (bmd->flag & eBooleanModifierFlag_Collection) != 0;
169 const bool use_exact = bmd->solver == eBooleanModifierSolver_Mesh_Arr;
170 const bool use_manifold = bmd->solver == eBooleanModifierSolver_Manifold;
171 const bool operation_intersect = bmd->operation == eBooleanModifierOp_Intersect;
172
173#ifndef WITH_GMP
174 /* If compiled without GMP, return a error. */
175 if (use_exact) {
176 BKE_modifier_set_error(ob, md, "Compiled without GMP, using \"float\" solver");
177 error_returns_result = false;
178 }
179#endif
180
181 /* If intersect is selected using "float" solver, return a error. */
182 if (operand_collection && operation_intersect && !(use_exact || use_manifold)) {
183 BKE_modifier_set_error(ob, md, "Cannot execute, intersect only available using exact solver");
184 error_returns_result = true;
185 }
186
187 /* If the selected collection is empty and using "float" solver, return a error. */
188 if (operand_collection) {
189 if (!use_exact && BKE_collection_is_empty(col)) {
190 BKE_modifier_set_error(ob, md, "Cannot execute, non-exact solver and empty collection");
191 error_returns_result = true;
192 }
193
194 /* If the selected collection contain non mesh objects, return a error. */
195 if (col) {
197 if (operand_ob->type != OB_MESH) {
199 ob, md, "Cannot execute, the selected collection contains non mesh objects");
200 error_returns_result = true;
201 }
202 }
204 }
205 }
206
207 return error_returns_result;
208}
209
211 Mesh *mesh, Object *object, Mesh *mesh_operand_ob, Object *operand_ob, bool *r_is_flip)
212{
213#ifdef DEBUG_TIME
214 SCOPED_TIMER(__func__);
215#endif
216
217 *r_is_flip = (is_negative_m4(object->object_to_world().ptr()) !=
218 is_negative_m4(operand_ob->object_to_world().ptr()));
219
220 const BMAllocTemplate allocsize = BMALLOC_TEMPLATE_FROM_ME(mesh, mesh_operand_ob);
221
222 BMeshCreateParams bmesh_create_params{};
223 BMesh *bm = BM_mesh_create(&allocsize, &bmesh_create_params);
224
225 /* Keep `mesh` first, needed so active layers are set based on `mesh` not `mesh_operand_ob`,
226 * otherwise the wrong active render layer is used, see #92384.
227 *
228 * NOTE: while initializing customer data layers the is not essential,
229 * it avoids the overhead of having to re-allocate #BMHeader.data when the 2nd mesh is added
230 * (if it contains additional custom-data layers). */
231 const Mesh *mesh_array[2] = {mesh, mesh_operand_ob};
232 BM_mesh_copy_init_customdata_from_mesh_array(bm, mesh_array, ARRAY_SIZE(mesh_array), &allocsize);
233
234 BMeshFromMeshParams bmesh_from_mesh_params{};
235 bmesh_from_mesh_params.calc_face_normal = true;
236 bmesh_from_mesh_params.calc_vert_normal = true;
237 BM_mesh_bm_from_me(bm, mesh_operand_ob, &bmesh_from_mesh_params);
238
239 if (*r_is_flip) [[unlikely]] {
240 const int cd_loop_mdisp_offset = CustomData_get_offset(&bm->ldata, CD_MDISPS);
241 BMIter iter;
242 BMFace *efa;
243 BM_ITER_MESH (efa, &iter, bm, BM_FACES_OF_MESH) {
244 BM_face_normal_flip_ex(bm, efa, cd_loop_mdisp_offset, true);
245 }
246 }
247
248 BM_mesh_bm_from_me(bm, mesh, &bmesh_from_mesh_params);
249
250 return bm;
251}
252
254 ModifierData *md,
255 const ModifierEvalContext *ctx,
256 Mesh *mesh_operand_ob,
257 Object *object,
258 Object *operand_ob,
259 bool is_flip)
260{
261#ifdef DEBUG_TIME
262 SCOPED_TIMER(__func__);
263#endif
264
265 BooleanModifierData *bmd = reinterpret_cast<BooleanModifierData *>(md);
266
267 /* Main BMesh intersection setup. */
268 /* Create tessellation & intersect. */
269 const int looptris_tot = poly_to_tri_count(bm->totface, bm->totloop);
270 Array<std::array<BMLoop *, 3>> looptris(looptris_tot);
272
273 /* postpone this until after tessellating
274 * so we can use the original normals before the vertex are moved */
275 {
276 BMIter iter;
277 int i;
278 const int i_verts_end = mesh_operand_ob->verts_num;
279 const int i_faces_end = mesh_operand_ob->faces_num;
280
281 float imat[4][4];
282 float omat[4][4];
283 invert_m4_m4(imat, object->object_to_world().ptr());
284 mul_m4_m4m4(omat, imat, operand_ob->object_to_world().ptr());
285
286 BMVert *eve;
287 i = 0;
288 BM_ITER_MESH (eve, &iter, bm, BM_VERTS_OF_MESH) {
289 mul_m4_v3(omat, eve->co);
290 if (++i == i_verts_end) {
291 break;
292 }
293 }
294
295 /* we need face normals because of 'BM_face_split_edgenet'
296 * we could calculate on the fly too (before calling split). */
297 float nmat[3][3];
298 copy_m3_m4(nmat, omat);
299 invert_m3(nmat);
300
301 if (is_flip) [[unlikely]] {
302 negate_m3(nmat);
303 }
304
305 Array<short> material_remap(operand_ob->totcol ? operand_ob->totcol : 1);
306
307 /* Using original (not evaluated) object here since we are writing to it. */
308 /* XXX Pretty sure comment above is fully wrong now with copy-on-eval & co ? */
309 BKE_object_material_remap_calc(ctx->object, operand_ob, material_remap.data());
310
311 BMFace *efa;
312 i = 0;
313 BM_ITER_MESH (efa, &iter, bm, BM_FACES_OF_MESH) {
314 mul_transposed_m3_v3(nmat, efa->no);
315 normalize_v3(efa->no);
316
317 /* Temp tag to test which side split faces are from. */
319
320 /* remap material */
321 if (efa->mat_nr < operand_ob->totcol) [[likely]] {
322 efa->mat_nr = material_remap[efa->mat_nr];
323 }
324 else {
325 efa->mat_nr = 0;
326 }
327
328 if (++i == i_faces_end) {
329 break;
330 }
331 }
332 }
333
334 /* not needed, but normals for 'dm' will be invalid,
335 * currently this is ok for 'BM_mesh_intersect' */
336 // BM_mesh_normals_update(bm);
337
338 bool use_separate = false;
339 bool use_dissolve = true;
340 bool use_island_connect = true;
341
342 /* change for testing */
343 if (G.debug & G_DEBUG) {
344 use_separate = (bmd->bm_flag & eBooleanModifierBMeshFlag_BMesh_Separate) != 0;
345 use_dissolve = (bmd->bm_flag & eBooleanModifierBMeshFlag_BMesh_NoDissolve) == 0;
346 use_island_connect = (bmd->bm_flag & eBooleanModifierBMeshFlag_BMesh_NoConnectRegions) == 0;
347 }
348
350 looptris,
352 nullptr,
353 false,
354 use_separate,
355 use_dissolve,
356 use_island_connect,
357 false,
358 false,
359 bmd->operation,
360 bmd->double_threshold);
361}
362
363#ifdef WITH_GMP
364
365/* Get a mapping from material slot numbers in the src_ob to slot numbers in the dst_ob.
366 * If a material doesn't exist in the dst_ob, the mapping just goes to the same slot
367 * or to zero if there aren't enough slots in the destination. */
368static Array<short> get_material_remap_index_based(Object *dest_ob, Object *src_ob)
369{
370 const int n = src_ob->totcol;
371 if (n <= 0) {
372 return Array<short>(1, 0);
373 }
374 Array<short> remap(n);
375 BKE_object_material_remap_calc(dest_ob, src_ob, remap.data());
376 return remap;
377}
378
379/* Get a mapping from material slot numbers in the source geometry to slot numbers in the result
380 * geometry. The material is added to the result geometry if it doesn't already use it. */
381static Array<short> get_material_remap_transfer(Object &object,
382 const Mesh &mesh,
383 VectorSet<Material *> &materials)
384{
385 const int material_num = mesh.totcol;
386 Array<short> map(material_num);
387 for (const int i : IndexRange(material_num)) {
388 Material *material = BKE_object_material_get_eval(&object, i + 1);
389 map[i] = material ? materials.index_of_or_add(material) : -1;
390 }
391 return map;
392}
393
394static Mesh *non_float_boolean_mesh(BooleanModifierData *bmd,
395 const ModifierEvalContext *ctx,
396 Mesh *mesh)
397{
398 const float4x4 &world_to_object = ctx->object->world_to_object();
400 Vector<float4x4> transforms;
401
402 Vector<Array<short>> material_remaps;
403
404# ifdef DEBUG_TIME
405 SCOPED_TIMER(__func__);
406# endif
407
408 if ((bmd->flag & eBooleanModifierFlag_Object) && bmd->object == nullptr) {
409 return mesh;
410 }
411
415 meshes.append(mesh);
416 transforms.append(float4x4::identity());
417 material_remaps.append({});
418
419 Vector<const char *> object_names;
420 object_names.append(BKE_id_name(ctx->object->id));
421
423 bmd->material_mode);
424 VectorSet<Material *> materials;
425 if (material_mode == eBooleanModifierMaterialMode_Transfer) {
426 if (mesh->totcol == 0) {
427 /* Necessary for faces using the default material when there are no material slots. */
428 materials.add(nullptr);
429 }
430 else {
431 materials.add_multiple({mesh->mat, mesh->totcol});
432 }
433 }
434
435 if (bmd->flag & eBooleanModifierFlag_Object) {
437 if (!mesh_operand) {
438 return mesh;
439 }
440 BKE_mesh_wrapper_ensure_mdata(mesh_operand);
441 meshes.append(mesh_operand);
442 transforms.append(world_to_object * bmd->object->object_to_world());
443 object_names.append(BKE_id_name(bmd->object->id));
444 if (material_mode == eBooleanModifierMaterialMode_Index) {
445 material_remaps.append(get_material_remap_index_based(ctx->object, bmd->object));
446 }
447 else {
448 material_remaps.append(get_material_remap_transfer(*bmd->object, *mesh_operand, materials));
449 }
450 }
451 else if (bmd->flag & eBooleanModifierFlag_Collection) {
452 Collection *collection = bmd->collection;
453 /* Allow collection to be empty; then target mesh will just removed self-intersections. */
454 if (collection) {
456 if (ob->type == OB_MESH && ob != ctx->object) {
458 if (!collection_mesh) {
459 continue;
460 }
461 BKE_mesh_wrapper_ensure_mdata(collection_mesh);
462 meshes.append(collection_mesh);
463 transforms.append(world_to_object * ob->object_to_world());
464 object_names.append(BKE_id_name(ob->id));
465 if (material_mode == eBooleanModifierMaterialMode_Index) {
466 material_remaps.append(get_material_remap_index_based(ctx->object, ob));
467 }
468 else {
469 material_remaps.append(get_material_remap_transfer(*ob, *collection_mesh, materials));
470 }
471 }
472 }
474 }
475 }
476
477 const bool use_self = (bmd->flag & eBooleanModifierFlag_Self) != 0;
478 const bool hole_tolerant = (bmd->flag & eBooleanModifierFlag_HoleTolerant) != 0;
480 op_params.boolean_mode = geometry::boolean::Operation(bmd->operation);
481 op_params.no_self_intersections = !use_self;
482 op_params.watertight = !hole_tolerant;
483 op_params.no_nested_components = false;
486 meshes, transforms, material_remaps, op_params, solver, nullptr, &error);
487
490 if (!error.non_manifold_mesh_indices.is_empty()) {
491 std::string names;
492 for (const auto index : error.non_manifold_mesh_indices) {
493 if (!names.empty()) {
494 names += ", ";
495 }
496 names += fmt::format("'{}'", object_names[index]);
497 }
498 BKE_modifier_set_error(ctx->object,
499 (ModifierData *)bmd,
500 "Cannot execute, object(s) %s have non-manifold geometry",
501 names.c_str());
502 }
503 else {
505 ctx->object, (ModifierData *)bmd, "Cannot execute, non-manifold inputs");
506 }
507 }
509 BKE_modifier_set_error(ctx->object, (ModifierData *)(bmd), "Cannot execute, unknown error");
510 }
511 return result;
512 }
513
514 if (result) {
515 if (material_mode == eBooleanModifierMaterialMode_Transfer) {
516 MEM_SAFE_DELETE(result->mat);
517 result->mat = MEM_new_array_uninitialized<Material *>(size_t(materials.size()), __func__);
518 result->totcol = materials.size();
519 MutableSpan(result->mat, result->totcol).copy_from(materials);
520 }
521
523 }
524
525 return result;
526}
527#endif
528
530{
531 BooleanModifierData *bmd = reinterpret_cast<BooleanModifierData *>(md);
532 Object *object = ctx->object;
533 Mesh *result = mesh;
534 Collection *collection = bmd->collection;
535
536 /* Return result for certain errors. */
537 if (BMD_error_messages(ctx->object, md)) {
538 return result;
539 }
540
541#ifdef WITH_GMP
543 return non_float_boolean_mesh(bmd, ctx, mesh);
544 }
545#endif
546
547#ifdef DEBUG_TIME
548 SCOPED_TIMER(__func__);
549#endif
550
552 if (bmd->object == nullptr) {
553 return result;
554 }
555
556 Object *operand_ob = bmd->object;
557
558 Mesh *mesh_operand_ob = BKE_modifier_get_evaluated_mesh_from_evaluated_object(operand_ob);
559
560 if (mesh_operand_ob) {
561 /* XXX This is utterly non-optimal, we may go from a bmesh to a mesh back to a bmesh!
562 * But for 2.90 better not try to be smart here. */
563 BKE_mesh_wrapper_ensure_mdata(mesh_operand_ob);
564 /* when one of objects is empty (has got no faces) we could speed up
565 * calculation a bit returning one of objects' derived meshes (or empty one)
566 * Returning mesh is dependent on modifiers operation (sergey) */
567 result = get_quick_mesh(object, mesh, operand_ob, mesh_operand_ob, bmd->operation);
568
569 if (result == nullptr) {
570 bool is_flip;
571 BMesh *bm = BMD_mesh_bm_create(mesh, object, mesh_operand_ob, operand_ob, &is_flip);
572
573 BMD_mesh_intersection(bm, md, ctx, mesh_operand_ob, object, operand_ob, is_flip);
574
576
578 }
579
580 if (result == nullptr) {
581 BKE_modifier_set_error(object, md, "Cannot execute boolean operation");
582 }
583 }
584 }
585 else {
586 if (collection == nullptr) {
587 return result;
588 }
589
590 FOREACH_COLLECTION_OBJECT_RECURSIVE_BEGIN (collection, operand_ob) {
591 if (operand_ob->type == OB_MESH && operand_ob != ctx->object) {
592 Mesh *mesh_operand_ob = BKE_modifier_get_evaluated_mesh_from_evaluated_object(operand_ob);
593
594 if (mesh_operand_ob == nullptr) {
595 continue;
596 }
597
598 /* XXX This is utterly non-optimal, we may go from a bmesh to a mesh back to a bmesh!
599 * But for 2.90 better not try to be smart here. */
600 BKE_mesh_wrapper_ensure_mdata(mesh_operand_ob);
601
602 bool is_flip;
603 BMesh *bm = BMD_mesh_bm_create(result, object, mesh_operand_ob, operand_ob, &is_flip);
604
605 BMD_mesh_intersection(bm, md, ctx, mesh_operand_ob, object, operand_ob, is_flip);
606
607 /* Needed for multiple objects to work. */
608 if (result == mesh) {
610 }
611 else {
612 BMeshToMeshParams bmesh_to_mesh_params{};
613 bmesh_to_mesh_params.calc_object_remap = false;
614 BM_mesh_bm_to_me(nullptr, bm, result, &bmesh_to_mesh_params);
615 }
617 }
618 }
620 }
621
623
624 return result;
625}
626
627static void required_data_mask(ModifierData * /*md*/, CustomData_MeshMasks *r_cddata_masks)
628{
629 r_cddata_masks->vmask |= CD_MASK_MDEFORMVERT;
630 r_cddata_masks->fmask |= CD_MASK_MTFACE;
631}
632
633static void panel_draw(const bContext * /*C*/, Panel *panel)
634{
635 ui::Layout &layout = *panel->layout;
637
638 layout.prop(ptr, "operation", ui::ITEM_R_EXPAND, std::nullopt, ICON_NONE);
639
640 layout.use_property_split_set(true);
641
642 layout.prop(ptr, "operand_type", UI_ITEM_NONE, std::nullopt, ICON_NONE);
643 if (RNA_enum_get(ptr, "operand_type") == eBooleanModifierFlag_Object) {
644 layout.prop(ptr, "object", UI_ITEM_NONE, std::nullopt, ICON_NONE);
645 }
646 else {
647 layout.prop(ptr, "collection", UI_ITEM_NONE, std::nullopt, ICON_NONE);
648 }
649
650 layout.prop(ptr, "solver", ui::ITEM_R_EXPAND, std::nullopt, ICON_NONE);
651
652 modifier_error_message_draw(layout, ptr);
653}
654
655static void solver_options_panel_draw(const bContext * /*C*/, Panel *panel)
656{
657 ui::Layout &layout = *panel->layout;
659
660 const bool use_exact = RNA_enum_get(ptr, "solver") == eBooleanModifierSolver_Mesh_Arr;
661 const bool use_manifold = RNA_enum_get(ptr, "solver") == eBooleanModifierSolver_Manifold;
662
663 layout.use_property_split_set(true);
664
665 ui::Layout &col = layout.column(true);
666 if (use_exact) {
667 col.prop(ptr, "material_mode", UI_ITEM_NONE, IFACE_("Materials"), ICON_NONE);
668 /* When operand is collection, we always use_self. */
669 if (RNA_enum_get(ptr, "operand_type") == eBooleanModifierFlag_Object) {
670 col.prop(ptr, "use_self", UI_ITEM_NONE, std::nullopt, ICON_NONE);
671 }
672 col.prop(ptr, "use_hole_tolerant", UI_ITEM_NONE, std::nullopt, ICON_NONE);
673 }
674 else if (use_manifold) {
675 col.prop(ptr, "material_mode", UI_ITEM_NONE, IFACE_("Materials"), ICON_NONE);
676 }
677 else {
678 col.prop(ptr, "double_threshold", UI_ITEM_NONE, std::nullopt, ICON_NONE);
679 }
680
681 if (G.debug) {
682 col.prop(ptr, "debug_options", UI_ITEM_NONE, std::nullopt, ICON_NONE);
683 }
684}
685
686static void panel_register(ARegionType *region_type)
687{
690 region_type, "solver_options", "Solver Options", nullptr, solver_options_panel_draw, panel);
691}
692
694 /*idname*/ "Boolean",
695 /*name*/ N_("Boolean"),
696 /*struct_name*/ "BooleanModifierData",
697 /*struct_size*/ sizeof(BooleanModifierData),
698 /*srna*/ &RNA_BooleanModifier,
700 /*flags*/
702 /*icon*/ ICON_MOD_BOOLEAN,
703
704 /*copy_data*/ BKE_modifier_copydata_generic,
705
706 /*deform_verts*/ nullptr,
707 /*deform_matrices*/ nullptr,
708 /*deform_verts_EM*/ nullptr,
709 /*deform_matrices_EM*/ nullptr,
710 /*modify_mesh*/ modify_mesh,
711 /*modify_geometry_set*/ nullptr,
712
713 /*init_data*/ init_data,
714 /*required_data_mask*/ required_data_mask,
715 /*free_data*/ nullptr,
716 /*is_disabled*/ is_disabled,
717 /*update_depsgraph*/ update_depsgraph,
718 /*depends_on_time*/ nullptr,
719 /*depends_on_normals*/ nullptr,
720 /*foreach_ID_link*/ foreach_ID_link,
721 /*foreach_tex_link*/ nullptr,
722 /*free_runtime_data*/ nullptr,
723 /*panel_register*/ panel_register,
724 /*blend_write*/ nullptr,
725 /*blend_read*/ nullptr,
726 /*foreach_cache*/ nullptr,
727 /*foreach_working_space_color*/ nullptr,
728};
729
730} // namespace blender
#define FOREACH_COLLECTION_OBJECT_RECURSIVE_END
#define FOREACH_COLLECTION_OBJECT_RECURSIVE_BEGIN(_collection, _object)
General operations, lookup, etc. for materials.
#define SCOPED_TIMER(name)
Definition BLI_timeit.hh:64
#define IFACE_(msgid)
Object is a sort of wrapper for general info.
Read Blender memory allocation and freeing.
#define UI_ITEM_NONE
#define INIT_DEFAULT_STRUCT_AFTER(struct_dst, member)
#define BM_elem_flag_test(ele, hflag)
#define BM_elem_flag_enable(ele, hflag)
#define BM_ITER_MESH(ele, iter, bm, itype)
#define BMALLOC_TEMPLATE_FROM_ME(...)
#define CD_MASK_MDEFORMVERT
#define CD_MASK_MTFACE
Array(Allocator allocator={}) noexcept
Definition BLI_array.hh:78
const T * data() const
Definition BLI_array.hh:323
constexpr IndexRange()=default
constexpr MutableSpan()=default
constexpr IndexRange index_range() const
Definition BLI_span.hh:676
void append(const T &value)
Mesh * mesh_boolean(Span< const Mesh * > meshes, Span< float4x4 > transforms, Span< Array< short > > material_remaps, BooleanOpParameters op_params, Solver solver, Vector< int > *r_intersecting_edges, BooleanError *r_error)
void debug_randomize_mesh_order(Mesh *mesh)
Definition randomize.cc:305
BMesh Iterators.
int CustomData_get_offset(const CustomData *data, eCustomDataType type)
static int bm_face_isect_pair(BMFace *f, void *)
int RNA_enum_get(PointerRNA *ptr, const char *name)
void BKE_modifier_set_error(const Object *ob, ModifierData *md, const char *format,...) ATTR_PRINTF_FORMAT(3
@ eBooleanModifierFlag_Collection
@ eBooleanModifierFlag_HoleTolerant
PointerRNA * modifier_panel_get_property_pointers(Panel *panel, PointerRNA *r_ob_ptr)
void BM_mesh_free(BMesh *bm)
BMesh Free Mesh.
void * MEM_new_array_uninitialized(size_t len, size_t size, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1
void negate_m3(float R[3][3])
void copy_m3_m4(float m1[3][3], const float m2[4][4])
static void BMD_mesh_intersection(BMesh *bm, ModifierData *md, const ModifierEvalContext *ctx, Mesh *mesh_operand_ob, Object *object, Object *operand_ob, bool is_flip)
bool invert_m4_m4(float inverse[4][4], const float mat[4][4])
static void init_data(ModifierData *md)
void(*)(void *user_data, Object *ob, ID **idpoin, LibraryForeachIDCallbackFlag cb_flag) IDWalkFunc
static void update_depsgraph(tGraphSliderOp *gso)
static void foreach_ID_link(ModifierData *md, Object *ob, IDWalkFunc walk, void *user_data)
void BKE_mesh_wrapper_ensure_mdata(Mesh *mesh)
bool is_negative_m4(const float mat[4][4])
void mul_m4_m4m4(float R[4][4], const float A[4][4], const float B[4][4])
void DEG_add_object_relation(DepsNodeHandle *node_handle, Object *object, eDepsObjectComponentType component, const char *description)
MatBase< float, 4, 4 > float4x4
static BMesh * BMD_mesh_bm_create(Mesh *mesh, Object *object, Mesh *mesh_operand_ob, Object *operand_ob, bool *r_is_flip)
const char * BKE_id_name(const ID &id)
void DEG_add_collection_geometry_relation(DepsNodeHandle *node_handle, Collection *collection, const char *description)
void DEG_add_depends_on_transform_relation(DepsNodeHandle *node_handle, const char *description)
@ eBooleanModifierBMeshFlag_BMesh_NoDissolve
@ eBooleanModifierBMeshFlag_BMesh_Separate
@ eBooleanModifierBMeshFlag_BMesh_NoConnectRegions
@ LIB_ID_COPY_LOCALIZE
@ eBooleanModifierOp_Difference
static void required_data_mask(ModifierData *, CustomData_MeshMasks *r_cddata_masks)
Global G
Definition blender.cc:57
void BM_mesh_bm_from_me(BMesh *bm, const Mesh *mesh, const BMeshFromMeshParams *params)
Mesh -> BMesh.
void mul_transposed_m3_v3(const float M[3][3], float r[3])
void mul_m4_v3(const float M[4][4], float r[3])
Mesh * BKE_modifier_get_evaluated_mesh_from_evaluated_object(Object *ob_eval)
void modifier_error_message_draw(ui::Layout &layout, PointerRNA *ptr)
bool BM_mesh_intersect(BMesh *bm, const Span< std::array< BMLoop *, 3 > > looptris, int(*test_fn)(BMFace *f, void *user_data), void *user_data, const bool use_self, const bool use_separate, const bool use_dissolve, const bool use_island_connect, const bool use_partial_connect, const bool use_edge_tag, const int boolean_mode, const float eps)
void BKE_object_material_remap_calc(Object *ob_dst, Object *ob_src, short *remap_src_to_dst)
static void panel_register(ARegionType *region_type)
bool BKE_collection_is_empty(const Collection *collection)
Mesh * BKE_mesh_new_nomain(int verts_num, int edges_num, int faces_num, int corners_num)
@ eBooleanModifierMaterialMode_Transfer
@ eBooleanModifierMaterialMode_Index
void BM_mesh_calc_tessellation_beauty(BMesh *bm, MutableSpan< std::array< BMLoop *, 3 > > looptris)
constexpr size_t ARRAY_SIZE(const T(&arg)[N]) noexcept
static void solver_options_panel_draw(const bContext *, Panel *panel)
static Mesh * modify_mesh(ModifierData *md, const ModifierEvalContext *ctx, Mesh *mesh)
Definition MOD_array.cc:873
MINLINE int poly_to_tri_count(int poly_count, int corner_count)
@ eModifierTypeFlag_SupportsEditmode
@ eModifierTypeFlag_AcceptsMesh
bool invert_m3(float mat[3][3])
MINLINE float normalize_v3(float n[3])
void BM_face_normal_flip_ex(BMesh *bm, BMFace *f, const int cd_loop_mdisp_offset, const bool use_loop_mdisp_flip)
Face Flip Normal.
Mesh * BKE_mesh_from_bmesh_for_eval_nomain(BMesh *bm, const CustomData_MeshMasks *cd_mask_extra, const Mesh *me_settings)
Material * BKE_object_material_get_eval(Object *ob, short act)
PanelType * modifier_panel_register(ARegionType *region_type, ModifierType type, PanelDrawFn draw)
static void panel_draw(const bContext *, Panel *panel)
static bool BMD_error_messages(const Object *ob, ModifierData *md)
void BM_mesh_copy_init_customdata_from_mesh_array(BMesh *bm_dst, const Mesh *me_src_array[], const int me_src_array_len, const BMAllocTemplate *allocsize)
PanelType * modifier_subpanel_register(ARegionType *region_type, const char *name, const char *label, PanelDrawFn draw_header, PanelDrawFn draw, PanelType *parent)
void BM_mesh_bm_to_me(Main *bmain, BMesh *bm, Mesh *mesh, const BMeshToMeshParams *params)
ID * BKE_id_copy_ex(Main *bmain, const ID *id, ID **new_id_p, int flag)
Definition lib_id.cc:851
static bool is_disabled(const Scene *, ModifierData *md, bool)
ModifierTypeInfo modifierType_Boolean
BMesh * BM_mesh_create(const BMAllocTemplate *allocsize, const BMeshCreateParams *params)
BMesh Make Mesh.
@ eBooleanModifierSolver_Mesh_Arr
@ eBooleanModifierSolver_Manifold
static Mesh * get_quick_mesh(Object *ob_self, Mesh *mesh_self, Object *ob_operand_ob, Mesh *mesh_operand_ob, int operation)
void BKE_modifier_copydata_generic(const ModifierData *md, ModifierData *md_dst, int flag)
BooleanModifierBMeshFlag bm_flag
ui::Layout * layout
void use_property_split_set(bool is_sep)
void prop(PointerRNA *ptr, PropertyRNA *prop, int index, int value, eUI_Item_Flag flag, std::optional< StringRef > name_opt, int icon, std::optional< StringRef > placeholder=std::nullopt)
Layout & column(bool align)
#define N_(msgid)