Blender V5.3
node_geo_split_to_instances.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
8#include "GEO_randomize.hh"
9
10#include "BKE_curves.hh"
11#include "BKE_instances.hh"
12#include "BKE_pointcloud.hh"
13
14#include "NOD_rna_define.hh"
15
17#include "UI_resources.hh"
18
19#include "RNA_enum_types.hh"
20
21#include "BLI_array_utils.hh"
22
24
26{
27 b.add_input<decl::Geometry>("Geometry"_ustr)
28 .supported_type({GeometryComponent::Type::Mesh,
32 .description("Geometry to split into instances");
33 b.add_input<decl::Bool>("Selection"_ustr)
34 .default_value(true)
35 .evaluated_geometry_field()
36 .hide_value();
37 b.add_input<decl::Int>("Group ID"_ustr).evaluated_geometry_field().hide_value();
38 b.add_output<decl::Geometry>("Instances"_ustr)
39 .propagate_all_geometry()
40 .description("All geometry groups as separate instances");
41 b.add_output<decl::Int>("Group ID"_ustr)
42 .anonymous_attribute_output()
43 .description("The group ID of each group instance");
44}
45
46static void node_layout(ui::Layout &layout, bContext * /*C*/, PointerRNA *ptr)
47{
48 layout.use_property_split_set(true);
49 layout.use_property_decorate_set(false);
50 layout.prop(ptr, "domain", UI_ITEM_NONE, "", ICON_NONE);
51}
52
53static void ensure_group_geometries(Map<int, std::unique_ptr<GeometrySet>> &geometry_by_group_id,
54 const Span<int> group_ids)
55{
56 for (const int group_id : group_ids) {
57 geometry_by_group_id.lookup_or_add_cb(group_id,
58 []() { return std::make_unique<GeometrySet>(); });
59 }
60}
61
63 std::optional<bke::GeometryFieldContext> field_context;
64 std::optional<FieldEvaluator> field_evaluator;
65
67
70};
71
75[[nodiscard]] static bool do_common_split(
76 const GeometryComponent &src_component,
77 const AttrDomain domain,
78 const Field<bool> &selection_field,
79 const Field<int> &group_id_field,
80 Map<int, std::unique_ptr<GeometrySet>> &geometry_by_group_id,
81 SplitGroups &r_groups)
82{
83 const int domain_size = src_component.attribute_domain_size(domain);
84
85 r_groups.field_context.emplace(src_component, domain);
86 FieldEvaluator &field_evaluator = r_groups.field_evaluator.emplace(*r_groups.field_context,
87 domain_size);
88 field_evaluator.set_selection(selection_field);
89 field_evaluator.add(group_id_field);
90 field_evaluator.evaluate();
91
92 const IndexMask selection = field_evaluator.get_evaluated_selection_as_mask();
93 if (selection.is_empty()) {
94 return true;
95 }
96
97 const VArray<int> group_ids = field_evaluator.get_evaluated<int>(0);
98 r_groups.group_masks = IndexMask::from_group_ids(selection, group_ids, r_groups.memory);
99 r_groups.group_ids.reinitialize(r_groups.group_masks.size());
100 for (const int group : r_groups.group_masks.index_range()) {
101 r_groups.group_ids[group] = group_ids[r_groups.group_masks[group].first()];
102 }
103
104 ensure_group_geometries(geometry_by_group_id, r_groups.group_ids);
105 return false;
106}
107
108static void split_mesh_groups(const MeshComponent &component,
109 const AttrDomain domain,
110 const Field<bool> &selection_field,
111 const Field<int> &group_id_field,
112 const AttributeFilter &attribute_filter,
113 Map<int, std::unique_ptr<GeometrySet>> &geometry_by_group_id)
114{
115 SplitGroups split_groups;
116 if (do_common_split(
117 component, domain, selection_field, group_id_field, geometry_by_group_id, split_groups))
118 {
119 return;
120 }
121 const Mesh &src_mesh = *component.get();
122 const int domain_size = component.attribute_domain_size(domain);
123
124 threading::EnumerableThreadSpecific<Array<bool>> group_selection_per_thread{
125 [&]() { return Array<bool>(domain_size, false); }};
126
127 threading::parallel_for(split_groups.group_masks.index_range(), 16, [&](const IndexRange range) {
128 /* Need task isolation because of the thread local variable. */
129 threading::isolate_task([&]() {
130 MutableSpan<bool> group_selection = group_selection_per_thread.local();
131 const VArray<bool> group_selection_varray = VArray<bool>::from_span(group_selection);
132 for (const int group_index : range) {
133 const IndexMask &mask = split_groups.group_masks[group_index];
134 index_mask::masked_fill(group_selection, true, mask);
135 const int group_id = split_groups.group_ids[group_index];
136
137 /* Using #mesh_copy_selection here is not ideal, because it can lead to O(n^2) behavior
138 * when there are many groups. */
139 std::optional<Mesh *> group_mesh_opt = geometry::mesh_copy_selection(
140 src_mesh, group_selection_varray, domain, attribute_filter);
141 GeometrySet &group_geometry = *geometry_by_group_id.lookup(group_id);
142 if (group_mesh_opt.has_value()) {
143 if (Mesh *group_mesh = *group_mesh_opt) {
144 group_geometry.replace_mesh(group_mesh);
145 }
146 else {
147 group_geometry.replace_mesh(nullptr);
148 }
149 }
150 else {
151 group_geometry.add(component);
152 }
153
154 index_mask::masked_fill(group_selection, false, mask);
155 }
156 });
157 });
158}
159
160static void split_pointcloud_groups(const PointCloudComponent &component,
161 const Field<bool> &selection_field,
162 const Field<int> &group_id_field,
163 const AttributeFilter &attribute_filter,
164 Map<int, std::unique_ptr<GeometrySet>> &geometry_by_group_id)
165{
166 SplitGroups split_groups;
167 if (do_common_split(component,
168 AttrDomain::Point,
169 selection_field,
170 group_id_field,
171 geometry_by_group_id,
172 split_groups))
173 {
174 return;
175 }
176 const PointCloud &src_pointcloud = *component.get();
177 threading::parallel_for(split_groups.group_ids.index_range(), 16, [&](const IndexRange range) {
178 for (const int group_index : range) {
179 const IndexMask &mask = split_groups.group_masks[group_index];
180 const int group_id = split_groups.group_ids[group_index];
181
182 PointCloud *group_pointcloud = BKE_pointcloud_new_nomain(src_pointcloud.type, mask.size());
183
184 const AttributeAccessor src_attributes = src_pointcloud.attributes();
185 MutableAttributeAccessor dst_attributes = group_pointcloud->attributes_for_write();
186 bke::gather_attributes(src_attributes,
187 AttrDomain::Point,
188 AttrDomain::Point,
189 attribute_filter,
190 mask,
191 dst_attributes);
192
193 GeometrySet &group_geometry = *geometry_by_group_id.lookup(group_id);
194 group_geometry.replace_pointcloud(group_pointcloud);
195 }
196 });
197}
198
199static void split_curve_groups(const bke::CurveComponent &component,
200 const AttrDomain domain,
201 const Field<bool> &selection_field,
202 const Field<int> &group_id_field,
203 const AttributeFilter &attribute_filter,
204 Map<int, std::unique_ptr<GeometrySet>> &geometry_by_group_id)
205{
206 SplitGroups split_groups;
207 if (do_common_split(
208 component, domain, selection_field, group_id_field, geometry_by_group_id, split_groups))
209 {
210 return;
211 }
212 const bke::CurvesGeometry &src_curves = component.get()->geometry.wrap();
213 threading::parallel_for(split_groups.group_ids.index_range(), 16, [&](const IndexRange range) {
214 for (const int group_index : range) {
215 const IndexMask &mask = split_groups.group_masks[group_index];
216 const int group_id = split_groups.group_ids[group_index];
217
218 bke::CurvesGeometry group_curves;
219 if (domain == AttrDomain::Point) {
220 group_curves = bke::curves_copy_point_selection(src_curves, mask, attribute_filter);
221 }
222 else {
223 group_curves = bke::curves_copy_curve_selection(src_curves, mask, attribute_filter);
224 }
225 Curves *group_curves_id = bke::curves_new_nomain(std::move(group_curves));
226 GeometrySet &group_geometry = *geometry_by_group_id.lookup(group_id);
227 group_geometry.replace_curves(group_curves_id);
228 }
229 });
230}
231
232static void split_instance_groups(const InstancesComponent &component,
233 const Field<bool> &selection_field,
234 const Field<int> &group_id_field,
235 const AttributeFilter &attribute_filter,
236 Map<int, std::unique_ptr<GeometrySet>> &geometry_by_group_id)
237{
238 SplitGroups split_groups;
239 if (do_common_split(component,
240 AttrDomain::Instance,
241 selection_field,
242 group_id_field,
243 geometry_by_group_id,
244 split_groups))
245 {
246 return;
247 }
248 const bke::Instances &src_instances = *component.get();
249 threading::parallel_for(split_groups.group_ids.index_range(), 16, [&](const IndexRange range) {
250 for (const int group_index : range) {
251 const IndexMask &mask = split_groups.group_masks[group_index];
252 const int group_id = split_groups.group_ids[group_index];
253
254 auto group_instances = std::make_unique<bke::Instances>(mask.size());
255
256 for (const bke::InstanceReference &reference : src_instances.references()) {
257 group_instances->add_reference(reference);
258 }
259
260 bke::gather_attributes(src_instances.attributes(),
261 AttrDomain::Instance,
262 AttrDomain::Instance,
263 attribute_filter,
264 mask,
265 group_instances->attributes_for_write());
266 group_instances->remove_unused_references();
267
268 GeometrySet &group_geometry = *geometry_by_group_id.lookup(group_id);
269 group_geometry.replace_instances(group_instances.release());
270 }
271 });
272}
273
275{
276 const bNode &node = params.node();
277 const AttrDomain domain = AttrDomain(node.custom1);
278
279 GeometrySet src_geometry = params.extract_input<GeometrySet>("Geometry"_ustr);
280 const Field<bool> selection_field = params.extract_input<Field<bool>>("Selection"_ustr);
281 const Field<int> group_id_field = params.extract_input<Field<int>>("Group ID"_ustr);
282
283 const NodeAttributeFilter &attribute_filter = params.get_attribute_filter("Instances"_ustr);
284
285 Map<int, std::unique_ptr<GeometrySet>> geometry_by_group_id;
286
287 if (src_geometry.has_mesh() &&
288 ELEM(domain, AttrDomain::Point, AttrDomain::Edge, AttrDomain::Face))
289 {
290 const auto &component = *src_geometry.get_component<MeshComponent>();
291 split_mesh_groups(component,
292 domain,
293 selection_field,
294 group_id_field,
295 attribute_filter,
296 geometry_by_group_id);
297 }
298 if (src_geometry.has_pointcloud() && domain == AttrDomain::Point) {
299 const auto &component = *src_geometry.get_component<PointCloudComponent>();
301 component, selection_field, group_id_field, attribute_filter, geometry_by_group_id);
302 }
303 if (src_geometry.has_curves() && ELEM(domain, AttrDomain::Point, AttrDomain::Curve)) {
304 const auto &component = *src_geometry.get_component<bke::CurveComponent>();
305 split_curve_groups(component,
306 domain,
307 selection_field,
308 group_id_field,
309 attribute_filter,
310 geometry_by_group_id);
311 }
312 if (src_geometry.has_instances() && domain == AttrDomain::Instance) {
313 const auto &component = *src_geometry.get_component<bke::InstancesComponent>();
315 component, selection_field, group_id_field, attribute_filter, geometry_by_group_id);
316 }
317
318 auto dst_instances = std::make_unique<bke::Instances>(geometry_by_group_id.size());
319
320 std::optional<std::string> dst_group_id_attribute_id =
321 params.get_output_anonymous_attribute_id_if_needed("Group ID"_ustr);
322 if (dst_group_id_attribute_id) {
323 SpanAttributeWriter<int> dst_group_id =
324 dst_instances->attributes_for_write().lookup_or_add_for_write_span<int>(
325 *dst_group_id_attribute_id, AttrDomain::Instance);
326 std::copy(geometry_by_group_id.keys().begin(),
327 geometry_by_group_id.keys().end(),
328 dst_group_id.span.begin());
329 dst_group_id.finish();
330 }
331
332 dst_instances->transforms_for_write().fill(float4x4::identity());
333 array_utils::fill_index_range(dst_instances->reference_handles_for_write());
334
335 for (auto item : geometry_by_group_id.items()) {
336 std::unique_ptr<GeometrySet> &group_geometry = item.value;
337 dst_instances->add_reference(std::move(group_geometry));
338 }
339
340 geometry::debug_randomize_instance_order(dst_instances.get());
341
342 GeometrySet dst_geometry = GeometrySet::from_instances(std::move(dst_instances));
343 dst_geometry.set_name(src_geometry.name());
344 dst_geometry.copy_bundle_from(src_geometry);
345
346 params.set_output("Instances"_ustr, std::move(dst_geometry));
347}
348
349static void node_rna(StructRNA *srna)
350{
352 "domain",
353 "Domain",
354 "Attribute domain for the Selection and Group ID inputs",
357 int(AttrDomain::Point));
358}
359
360static void node_register()
361{
362 static bke::bNodeType ntype;
363 geo_node_type_base(&ntype, "GeometryNodeSplitToInstances"_ustr, GEO_NODE_SPLIT_TO_INSTANCES);
364 ntype.ui_name = "Split to Instances";
365 ntype.ui_description = "Create separate geometries containing the elements from the same group";
366 ntype.enum_name_legacy = "Split to Instances";
369 ntype.declare = node_declare;
372
373 node_rna(ntype.rna_ext.srna);
374}
375NOD_REGISTER_NODE(node_register)
376
377} // namespace blender::nodes::node_geo_split_to_instances_cc
Low-level operations for curves.
#define NODE_CLASS_GEOMETRY
Definition BKE_node.hh:492
#define GEO_NODE_SPLIT_TO_INSTANCES
General operations for point clouds.
#define NOD_REGISTER_NODE(REGISTER_FUNC)
#define NOD_inline_enum_accessors(member)
#define UI_ITEM_NONE
#define ELEM(...)
IndexRange index_range() const
Definition BLI_array.hh:371
void reinitialize(const int64_t new_size)
Definition BLI_array.hh:430
static Vector< IndexMask, 4 > from_group_ids(const VArray< int > &group_ids, LinearAllocator<> &memory)
SubIterator begin() const
Definition BLI_map.hh:768
SubIterator end() const
Definition BLI_map.hh:778
int64_t size() const
Definition BLI_map.hh:976
KeyIterator keys() const &
Definition BLI_map.hh:875
ItemIterator items() const &
Definition BLI_map.hh:902
int attribute_domain_size(AttrDomain domain) const
void set_selection(Field< bool > selection)
int add(GField field, GVArray *varray_ptr)
IndexMask get_evaluated_selection_as_mask() const
const GVArray & get_evaluated(const int field_index) const
NodeAttributeFilter get_attribute_filter(const UString output_identifier) 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 fill_index_range(MutableSpan< T > span, const T start=0)
void node_register_type(bNodeType &ntype)
Definition node.cc:2920
void debug_randomize_instance_order(bke::Instances *instances)
Definition randomize.cc:316
static void node_declare(NodeDeclarationBuilder &b)
static void node_layout(ui::Layout &layout, bContext *, PointerRNA *ptr)
static void split_pointcloud_groups(const PointCloudComponent &component, const Field< bool > &selection_field, const Field< int > &group_id_field, const AttributeFilter &attribute_filter, Map< int, std::unique_ptr< GeometrySet > > &geometry_by_group_id)
static bool do_common_split(const GeometryComponent &src_component, const AttrDomain domain, const Field< bool > &selection_field, const Field< int > &group_id_field, Map< int, std::unique_ptr< GeometrySet > > &geometry_by_group_id, SplitGroups &r_groups)
static void split_mesh_groups(const MeshComponent &component, const AttrDomain domain, const Field< bool > &selection_field, const Field< int > &group_id_field, const AttributeFilter &attribute_filter, Map< int, std::unique_ptr< GeometrySet > > &geometry_by_group_id)
static void split_instance_groups(const InstancesComponent &component, const Field< bool > &selection_field, const Field< int > &group_id_field, const AttributeFilter &attribute_filter, Map< int, std::unique_ptr< GeometrySet > > &geometry_by_group_id)
static void ensure_group_geometries(Map< int, std::unique_ptr< GeometrySet > > &geometry_by_group_id, const Span< int > group_ids)
static void split_curve_groups(const bke::CurveComponent &component, const AttrDomain domain, const Field< bool > &selection_field, const Field< int > &group_id_field, const AttributeFilter &attribute_filter, Map< int, std::unique_ptr< GeometrySet > > &geometry_by_group_id)
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 parallel_for(const IndexRange range, const int64_t grain_size, const Function &function, const TaskSizeHints &size_hints=detail::TaskSizeHints_Static(1))
Definition BLI_task.hh:69
const EnumPropertyItem rna_enum_attribute_domain_without_corner_items[]
void geo_node_type_base(bke::bNodeType *ntype, UString idname, const std::optional< int16_t > legacy_type)
StringRefNull name() const
void set_name(std::string name)
const GeometryComponent * get_component(GeometryComponent::Type component_type) const
void copy_bundle_from(const GeometrySet &other)
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
const char * enum_name_legacy
Definition BKE_node.hh:274
NodeDeclareFunction declare
Definition BKE_node.hh:393
static GeometrySet from_instances(std::unique_ptr< Instances > instances)
void use_property_decorate_set(bool is_decorate)
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)