Blender V5.3
extract_elements.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2024 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
10
11#include "BLI_index_mask.hh"
12
13#include "BKE_attribute.hh"
14#include "BKE_curves.hh"
15#include "BKE_geometry_set.hh"
16#include "BKE_grease_pencil.hh"
17#include "BKE_instances.hh"
18#include "BKE_mesh.hh"
19#include "BKE_pointcloud.hh"
20
21namespace blender::geometry {
22
23using bke::AttrDomain;
24
31
33 const IndexMask &mask,
34 const bke::AttributeFilter &attribute_filter)
35{
36 BLI_assert(mask.min_array_size() <= mesh.verts_num);
37 Array<Mesh *> elements(mask.size(), nullptr);
38
39 const bke::AttributeAccessor src_attributes = mesh.attributes();
40
41 Vector<PropagationAttribute> propagation_attributes;
42 src_attributes.foreach_attribute([&](const bke::AttributeIter &iter) {
43 if (iter.data_type == bke::AttrType::String) {
44 return;
45 }
46 if (attribute_filter.allow_skip(iter.name)) {
47 return;
48 }
49 const bke::GAttributeReader src_attribute = iter.get(AttrDomain::Point);
50 if (!src_attribute) {
51 return;
52 }
53 propagation_attributes.append({iter.name, iter.data_type, AttrDomain::Point, *src_attribute});
54 });
55
56 mask.foreach_index(
57 [&](const int vert_i, const int element_i) {
58 Mesh *element = BKE_mesh_new_nomain(1, 0, 0, 0);
60
61 bke::MutableAttributeAccessor element_attributes = element->attributes_for_write();
62
63 for (const PropagationAttribute &src_attribute : propagation_attributes) {
65 src_attribute.name, AttrDomain::Point, src_attribute.data_type);
66 if (!dst) {
67 continue;
68 }
69 src_attribute.data.get(vert_i, dst.span[0]);
70 dst.finish();
71 }
72
73 elements[element_i] = element;
74 },
76
77 return elements;
78}
79
81 const IndexMask &mask,
82 const bke::AttributeFilter &attribute_filter)
83{
84 BLI_assert(mask.min_array_size() <= mesh.edges_num);
85 Array<Mesh *> elements(mask.size(), nullptr);
86
87 const Span<int2> src_edges = mesh.edges();
88 const bke::AttributeAccessor src_attributes = mesh.attributes();
89
90 Vector<PropagationAttribute> propagation_attributes;
91 src_attributes.foreach_attribute([&](const bke::AttributeIter &iter) {
92 if (iter.data_type == bke::AttrType::String) {
93 return;
94 }
95 if (iter.name == ".edge_verts") {
96 return;
97 }
98 if (attribute_filter.allow_skip(iter.name)) {
99 return;
100 }
101 const bke::GAttributeReader src_attribute = iter.get();
102 if (ELEM(src_attribute.domain, AttrDomain::Point, AttrDomain::Edge)) {
103 propagation_attributes.append(
104 {iter.name, iter.data_type, src_attribute.domain, *src_attribute});
105 }
106 else if (src_attribute.domain == AttrDomain::Corner) {
107 if (GVArray adapted_attribute = src_attributes.adapt_domain(
108 *src_attribute, src_attribute.domain, AttrDomain::Point))
109 {
110 propagation_attributes.append(
111 {iter.name, iter.data_type, AttrDomain::Point, adapted_attribute});
112 }
113 }
114 else if (src_attribute.domain == AttrDomain::Face) {
115 if (GVArray adapted_attribute = src_attributes.adapt_domain(
116 *src_attribute, src_attribute.domain, AttrDomain::Edge))
117 {
118 propagation_attributes.append(
119 {iter.name, iter.data_type, AttrDomain::Edge, adapted_attribute});
120 }
121 }
122 });
123
124 mask.foreach_index(
125 [&](const int edge_i, const int element_i) {
126 Mesh *element = BKE_mesh_new_nomain(2, 1, 0, 0);
128
129 MutableSpan<int2> element_edges = element->edges_for_write();
130 element_edges[0] = {0, 1};
131 const int2 &src_edge = src_edges[edge_i];
132
133 bke::MutableAttributeAccessor element_attributes = element->attributes_for_write();
134 for (const PropagationAttribute &src_attribute : propagation_attributes) {
136 src_attribute.name, src_attribute.domain, src_attribute.data_type);
137 if (!dst) {
138 continue;
139 }
140 if (src_attribute.domain == AttrDomain::Point) {
141 src_attribute.data.get(src_edge[0], dst.span[0]);
142 src_attribute.data.get(src_edge[1], dst.span[1]);
143 }
144 else {
145 src_attribute.data.get(edge_i, dst.span[0]);
146 }
147 dst.finish();
148 }
149 elements[element_i] = element;
150 },
152
153 return elements;
154}
155
157 const IndexMask &mask,
158 const bke::AttributeFilter &attribute_filter)
159{
160 BLI_assert(mask.min_array_size() <= mesh.faces_num);
161 Array<Mesh *> elements(mask.size(), nullptr);
162
163 const Span<int> src_corner_verts = mesh.corner_verts();
164 const Span<int> src_corner_edges = mesh.corner_edges();
165 const OffsetIndices<int> src_faces = mesh.faces();
166
167 const bke::AttributeAccessor src_attributes = mesh.attributes();
168
169 Vector<PropagationAttribute> propagation_attributes;
170 src_attributes.foreach_attribute([&](const bke::AttributeIter &iter) {
171 if (iter.data_type == bke::AttrType::String) {
172 return;
173 }
174 if (ELEM(iter.name, ".edge_verts", ".corner_edge", ".corner_vert")) {
175 return;
176 }
177 if (attribute_filter.allow_skip(iter.name)) {
178 return;
179 }
180 const bke::GAttributeReader src_attribute = iter.get();
181 if (!src_attribute) {
182 return;
183 }
184 propagation_attributes.append(
185 {iter.name, iter.data_type, src_attribute.domain, *src_attribute});
186 });
187
188 mask.foreach_index(
189 [&](const int face_i, const int element_i) {
190 const IndexRange src_face = src_faces[face_i];
191 const int verts_num = src_face.size();
192
193 Mesh *element = BKE_mesh_new_nomain(verts_num, verts_num, 1, verts_num);
195
196 MutableSpan<int2> element_edges = element->edges_for_write();
197 MutableSpan<int> element_corner_verts = element->corner_verts_for_write();
198 MutableSpan<int> element_corner_edges = element->corner_edges_for_write();
199 MutableSpan<int> element_face_offsets = element->face_offsets_for_write();
200
201 for (const int i : IndexRange(verts_num)) {
202 element_edges[i] = {i, i + 1};
203 element_corner_verts[i] = i;
204 element_corner_edges[i] = i;
205 }
206 element_edges.last()[1] = 0;
207 element_face_offsets[0] = 0;
208 element_face_offsets[1] = verts_num;
209
210 bke::MutableAttributeAccessor element_attributes = element->attributes_for_write();
211 for (const PropagationAttribute &src_attribute : propagation_attributes) {
213 src_attribute.name, src_attribute.domain, src_attribute.data_type);
214 if (!dst) {
215 continue;
216 }
217 switch (src_attribute.domain) {
218 case AttrDomain::Point: {
219 for (const int i : IndexRange(verts_num)) {
220 const int src_corner_i = src_face[i];
221 const int src_vert_i = src_corner_verts[src_corner_i];
222 src_attribute.data.get(src_vert_i, dst.span[i]);
223 }
224 break;
225 }
226 case AttrDomain::Edge: {
227 for (const int i : IndexRange(verts_num)) {
228 const int src_corner_i = src_face[i];
229 const int src_edge_i = src_corner_edges[src_corner_i];
230 src_attribute.data.get(src_edge_i, dst.span[i]);
231 }
232 break;
233 }
234 case AttrDomain::Corner: {
235 src_attribute.data.materialize_compressed(src_face, dst.span.data());
236 break;
237 }
238 case AttrDomain::Face: {
239 src_attribute.data.get(face_i, dst.span[0]);
240 break;
241 }
242 default:
244 break;
245 }
246 dst.finish();
247 }
248 elements[element_i] = element;
249 },
251
252 return elements;
253}
254
256 const IndexMask &mask,
257 const bke::AttributeFilter &attribute_filter)
258{
259 BLI_assert(mask.min_array_size() <= pointcloud.totpoint);
260 Array<PointCloud *> elements(mask.size(), nullptr);
261
262 const bke::AttributeAccessor src_attributes = pointcloud.attributes();
263
264 mask.foreach_index(
265 [&](const int point_i, const int element_i) {
267 element->totcol = pointcloud.totcol;
268 element->mat = MEM_dupalloc(pointcloud.mat);
269
270 bke::gather_attributes(src_attributes,
271 AttrDomain::Point,
272 AttrDomain::Point,
273 attribute_filter,
274 Span<int>{point_i},
275 element->attributes_for_write());
276 elements[element_i] = element;
277 },
279
280 return elements;
281}
282
284 const IndexMask &mask,
285 const bke::AttributeFilter &attribute_filter)
286{
287 BLI_assert(mask.min_array_size() <= curves.geometry.point_num);
288 Array<Curves *> elements(mask.size(), nullptr);
289
290 const bke::CurvesGeometry &src_curves = curves.geometry.wrap();
291 const bke::AttributeAccessor src_attributes = src_curves.attributes();
292 const Array<int> point_to_curve_map = src_curves.point_to_curve_map();
293
294 mask.foreach_index(
295 [&](const int point_i, const int element_i) {
296 const int curve_i = point_to_curve_map[point_i];
297
298 /* Actual curve type is propagated below. */
301
302 bke::MutableAttributeAccessor element_attributes =
303 element->geometry.wrap().attributes_for_write();
304 bke::gather_attributes(src_attributes,
305 AttrDomain::Point,
306 AttrDomain::Point,
307 attribute_filter,
308 Span<int>{point_i},
309 element_attributes);
310 bke::gather_attributes(src_attributes,
311 AttrDomain::Curve,
312 AttrDomain::Curve,
313 attribute_filter,
314 Span<int>{curve_i},
315 element_attributes);
316 elements[element_i] = element;
317 },
319
320 return elements;
321}
322
324 const IndexMask &mask,
325 const bke::AttributeFilter &attribute_filter)
326{
327 BLI_assert(mask.min_array_size() <= curves.geometry.curve_num);
328 Array<Curves *> elements(mask.size(), nullptr);
329
330 const bke::CurvesGeometry &src_curves = curves.geometry.wrap();
331 const bke::AttributeAccessor src_attributes = src_curves.attributes();
332 const OffsetIndices<int> src_points_by_curve = src_curves.points_by_curve();
333
334 mask.foreach_index(
335 [&](const int curve_i, const int element_i) {
336 const IndexRange src_points = src_points_by_curve[curve_i];
337 const int points_num = src_points.size();
338 Curves *element = bke::curves_new_nomain(points_num, 1);
339 bke::MutableAttributeAccessor element_attributes =
340 element->geometry.wrap().attributes_for_write();
342 bke::gather_attributes(src_attributes,
343 AttrDomain::Point,
344 AttrDomain::Point,
345 attribute_filter,
346 src_points,
347 element_attributes);
348 bke::gather_attributes(src_attributes,
349 AttrDomain::Curve,
350 AttrDomain::Curve,
351 attribute_filter,
352 Span<int>{curve_i},
353 element_attributes);
354 element->geometry.wrap().update_curve_types();
355 elements[element_i] = element;
356 },
358
359 return elements;
360}
361
363 const IndexMask &mask,
364 const bke::AttributeFilter &attribute_filter)
365{
366 using bke::Instances;
367 BLI_assert(mask.min_array_size() <= instances.instances_num());
368 Array<Instances *> elements(mask.size(), nullptr);
369
370 const bke::AttributeAccessor src_attributes = instances.attributes();
371 const Span<bke::InstanceReference> src_references = instances.references();
372 const Span<int> src_reference_handles = instances.reference_handles();
373 const Span<float4x4> src_transforms = instances.transforms();
374
375 mask.foreach_index(
376 [&](const int instance_i, const int element_i) {
377 const int old_handle = src_reference_handles[instance_i];
378 const bke::InstanceReference &old_reference = src_references[old_handle];
379 const float4x4 &old_transform = src_transforms[instance_i];
380
381 Instances *element = new Instances(1);
382 element->reference_handles_for_write().first() = element->add_new_reference(old_reference);
383 element->transforms_for_write().first() = old_transform;
384
385 bke::gather_attributes(src_attributes,
386 AttrDomain::Instance,
387 AttrDomain::Instance,
389 attribute_filter, {".reference_index", "instance_transform"}),
390 Span<int>{instance_i},
391 element->attributes_for_write());
392
393 elements[element_i] = element;
394 },
396
397 return elements;
398}
399
401 const IndexMask &mask,
402 const bke::AttributeFilter &attribute_filter)
403{
404 using namespace bke::greasepencil;
405 BLI_assert(mask.min_array_size() <= grease_pencil.layers().size());
406
407 Array<GreasePencil *> elements(mask.size(), nullptr);
408 const bke::AttributeAccessor src_attributes = grease_pencil.attributes();
409 const Span<const Layer *> src_layers = grease_pencil.layers();
410
411 mask.foreach_index(
412 [&](const int layer_i, const int element_i) {
414 element->material_array = MEM_dupalloc(grease_pencil.material_array);
415 element->material_array_num = grease_pencil.material_array_num;
416
417 const Layer &src_layer = *src_layers[layer_i];
418 const Drawing *src_drawing = grease_pencil.get_eval_drawing(src_layer);
419
420 if (src_drawing) {
421 Layer &new_layer = element->add_layer(src_layer.name());
422 Drawing &drawing = *element->insert_frame(new_layer, element->runtime->eval_frame);
423 drawing.strokes_for_write() = src_drawing->strokes();
424
425 bke::gather_attributes(src_attributes,
426 AttrDomain::Layer,
427 AttrDomain::Layer,
428 attribute_filter,
429 Span<int>{layer_i},
430 element->attributes_for_write());
431 }
432
433 elements[element_i] = element;
434 },
436
437 return elements;
438}
439
442 int layer_i,
443 const IndexMask &mask,
444 const bke::AttributeFilter &attribute_filter)
445{
446 using namespace bke::greasepencil;
447 const Layer &src_layer = grease_pencil.layer(layer_i);
448 const Drawing &src_drawing = *grease_pencil.get_eval_drawing(src_layer);
449 const bke::CurvesGeometry &src_curves = src_drawing.strokes();
450 const bke::AttributeAccessor src_layer_attributes = grease_pencil.attributes();
451 const bke::AttributeAccessor src_curves_attributes = src_curves.attributes();
452 const Array<int> point_to_curve_map = src_curves.point_to_curve_map();
453
454 Array<GreasePencil *> elements(mask.size(), nullptr);
455 mask.foreach_index(
456 [&](const int point_i, const int element_i) {
457 const int curve_i = point_to_curve_map[point_i];
458
460 element->material_array = MEM_dupalloc(grease_pencil.material_array);
461 element->material_array_num = grease_pencil.material_array_num;
462
463 Layer &new_layer = element->add_layer(src_layer.name());
464 Drawing &drawing = *element->insert_frame(new_layer, element->runtime->eval_frame);
465 bke::CurvesGeometry &new_curves = drawing.strokes_for_write();
466 new_curves.resize(1, 1);
467 new_curves.offsets_for_write().last() = 1;
468
469 bke::gather_attributes(src_curves_attributes,
470 AttrDomain::Point,
471 AttrDomain::Point,
472 attribute_filter,
473 Span<int>{point_i},
474 new_curves.attributes_for_write());
475 bke::gather_attributes(src_curves_attributes,
476 AttrDomain::Curve,
477 AttrDomain::Curve,
478 attribute_filter,
479 Span<int>{curve_i},
480 new_curves.attributes_for_write());
481 bke::gather_attributes(src_layer_attributes,
482 AttrDomain::Layer,
483 AttrDomain::Layer,
484 attribute_filter,
485 Span<int>{layer_i},
486 element->attributes_for_write());
487
488 new_curves.update_curve_types();
489
490 elements[element_i] = element;
491 },
493
494 return elements;
495}
496
499 const int layer_i,
500 const IndexMask &mask,
501 const bke::AttributeFilter &attribute_filter)
502{
503 using namespace bke::greasepencil;
504 const Layer &src_layer = grease_pencil.layer(layer_i);
505 const Drawing &src_drawing = *grease_pencil.get_eval_drawing(src_layer);
506 const bke::CurvesGeometry &src_curves = src_drawing.strokes();
507 const bke::AttributeAccessor src_layer_attributes = grease_pencil.attributes();
508 const bke::AttributeAccessor src_curves_attributes = src_curves.attributes();
509 const OffsetIndices<int> src_points_by_curve = src_curves.points_by_curve();
510
511 Array<GreasePencil *> elements(mask.size(), nullptr);
512 mask.foreach_index(
513 [&](const int curve_i, const int element_i) {
514 const IndexRange src_points = src_points_by_curve[curve_i];
515 const int points_num = src_points.size();
516
518 element->material_array = MEM_dupalloc(grease_pencil.material_array);
519 element->material_array_num = grease_pencil.material_array_num;
520
521 Layer &new_layer = element->add_layer(src_layer.name());
522 Drawing &drawing = *element->insert_frame(new_layer, element->runtime->eval_frame);
523 bke::CurvesGeometry &new_curves = drawing.strokes_for_write();
524
525 new_curves.resize(points_num, 1);
526 bke::gather_attributes(src_curves_attributes,
527 AttrDomain::Point,
528 AttrDomain::Point,
529 attribute_filter,
530 src_points,
531 new_curves.attributes_for_write());
532 bke::gather_attributes(src_curves_attributes,
533 AttrDomain::Curve,
534 AttrDomain::Curve,
535 attribute_filter,
536 Span<int>{curve_i},
537 new_curves.attributes_for_write());
538 bke::gather_attributes(src_layer_attributes,
539 AttrDomain::Layer,
540 AttrDomain::Layer,
541 attribute_filter,
542 Span<int>{layer_i},
543 element->attributes_for_write());
544
545 new_curves.update_curve_types();
546 elements[element_i] = element;
547 },
549
550 return elements;
551}
552
553} // namespace blender::geometry
Low-level operations for curves.
Low-level operations for grease pencil.
General operations for point clouds.
#define BLI_assert_unreachable()
#define ELEM(...)
constexpr int64_t size() const
constexpr IndexRange()=default
constexpr T & last(const int64_t n=0) const
Definition BLI_span.hh:695
constexpr const T * data() const
Definition BLI_span.hh:219
void append(const T &value)
void foreach_attribute(const FunctionRef< void(const AttributeIter &)> fn) const
GVArray adapt_domain(const GVArray &varray, const AttrDomain from_domain, const AttrDomain to_domain) const
GAttributeReader get() const
void resize(int points_num, int curves_num)
AttributeAccessor attributes() const
MutableSpan< int > offsets_for_write()
OffsetIndices< int > points_by_curve() const
Array< int > point_to_curve_map() const
MutableAttributeAccessor attributes_for_write()
Span< int > reference_handles() const
Definition instances.cc:222
Span< float4x4 > transforms() const
Definition instances.cc:235
Span< InstanceReference > references() const
Definition instances.cc:290
bke::AttributeAccessor attributes() const
Definition instances.cc:68
int instances_num() const
Definition instances.cc:408
GSpanAttributeWriter lookup_or_add_for_write_only_span(StringRef name, AttrDomain domain, AttrType data_type)
bke::CurvesGeometry & strokes_for_write()
const bke::CurvesGeometry & strokes() const
auto attribute_filter_with_skip_ref(const AttributeFilter &filter, const Span< StringRef > skip)
void curves_copy_parameters(const Curves &src, Curves &dst)
void gather_attributes(AttributeAccessor src_attributes, AttrDomain src_domain, AttrDomain dst_domain, const AttributeFilter &attribute_filter, const IndexMask &selection, MutableAttributeAccessor dst_attributes)
Curves * curves_new_nomain_single(int points_num, CurveType type)
Curves * curves_new_nomain(int points_num, int curves_num)
constexpr ParallelGrainSize grain_size(int grain_size)
Array< bke::Instances * > extract_instances(const bke::Instances &instances, const IndexMask &mask, const bke::AttributeFilter &attribute_filter)
Array< GreasePencil * > extract_greasepencil_layer_points(const GreasePencil &grease_pencil, int layer_i, const IndexMask &mask, const bke::AttributeFilter &attribute_filter)
Array< Mesh * > extract_mesh_faces(const Mesh &mesh, const IndexMask &mask, const bke::AttributeFilter &attribute_filter)
Array< Mesh * > extract_mesh_vertices(const Mesh &mesh, const IndexMask &mask, const bke::AttributeFilter &attribute_filter)
Array< Curves * > extract_curves(const Curves &curves, const IndexMask &mask, const bke::AttributeFilter &attribute_filter)
Array< Curves * > extract_curves_points(const Curves &curves, const IndexMask &mask, const bke::AttributeFilter &attribute_filter)
Array< GreasePencil * > extract_greasepencil_layers(const GreasePencil &grease_pencil, const IndexMask &mask, const bke::AttributeFilter &attribute_filter)
Array< GreasePencil * > extract_greasepencil_layer_curves(const GreasePencil &grease_pencil, int layer_i, const IndexMask &mask, const bke::AttributeFilter &attribute_filter)
Array< PointCloud * > extract_pointcloud_points(const PointCloud &pointcloud, const IndexMask &mask, const bke::AttributeFilter &attribute_filter)
Array< Mesh * > extract_mesh_edges(const Mesh &mesh, const IndexMask &mask, const bke::AttributeFilter &attribute_filter)
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
MatBase< float, 4, 4 > float4x4
void BKE_mesh_copy_parameters_for_eval(Mesh *me_dst, const Mesh *me_src)
VecBase< int32_t, 2 > int2
Mesh * BKE_mesh_new_nomain(int verts_num, int edges_num, int faces_num, int corners_num)
PointCloud * BKE_pointcloud_new_nomain(PointCloudType type, int totpoint)
ATTR_WARN_UNUSED_RESULT const void * element
GreasePencil * BKE_grease_pencil_new_nomain()
struct Material ** mat
bool allow_skip(const StringRef name) const