Blender V5.3
node_geo_boolean.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2023 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
6#include "BKE_instances.hh"
7
8#include "DNA_mesh_types.h"
9#include "DNA_object_types.h"
10
11#include "NOD_rna_define.hh"
12
14#include "UI_resources.hh"
15
17#include "GEO_mesh_boolean.hh"
18#include "GEO_randomize.hh"
19
20#include "node_geometry_util.hh"
21
22#include <fmt/format.h>
23
25
27{
28 const bNode *node = b.node_or_null();
29
30 auto &first_geometry = b.add_input<decl::Geometry>("Mesh 1"_ustr)
31 .only_realized_data()
32 .supported_type(GeometryComponent::Type::Mesh)
33 .description("Base mesh to subtract geometry from");
34
35 if (node != nullptr) {
36 switch (geometry::boolean::Operation(node->custom1)) {
39 b.add_input<decl::Geometry>("Mesh"_ustr, "Mesh 2"_ustr)
40 .supported_type(GeometryComponent::Type::Mesh)
41 .multi_input()
42 .description("Meshes to union or intersect");
43 break;
45 b.add_input<decl::Geometry>("Mesh 2"_ustr)
46 .supported_type(GeometryComponent::Type::Mesh)
47 .multi_input()
48 .description("Mesh that is subtracted from the first mesh");
49 break;
50 }
51 }
52
53 auto make_mesh_arr = [](bNode &node) {
55 };
56 auto &self_intersect =
57 b.add_input<decl::Bool>("Self Intersection"_ustr).make_available(make_mesh_arr);
58 auto &hole_tolerant =
59 b.add_input<decl::Bool>("Hole Tolerant"_ustr).make_available(make_mesh_arr);
60 b.add_output<decl::Geometry>("Mesh"_ustr).propagate_all_geometry();
61 auto &output_edges = b.add_output<decl::Bool>("Intersecting Edges"_ustr)
62 .anonymous_attribute_output()
63 .make_available(make_mesh_arr);
64
65 if (node != nullptr) {
66 const auto operation = geometry::boolean::Operation(node->custom1);
67 const auto solver = geometry::boolean::Solver(node->custom2);
68
69 output_edges.available(
71 self_intersect.available(solver == geometry::boolean::Solver::MeshArr);
72 hole_tolerant.available(solver == geometry::boolean::Solver::MeshArr);
73
74 switch (operation) {
77 first_geometry.available(false);
78 break;
80 break;
81 }
82 }
83}
84
85static void node_layout(ui::Layout &layout, bContext * /*C*/, PointerRNA *ptr)
86{
87 layout.prop(ptr, "operation", UI_ITEM_NONE, "", ICON_NONE);
88 layout.prop(ptr, "solver", UI_ITEM_NONE, "", ICON_NONE);
89}
90
92 std::optional<std::string> intersecting_edges_id;
93};
94
100
102{
103 Array<short> map(mesh.totcol);
104 for (const int i : IndexRange(mesh.totcol)) {
105 Material *material = mesh.mat[i];
106 map[i] = material ? all_materials.index_of_or_add(material) : -1;
107 }
108 return map;
109}
110
112{
115 bool use_self = false;
116 bool hole_tolerant = false;
118 use_self = params.extract_input<bool>("Self Intersection"_ustr);
119 hole_tolerant = params.extract_input<bool>("Hole Tolerant"_ustr);
120 }
121
123 Vector<float4x4> transforms;
124 VectorSet<Material *> materials;
125 Vector<Array<short>> material_remaps;
126
127 GeometrySet set_a;
129 set_a = params.extract_input<GeometrySet>("Mesh 1"_ustr);
130 /* Note that it technically wouldn't be necessary to realize the instances for the first
131 * geometry input, but the boolean code expects the first shape for the difference operation
132 * to be a single mesh. */
133 if (const Mesh *mesh_in_a = set_a.get_mesh()) {
134 meshes.append(mesh_in_a);
135 transforms.append(float4x4::identity());
136 if (mesh_in_a->totcol == 0) {
137 /* Necessary for faces using the default material when there are no material slots. */
138 materials.add(nullptr);
139 }
140 else {
141 materials.add_multiple({mesh_in_a->mat, mesh_in_a->totcol});
142 }
143 material_remaps.append({});
144 }
145 }
146
147 GeoNodesMultiInput<GeometrySet> geometry_sets =
148 params.extract_input<GeoNodesMultiInput<GeometrySet>>("Mesh 2"_ustr);
149
150 for (const GeometrySet &geometry : geometry_sets.values) {
151 if (const Mesh *mesh = geometry.get_mesh()) {
152 meshes.append(mesh);
153 transforms.append(float4x4::identity());
154 material_remaps.append(calc_mesh_material_map(*mesh, materials));
155 }
156 if (const bke::Instances *instances = geometry.get_instances()) {
157 const Span<bke::InstanceReference> references = instances->references();
158 const Span<int> handles = instances->reference_handles();
159 const Span<float4x4> instance_transforms = instances->transforms();
160 for (const int i : handles.index_range()) {
161 const bke::InstanceReference &reference = references[handles[i]];
162 switch (reference.type()) {
165 reference.object());
166 if (const Mesh *mesh = object_geometry.get_mesh()) {
167 meshes.append(mesh);
168 transforms.append(instance_transforms[i]);
169 material_remaps.append(calc_mesh_material_map(*mesh, materials));
170 }
171 break;
172 }
174 if (const Mesh *mesh = reference.geometry_set().get_mesh()) {
175 meshes.append(mesh);
176 transforms.append(instance_transforms[i]);
177 material_remaps.append(calc_mesh_material_map(*mesh, materials));
178 }
179 break;
180 }
183 break;
184 }
185 }
186 }
187 }
188
190 /* These solvers remap materials using realize_instances. */
191 material_remaps.resize(0);
192 }
193
194 AttributeOutputs attribute_outputs;
197 "Intersecting Edges"_ustr);
198 }
199
200 Vector<int> intersecting_edges;
202 op_params.boolean_mode = operation;
203 op_params.no_self_intersections = !use_self;
204 op_params.watertight = !hole_tolerant;
205 op_params.no_nested_components = true; /* TODO: make this configurable. */
208 meshes,
209 transforms,
210 material_remaps,
211 op_params,
212 solver,
213 attribute_outputs.intersecting_edges_id ? &intersecting_edges : nullptr,
214 &error);
216 if (!error.non_manifold_mesh_indices.is_empty()) {
217 for (const auto index : error.non_manifold_mesh_indices) {
218 params.error_message_add(
220 fmt::format(fmt::runtime(TIP_("Input {} was not manifold")), index));
221 }
222 }
223 else {
224 params.error_message_add(NodeWarningType::Error, TIP_("An input was not manifold"));
225 }
226 }
229 TIP_("Boolean result is too big for solver to handle"));
230 }
233 TIP_("Boolean solver not available (compiled without it)"));
234 }
236 params.error_message_add(NodeWarningType::Error, TIP_("Unknown Boolean error"));
237 }
238 if (!result) {
240 return;
241 }
242
243 MEM_SAFE_DELETE(result->mat);
244 result->mat = MEM_new_array_uninitialized<Material *>(size_t(materials.size()), __func__);
245 result->totcol = materials.size();
246 MutableSpan(result->mat, result->totcol).copy_from(materials);
247
248 /* Store intersecting edges in attribute. */
249 if (attribute_outputs.intersecting_edges_id) {
250 MutableAttributeAccessor attributes = result->attributes_for_write();
252 *attribute_outputs.intersecting_edges_id, AttrDomain::Edge);
253
254 selection.span.fill(false);
255 for (const int i : intersecting_edges) {
256 selection.span[i] = true;
257 }
258 selection.finish();
259 }
261
262 Vector<GeometrySet> all_geometries;
263 all_geometries.append(set_a);
264 all_geometries.extend(geometry_sets.values);
265
266 const std::array types_to_join = {GeometryComponent::Type::Edit};
267 GeometrySet result_geometry = geometry::join_geometries(
268 all_geometries, {}, std::make_optional(types_to_join));
269 result_geometry.replace_mesh(result);
270 result_geometry.set_name(set_a.name());
271 for (const GeometrySet &geometry : all_geometries) {
272 result_geometry.merge_bundle_from(geometry);
273 }
274
275 params.set_output("Mesh"_ustr, std::move(result_geometry));
276}
277
278static void node_rna(StructRNA *srna)
279{
280 static const EnumPropertyItem rna_node_geometry_boolean_method_items[] = {
282 "INTERSECT",
283 0,
284 "Intersect",
285 "Keep the part of the mesh that is common between all operands"},
287 "UNION",
288 0,
289 "Union",
290 "Combine meshes in an additive way"},
292 "DIFFERENCE",
293 0,
294 "Difference",
295 "Combine meshes in a subtractive way"},
296 {0, nullptr, 0, nullptr, nullptr},
297 };
298 static const EnumPropertyItem rna_geometry_boolean_solver_items[] = {
300 "EXACT",
301 0,
302 "Exact",
303 "Slower solver with the best results for coplanar faces"},
305 "FLOAT",
306 0,
307 "Float",
308 "Simple solver with good performance, without support for overlapping geometry"},
310 "MANIFOLD",
311 0,
312 "Manifold",
313 "Fastest solver that works only on manifold meshes but gives better results"},
314 {0, nullptr, 0, nullptr, nullptr},
315 };
316
318 "operation",
319 "Operation",
320 "",
321 rna_node_geometry_boolean_method_items,
324
326 "solver",
327 "Solver",
328 "",
329 rna_geometry_boolean_solver_items,
332}
333
334static void node_register()
335{
336 static bke::bNodeType ntype;
337 geo_node_type_base(&ntype, "GeometryNodeMeshBoolean"_ustr, GEO_NODE_MESH_BOOLEAN);
338 ntype.ui_name = "Mesh Boolean";
339 ntype.ui_description = "Cut, subtract, or join multiple mesh inputs";
340 ntype.enum_name_legacy = "MESH_BOOLEAN";
342 ntype.declare = node_declare;
344 ntype.initfunc = node_init;
347
348 node_rna(ntype.rna_ext.srna);
349}
351
352} // namespace blender::nodes::node_geo_boolean_cc
#define NODE_CLASS_GEOMETRY
Definition BKE_node.hh:492
#define GEO_NODE_MESH_BOOLEAN
#define TIP_(msgid)
Object is a sort of wrapper for general info.
#define NOD_REGISTER_NODE(REGISTER_FUNC)
#define NOD_inline_enum_accessors(member)
#define UI_ITEM_NONE
#define ELEM(...)
constexpr IndexRange()=default
constexpr MutableSpan()=default
constexpr IndexRange index_range() const
Definition BLI_span.hh:405
bool add(const Key &key)
int64_t index_of_or_add(const Key &key)
void add_multiple(Span< Key > keys)
int64_t size() const
void append(const T &value)
bool is_empty() const
void resize(const int64_t new_size)
void extend(Span< T > array)
GSpanAttributeWriter lookup_or_add_for_write_only_span(StringRef name, AttrDomain domain, AttrType data_type)
void error_message_add(const NodeWarningType type, StringRef message) const
std::optional< std::string > get_output_anonymous_attribute_id_if_needed(const UString output_identifier, const bool force_create=false)
T extract_input(const UString identifier)
void set_output(const UString identifier, T &&value)
void make_available(bNode &node) const
void node_register_type(bNodeType &ntype)
Definition node.cc:2920
GeometrySet object_get_evaluated_geometry_set(const Object &object, bool apply_subdiv=true)
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)
bke::GeometrySet join_geometries(Span< bke::GeometrySet > geometries, const bke::AttributeFilter &attribute_filter, const std::optional< Span< bke::GeometryComponent::Type > > &component_types_to_join=std::nullopt, bool allow_merging_instance_references=true)
void debug_randomize_mesh_order(Mesh *mesh)
Definition randomize.cc:305
static void node_init(bNodeTree *, bNode *node)
static Array< short > calc_mesh_material_map(const Mesh &mesh, VectorSet< Material * > &all_materials)
static void node_geo_exec(GeoNodeExecParams params)
static void node_layout(ui::Layout &layout, bContext *, PointerRNA *ptr)
static void node_rna(StructRNA *srna)
static void node_declare(NodeDeclarationBuilder &b)
PropertyRNA * RNA_def_node_enum(StructRNA *srna, const char *identifier, const char *ui_name, const char *ui_description, const EnumPropertyItem *static_items, const EnumRNAAccessors accessors, std::optional< int > default_value, const EnumPropertyItemFunc item_func, const bool allow_animation)
void * MEM_new_array_uninitialized(size_t len, size_t size, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1
void geo_node_type_base(bke::bNodeType *ntype, UString idname, const std::optional< int16_t > legacy_type)
signed short int16_t
Definition BKE_text.h:77
void merge_bundle_from(const GeometrySet &other)
StringRefNull name() const
void set_name(std::string name)
const Mesh * get_mesh() const
void replace_mesh(Mesh *mesh, GeometryOwnershipType ownership=GeometryOwnershipType::Owned)
Defines a node type.
Definition BKE_node.hh:265
void(*) draw_buttons(ui::Layout &, bContext *C, PointerRNA *ptr)
Definition BKE_node.hh:290
std::string ui_description
Definition BKE_node.hh:271
NodeGeometryExecFunction geometry_node_execute
Definition BKE_node.hh:385
void(*) initfunc(bNodeTree *ntree, bNode *node)
Definition BKE_node.hh:320
const char * enum_name_legacy
Definition BKE_node.hh:274
NodeDeclareFunction declare
Definition BKE_node.hh:393
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)