Blender V5.3
curve_to_mesh_convert.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
8
9#include <limits>
10#include <numbers>
11
12#include "BLI_array.hh"
13#include "BLI_array_utils.hh"
14#include "BLI_math_matrix.hh"
15#include "BLI_task.hh"
16
17#include "BKE_attribute_math.hh"
18#include "BKE_curves.hh"
19#include "BKE_customdata.hh"
20#include "BKE_geometry_set.hh"
21#include "BKE_mesh.hh"
22
23#include "BKE_curve_to_mesh.hh"
24
25namespace blender::bke {
26
27static int segments_num_no_duplicate_edge(const int points_num, const bool cyclic)
28{
29 if (points_num == 0) {
30 return 0;
31 }
32 if (points_num <= 2) {
33 return curves::segments_num(points_num, false);
34 }
35 return curves::segments_num(points_num, cyclic);
36}
37
38static inline bool has_caps(const bool main_cyclic,
39 const bool profile_cyclic,
40 const int profile_segment_num)
41{
42 return !main_cyclic && profile_cyclic && profile_segment_num > 2;
43}
44
45static void fill_mesh_topology(const int vert_offset,
46 const int edge_offset,
47 const int face_offset,
48 const int loop_offset,
49 const int main_point_num,
50 const int profile_point_num,
51 const bool main_cyclic,
52 const bool profile_cyclic,
53 const bool fill_caps,
55 MutableSpan<int> corner_verts,
56 MutableSpan<int> corner_edges,
57 MutableSpan<int> face_offsets)
58{
59 const int main_segment_num = segments_num_no_duplicate_edge(main_point_num, main_cyclic);
60 const int profile_segment_num = curves::segments_num(profile_point_num, profile_cyclic);
61
62 if (profile_point_num == 1) {
63 for (const int i : IndexRange(main_point_num - 1)) {
64 int2 &edge = edges[edge_offset + i];
65 edge[0] = vert_offset + i;
66 edge[1] = vert_offset + i + 1;
67 }
68
69 if (main_cyclic && main_segment_num > 2) {
70 int2 &edge = edges[edge_offset + main_segment_num - 1];
71 edge[0] = vert_offset + main_point_num - 1;
72 edge[1] = vert_offset;
73 }
74 return;
75 }
76
77 /* Add the edges running along the length of the curve, starting at each profile vertex. */
78 const int main_edges_start = edge_offset;
79 for (const int i_profile : IndexRange(profile_point_num)) {
80 const int profile_edge_offset = main_edges_start + i_profile * main_segment_num;
81 for (const int i_ring : IndexRange(main_segment_num)) {
82 const int i_next_ring = (i_ring == main_point_num - 1) ? 0 : i_ring + 1;
83
84 const int ring_vert_offset = vert_offset + profile_point_num * i_ring;
85 const int next_ring_vert_offset = vert_offset + profile_point_num * i_next_ring;
86
87 int2 &edge = edges[profile_edge_offset + i_ring];
88 edge[0] = ring_vert_offset + i_profile;
89 edge[1] = next_ring_vert_offset + i_profile;
90 }
91 }
92
93 /* Add the edges running along each profile ring. */
94 const int profile_edges_start = main_edges_start + profile_point_num * main_segment_num;
95 for (const int i_ring : IndexRange(main_point_num)) {
96 const int ring_vert_offset = vert_offset + profile_point_num * i_ring;
97
98 const int ring_edge_offset = profile_edges_start + i_ring * profile_segment_num;
99 for (const int i_profile : IndexRange(profile_segment_num)) {
100 const int i_next_profile = (i_profile == profile_point_num - 1) ? 0 : i_profile + 1;
101
102 int2 &edge = edges[ring_edge_offset + i_profile];
103 edge[0] = ring_vert_offset + i_profile;
104 edge[1] = ring_vert_offset + i_next_profile;
105 }
106 }
107
108 /* Calculate face and corner indices. */
109 for (const int i_ring : IndexRange(main_segment_num)) {
110 const int i_next_ring = (i_ring == main_point_num - 1) ? 0 : i_ring + 1;
111
112 const int ring_vert_offset = vert_offset + profile_point_num * i_ring;
113 const int next_ring_vert_offset = vert_offset + profile_point_num * i_next_ring;
114
115 const int ring_edge_start = profile_edges_start + profile_segment_num * i_ring;
116 const int next_ring_edge_offset = profile_edges_start + profile_segment_num * i_next_ring;
117
118 const int ring_face_offset = face_offset + i_ring * profile_segment_num;
119 const int ring_loop_offset = loop_offset + i_ring * profile_segment_num * 4;
120
121 for (const int i_profile : IndexRange(profile_segment_num)) {
122 const int ring_segment_loop_offset = ring_loop_offset + i_profile * 4;
123 const int i_next_profile = (i_profile == profile_point_num - 1) ? 0 : i_profile + 1;
124
125 const int main_edge_start = main_edges_start + main_segment_num * i_profile;
126 const int next_main_edge_start = main_edges_start + main_segment_num * i_next_profile;
127
128 face_offsets[ring_face_offset + i_profile] = ring_segment_loop_offset;
129
130 corner_verts[ring_segment_loop_offset] = ring_vert_offset + i_profile;
131 corner_edges[ring_segment_loop_offset] = ring_edge_start + i_profile;
132
133 corner_verts[ring_segment_loop_offset + 1] = ring_vert_offset + i_next_profile;
134 corner_edges[ring_segment_loop_offset + 1] = next_main_edge_start + i_ring;
135
136 corner_verts[ring_segment_loop_offset + 2] = next_ring_vert_offset + i_next_profile;
137 corner_edges[ring_segment_loop_offset + 2] = next_ring_edge_offset + i_profile;
138
139 corner_verts[ring_segment_loop_offset + 3] = next_ring_vert_offset + i_profile;
140 corner_edges[ring_segment_loop_offset + 3] = main_edge_start + i_ring;
141 }
142 }
143
144 if (fill_caps & has_caps(main_cyclic, profile_cyclic, profile_segment_num)) {
145 const int face_num = main_segment_num * profile_segment_num;
146 const int cap_loop_offset = loop_offset + face_num * 4;
147 const int cap_face_offset = face_offset + face_num;
148
149 face_offsets[cap_face_offset] = cap_loop_offset;
150 face_offsets[cap_face_offset + 1] = cap_loop_offset + profile_segment_num;
151
152 const int last_ring_index = main_point_num - 1;
153 const int last_ring_vert_offset = vert_offset + profile_point_num * last_ring_index;
154 const int last_ring_edge_offset = profile_edges_start + profile_segment_num * last_ring_index;
155
156 for (const int i : IndexRange(profile_segment_num)) {
157 const int i_inv = profile_segment_num - i - 1;
158 corner_verts[cap_loop_offset + i] = vert_offset + i_inv;
159 corner_edges[cap_loop_offset + i] = profile_edges_start + ((i == (profile_segment_num - 1)) ?
160 (profile_segment_num - 1) :
161 (i_inv - 1));
162 corner_verts[cap_loop_offset + profile_segment_num + i] = last_ring_vert_offset + i;
163 corner_edges[cap_loop_offset + profile_segment_num + i] = last_ring_edge_offset + i;
164 }
165 }
166}
167
169static void mark_bezier_vector_edges_sharp(const int profile_point_num,
170 const int main_segment_num,
171 const Span<int> control_point_offsets,
172 const Span<int8_t> handle_types_left,
173 const Span<int8_t> handle_types_right,
174 MutableSpan<bool> sharp_edges)
175{
176 const int main_edges_start = 0;
177 if (curves::bezier::point_is_sharp(handle_types_left, handle_types_right, 0)) {
178 sharp_edges.slice(main_edges_start, main_segment_num).fill(true);
179 }
180
181 for (const int i : IndexRange(profile_point_num).drop_front(1)) {
182 if (curves::bezier::point_is_sharp(handle_types_left, handle_types_right, i)) {
183 const int offset = main_edges_start + main_segment_num * control_point_offsets[i];
184 sharp_edges.slice(offset, main_segment_num).fill(true);
185 }
186 }
187}
188
189static float4x4 build_point_matrix(const float3 &location,
190 const float3 &tangent,
191 const float3 &normal)
192{
193 float4x4 matrix = float4x4::identity();
194 matrix.x_axis() = tangent;
195 /* Normal and tangent may not be orthogonal in case of custom normals. */
196 matrix.y_axis() = math::normalize(math::cross(normal, tangent));
197 matrix.z_axis() = normal;
198 matrix.location() = location;
199 return matrix;
200}
201
203 const float3 &location,
204 const float3 &location_next,
205 const float3 &tangent,
206 const float3 &normal,
207 const float miter_scale_limit)
208{
209 float length_in;
210 float length_out;
211 const float3 dir_in = math::normalize_and_get_length(location - location_prev, length_in);
212 const float3 dir_out = math::normalize_and_get_length(location_next - location, length_out);
213 if (length_in < 1e-10f || length_out < 1e-10f) {
214 return build_point_matrix(location, tangent, normal);
215 }
216 const float cos_turn = math::dot(dir_in, dir_out);
217 if (cos_turn >= 1.0f || cos_turn == -1.0f) {
218 return build_point_matrix(location, tangent, normal);
219 }
220 float4x4 matrix = build_point_matrix(location, tangent, normal);
221 const float scale = math::min(math::sqrt(2.0f / (1.0f + cos_turn)), miter_scale_limit);
222 const float3 bisector = math::normalize(dir_out - dir_in);
223 matrix.x_axis() += (scale - 1.0f) * math::dot(matrix.x_axis(), bisector) * bisector;
224 matrix.y_axis() += (scale - 1.0f) * math::dot(matrix.y_axis(), bisector) * bisector;
225 return matrix;
226}
227
228static float4x4 build_point_matrix(const Span<float3> main_positions,
229 const Span<float3> tangents,
230 const Span<float3> normals,
231 const Span<float> scales,
232 const bool main_cyclic,
233 const std::optional<float> miter_scale_limit,
234 const int i_ring)
235{
236 const bool is_end = !main_cyclic && (i_ring == 0 || i_ring == main_positions.size() - 1);
237 float4x4 point_matrix;
238 if (!miter_scale_limit || is_end) {
239 point_matrix = build_point_matrix(main_positions[i_ring], normals[i_ring], tangents[i_ring]);
240 }
241 else {
242 const int i_ring_prev = i_ring == 0 ? main_positions.size() - 1 : i_ring - 1;
243 const int i_ring_next = i_ring == main_positions.size() - 1 ? 0 : i_ring + 1;
244 point_matrix = build_point_matrix_miter_scale(main_positions[i_ring_prev],
245 main_positions[i_ring],
246 main_positions[i_ring_next],
247 normals[i_ring],
248 tangents[i_ring],
249 *miter_scale_limit);
250 }
251 if (!scales.is_empty()) {
252 point_matrix = math::scale(point_matrix, float3(scales[i_ring]));
253 }
254 return point_matrix;
255}
256
257static void fill_mesh_positions(const Span<float3> main_positions,
258 const Span<float3> profile_positions,
259 const Span<float3> tangents,
260 const Span<float3> normals,
261 const Span<float> scales,
262 const bool main_cyclic,
263 const std::optional<float> miter_scale_limit,
264 MutableSpan<float3> mesh_positions)
265{
266 if (profile_positions.size() == 1) {
267 for (const int i_ring : main_positions.index_range()) {
268 const float4x4 point_matrix = build_point_matrix(
269 main_positions, tangents, normals, scales, main_cyclic, miter_scale_limit, i_ring);
270 mesh_positions[i_ring] = math::transform_point(point_matrix, profile_positions.first());
271 }
272 }
273 else {
274 for (const int i_ring : main_positions.index_range()) {
275 const float4x4 point_matrix = build_point_matrix(
276 main_positions, tangents, normals, scales, main_cyclic, miter_scale_limit, i_ring);
277 const int ring_vert_start = i_ring * profile_positions.size();
278 for (const int i_profile : profile_positions.index_range()) {
279 mesh_positions[ring_vert_start + i_profile] = math::transform_point(
280 point_matrix, profile_positions[i_profile]);
281 }
282 }
283 }
284}
285
289
290 /* Make sure these are spans because they are potentially accessed many times. */
293};
295{
296 return {main, profile, main.cyclic(), profile.cyclic()};
297}
298
300{
301 for (const int64_t i : offsets.index_range()) {
302 if (offsets[i].size() == 1) {
303 return true;
304 }
305 }
306 return false;
307}
308
311 int total;
312
318
319 /* The indices of the main and profile curves that form each combination. */
322
326};
327static ResultOffsets calculate_result_offsets(const CurvesInfo &info, const bool fill_caps)
328{
330 result.total = info.main.curves_num() * info.profile.curves_num();
331
332 const OffsetIndices<int> main_offsets = info.main.evaluated_points_by_curve();
333 const OffsetIndices<int> profile_offsets = info.profile.evaluated_points_by_curve();
334
336 result.total > 1024,
337 [&]() {
338 result.vert.reinitialize(result.total + 1);
339 result.edge.reinitialize(result.total + 1);
340 result.loop.reinitialize(result.total + 1);
341 result.face.reinitialize(result.total + 1);
342
343 int mesh_index = 0;
344 int vert_offset = 0;
345 int edge_offset = 0;
346 int loop_offset = 0;
347 int face_offset = 0;
348 for (const int i_main : main_offsets.index_range()) {
349 const bool main_cyclic = info.main_cyclic[i_main];
350 const int main_point_num = main_offsets[i_main].size();
351 const int main_segment_num = segments_num_no_duplicate_edge(main_point_num, main_cyclic);
352 for (const int i_profile : profile_offsets.index_range()) {
353 result.vert[mesh_index] = vert_offset;
354 result.edge[mesh_index] = edge_offset;
355 result.loop[mesh_index] = loop_offset;
356 result.face[mesh_index] = face_offset;
357
358 const bool profile_cyclic = info.profile_cyclic[i_profile];
359 const int profile_point_num = profile_offsets[i_profile].size();
360 if (profile_point_num == 0) {
361 continue;
362 }
363 const int profile_segment_num = curves::segments_num(profile_point_num,
364 profile_cyclic);
365
366 const bool caps = fill_caps &
367 has_caps(main_cyclic, profile_cyclic, profile_segment_num);
368 const int tube_face_num = main_segment_num * profile_segment_num;
369
370 vert_offset += main_point_num * profile_point_num;
371
372 /* Add the ring edges, with one ring for every curve vertex, and the edge loops
373 * that run along the length of the curve, starting on the first profile. */
374 edge_offset += main_point_num * profile_segment_num +
375 main_segment_num * profile_point_num;
376
377 /* Add two cap N-gons for every ending. */
378 face_offset += tube_face_num + (caps ? 2 : 0);
379
380 /* All faces on the tube are quads, and all cap faces are N-gons with an edge for each
381 * profile edge. */
382 loop_offset += tube_face_num * 4 + (caps ? profile_segment_num * 2 : 0);
383
384 mesh_index++;
385 }
386 }
387
388 result.vert.last() = vert_offset;
389 result.edge.last() = edge_offset;
390 result.loop.last() = loop_offset;
391 result.face.last() = face_offset;
392 },
393 [&]() {
394 result.main_indices.reinitialize(result.total);
395 result.profile_indices.reinitialize(result.total);
396
397 int mesh_index = 0;
398 for (const int i_main : main_offsets.index_range()) {
399 for (const int i_profile : profile_offsets.index_range()) {
400 result.main_indices[mesh_index] = i_main;
401 result.profile_indices[mesh_index] = i_profile;
402 mesh_index++;
403 }
404 }
405 },
406 [&]() { result.any_single_point_main = offsets_contain_single_point(main_offsets); },
407 [&]() { result.any_single_point_profile = offsets_contain_single_point(profile_offsets); });
408
409 return result;
410}
411
413 const StringRef name)
414{
415 /* Only use a different domain if it is builtin and must only exist on one domain. */
416 if (!mesh_attributes.is_builtin(name)) {
417 return AttrDomain::Point;
418 }
419
420 std::optional<AttributeMetaData> meta_data = mesh_attributes.lookup_meta_data(name);
421 if (!meta_data) {
422 return AttrDomain::Point;
423 }
424
425 return meta_data->domain;
426}
427
428static bool should_add_attribute_to_mesh(const AttributeAccessor &curve_attributes,
429 const AttributeAccessor &mesh_attributes,
430 const StringRef name,
431 const AttributeMetaData &meta_data,
432 const AttributeFilter &attribute_filter)
433{
434
435 if (ELEM(name, "position", ".edge_verts", ".corner_vert", ".corner_edge")) {
436 /* These attributes have non-generic evaluation. */
437 return false;
438 }
439 if (name == "custom_normal") {
440 /* The custom normal attribute is builtin on both meshes and curves, but has a different
441 * meaning and shouldn't be directly propagated. */
442 return false;
443 }
444 /* Don't propagate built-in curves attributes that are not built-in on meshes. */
445 if (curve_attributes.is_builtin(name) && !mesh_attributes.is_builtin(name)) {
446 return false;
447 }
448 if (attribute_filter.allow_skip(name)) {
449 return false;
450 }
451 if (meta_data.data_type == AttrType::String) {
452 return false;
453 }
454 return true;
455}
456
458 const CurvesGeometry &curves,
459 Vector<std::byte> &buffer)
460{
461 /* Poly curves evaluated points match the curve points, no need to interpolate. */
462 if (curves.is_single_type(CURVE_TYPE_POLY)) {
463 if (src.is_span()) {
464 return src.get_internal_span();
465 }
466 buffer.reinitialize(curves.points_num() * src.type().size);
467 src.materialize(buffer.data());
468 GMutableSpan eval{src.type(), buffer.data(), curves.points_num()};
469 return eval;
470 }
471
472 if (src.is_span()) {
473 buffer.reinitialize(curves.evaluated_points_num() * src.type().size);
474 GMutableSpan eval{src.type(), buffer.data(), curves.evaluated_points_num()};
475 curves.interpolate_to_evaluated(src.get_internal_span(), eval);
476 return eval;
477 }
478 GVArraySpan src_buffer(src);
479 buffer.reinitialize(curves.evaluated_points_num() * src.type().size);
480 GMutableSpan eval{src.type(), buffer.data(), curves.evaluated_points_num()};
481 curves.interpolate_to_evaluated(src_buffer, eval);
482 return eval;
483}
484
504template<typename Fn>
505static void foreach_curve_combination(const CurvesInfo &info,
506 const ResultOffsets &offsets,
507 const Fn &fn)
508{
509 const OffsetIndices<int> main_offsets = info.main.evaluated_points_by_curve();
510 const OffsetIndices<int> profile_offsets = info.profile.evaluated_points_by_curve();
511 const OffsetIndices<int> vert_offsets(offsets.vert);
512 const OffsetIndices<int> edge_offsets(offsets.edge);
513 const OffsetIndices<int> face_offsets(offsets.face);
514 const OffsetIndices<int> loop_offsets(offsets.loop);
515 threading::parallel_for(IndexRange(offsets.total), 512, [&](IndexRange range) {
516 for (const int i : range) {
517 const int i_main = offsets.main_indices[i];
518 const int i_profile = offsets.profile_indices[i];
519
520 const IndexRange main_points = main_offsets[i_main];
521 const IndexRange profile_points = profile_offsets[i_profile];
522 if (main_points.is_empty() || profile_points.is_empty()) {
523 continue;
524 }
525
526 const bool main_cyclic = info.main_cyclic[i_main];
527 const bool profile_cyclic = info.profile_cyclic[i_profile];
528
529 /* Pass all information in a struct to avoid repeating arguments in many lambdas.
530 * The idea is that inlining `fn` will help avoid accessing unnecessary information,
531 * though that may or may not happen in practice. */
532 fn(CombinationInfo{i_main,
533 i_profile,
534 main_points,
535 profile_points,
536 main_cyclic,
537 profile_cyclic,
538 curves::segments_num(main_points.size(), main_cyclic),
539 curves::segments_num(profile_points.size(), profile_cyclic),
540 vert_offsets[i],
541 edge_offsets[i],
542 face_offsets[i],
543 loop_offsets[i]});
544 }
545 });
546}
547
548static void build_mesh_positions(const CurvesInfo &curves_info,
549 const ResultOffsets &offsets,
550 const VArray<float> &scales,
551 const std::optional<float> miter_scale_limit,
552 Vector<std::byte> &eval_buffer,
553 Mesh &mesh)
554{
555 BLI_assert(!mesh.attributes().contains("position"));
556 const Span<float3> profile_positions = curves_info.profile.evaluated_positions();
557 const bool ignore_profile_position = profile_positions.size() == 1 &&
558 math::is_equal(profile_positions.first(), float3(0.0f));
559 if (ignore_profile_position) {
560 if (mesh.verts_num == curves_info.main.points_num() &&
561 /* NURBS can have equal evaluated and positions sizes, but different coords. */
563 {
564 const GAttributeReader src = curves_info.main.attributes().lookup("position");
565 if (src.sharing_info && src.varray.is_span()) {
567 if (mesh.attributes_for_write().add<float3>("position", AttrDomain::Point, init)) {
568 return;
569 }
570 }
571 }
572 }
573 const Span<float3> main_positions = curves_info.main.evaluated_positions();
574 mesh.attributes_for_write().add<float3>("position", AttrDomain::Point, AttributeInitConstruct());
575 MutableSpan<float3> positions = mesh.vert_positions_for_write();
576 if (ignore_profile_position) {
577 array_utils::copy(main_positions, positions);
578 return;
579 }
580 const Span<float3> tangents = curves_info.main.evaluated_tangents();
581 const Span<float3> normals = curves_info.main.evaluated_normals();
582 Span<float> eval_scales;
583 if (!scales.is_empty() && scales.get_if_single() != 1.0f) {
584 eval_scales = evaluate_attribute(scales, curves_info.main, eval_buffer).typed<float>();
585 }
586 foreach_curve_combination(curves_info, offsets, [&](const CombinationInfo &info) {
587 fill_mesh_positions(main_positions.slice(info.main_points),
588 profile_positions.slice(info.profile_points),
589 tangents.slice(info.main_points),
590 normals.slice(info.main_points),
591 eval_scales.is_empty() ? eval_scales : eval_scales.slice(info.main_points),
592 info.main_cyclic,
593 miter_scale_limit,
594 positions.slice(info.vert_range));
595 });
596}
597
598template<typename T>
600 const int profile_point_num,
601 MutableSpan<T> dst)
602{
603 for (const int i_ring : src.index_range()) {
604 const int ring_vert_start = i_ring * profile_point_num;
605 dst.slice(ring_vert_start, profile_point_num).fill(src[i_ring]);
606 }
607}
608
609template<typename T>
611 const int profile_point_num,
612 const int main_segment_num,
613 const int profile_segment_num,
614 MutableSpan<T> dst)
615{
616 const int edges_start = profile_point_num * main_segment_num;
617 for (const int i_ring : src.index_range()) {
618 const int ring_edge_start = edges_start + profile_segment_num * i_ring;
619 dst.slice(ring_edge_start, profile_segment_num).fill(src[i_ring]);
620 }
621}
622
623template<typename T>
625 const int main_segment_num,
626 const int profile_segment_num,
627 MutableSpan<T> dst)
628{
629 for (const int i_ring : IndexRange(main_segment_num)) {
630 const int ring_face_start = profile_segment_num * i_ring;
631 dst.slice(ring_face_start, profile_segment_num).fill(src[i_ring]);
632 }
633}
634
636 const StringRef name,
637 const GAttributeReader &src,
638 MutableAttributeAccessor mesh_attributes)
639{
640 if (mesh_attributes.domain_size(AttrDomain::Point) != main.points_num()) {
641 return false;
642 }
643 if (!src.sharing_info || !src.varray.is_span()) {
644 return false;
645 }
646 return mesh_attributes.add(
647 name,
651}
652
654 const GAttributeReader &src,
655 GMutableSpan dst)
656{
657 if (dst.size() != main.evaluated_points_num()) {
658 return false;
659 }
660 if (!src.varray.is_span()) {
661 return false;
662 }
663 main.interpolate_to_evaluated(src.varray.get_internal_span(), dst);
664 return true;
665}
666
668 const StringRef name,
669 const ResultOffsets &offsets,
670 const AttrDomain dst_domain,
671 const GAttributeReader &src_attribute,
672 Vector<std::byte> &eval_buffer,
673 MutableAttributeAccessor mesh_attributes)
674{
675 if (dst_domain == AttrDomain::Point) {
676 if (try_sharing_point_data(curves_info.main, name, src_attribute, mesh_attributes)) {
677 return;
678 }
679 }
680 GSpanAttributeWriter dst_attribute = mesh_attributes.lookup_or_add_for_write_only_span(
681 name, dst_domain, bke::cpp_type_to_attribute_type(src_attribute.varray.type()));
682 if (!dst_attribute) {
683 return;
684 }
685 if (dst_domain == AttrDomain::Point) {
686 if (try_direct_evaluate_point_data(curves_info.main, src_attribute, dst_attribute.span)) {
687 dst_attribute.finish();
688 return;
689 }
690 }
691 const GSpan src_all = evaluate_attribute(*src_attribute, curves_info.main, eval_buffer);
692 attribute_math::to_static_type(src_attribute.varray.type(), [&]<typename T>() {
693 const Span<T> src = src_all.typed<T>();
694 MutableSpan<T> dst = dst_attribute.span.typed<T>();
695 switch (dst_domain) {
696 case AttrDomain::Point:
697 foreach_curve_combination(curves_info, offsets, [&](const CombinationInfo &info) {
698 copy_main_point_data_to_mesh_verts(
699 src.slice(info.main_points), info.profile_points.size(), dst.slice(info.vert_range));
700 });
701 break;
702 case AttrDomain::Edge:
703 foreach_curve_combination(curves_info, offsets, [&](const CombinationInfo &info) {
704 copy_main_point_data_to_mesh_edges(src.slice(info.main_points),
705 info.profile_points.size(),
706 info.main_segment_num,
707 info.profile_segment_num,
708 dst.slice(info.edge_range));
709 });
710 break;
711 case AttrDomain::Face:
712 foreach_curve_combination(curves_info, offsets, [&](const CombinationInfo &info) {
713 copy_main_point_data_to_mesh_faces(src.slice(info.main_points),
714 info.main_segment_num,
715 info.profile_segment_num,
716 dst.slice(info.face_range));
717 });
718 break;
719 case AttrDomain::Corner:
720 /* Unsupported for now, since there are no builtin attributes to convert into. */
721 break;
722 default:
723 BLI_assert_unreachable();
724 break;
725 }
726 });
727 dst_attribute.finish();
728}
729
730template<typename T>
732 const int main_point_num,
733 MutableSpan<T> dst)
734{
735 for (const int i_ring : IndexRange(main_point_num)) {
736 const int profile_vert_start = i_ring * src.size();
737 for (const int i_profile : src.index_range()) {
738 dst[profile_vert_start + i_profile] = src[i_profile];
739 }
740 }
741}
742
743template<typename T>
745 const int main_segment_num,
746 MutableSpan<T> dst)
747{
748 for (const int i_profile : src.index_range()) {
749 const int profile_edge_offset = i_profile * main_segment_num;
750 dst.slice(profile_edge_offset, main_segment_num).fill(src[i_profile]);
751 }
752}
753
754template<typename T>
756 const int main_segment_num,
757 const int profile_segment_num,
758 MutableSpan<T> dst)
759{
760 for (const int i_ring : IndexRange(main_segment_num)) {
761 const int profile_face_start = i_ring * profile_segment_num;
762 for (const int i_profile : IndexRange(profile_segment_num)) {
763 dst[profile_face_start + i_profile] = src[i_profile];
764 }
765 }
766}
767
769 const ResultOffsets &offsets,
770 const AttrDomain dst_domain,
771 const GSpan src_all,
772 GMutableSpan dst_all)
773{
774 attribute_math::to_static_type(src_all.type(), [&]<typename T>() {
775 const Span<T> src = src_all.typed<T>();
776 MutableSpan<T> dst = dst_all.typed<T>();
777 switch (dst_domain) {
778 case AttrDomain::Point:
779 foreach_curve_combination(curves_info, offsets, [&](const CombinationInfo &info) {
780 copy_profile_point_data_to_mesh_verts(
781 src.slice(info.profile_points), info.main_points.size(), dst.slice(info.vert_range));
782 });
783 break;
784 case AttrDomain::Edge:
785 foreach_curve_combination(curves_info, offsets, [&](const CombinationInfo &info) {
786 copy_profile_point_data_to_mesh_edges(
787 src.slice(info.profile_points), info.main_segment_num, dst.slice(info.edge_range));
788 });
789 break;
790 case AttrDomain::Face:
791 foreach_curve_combination(curves_info, offsets, [&](const CombinationInfo &info) {
792 copy_profile_point_data_to_mesh_faces(src.slice(info.profile_points),
793 info.main_segment_num,
794 info.profile_segment_num,
795 dst.slice(info.face_range));
796 });
797 break;
798 case AttrDomain::Corner:
799 /* Unsupported for now, since there are no builtin attributes to convert into. */
800 break;
801 default:
802 BLI_assert_unreachable();
803 break;
804 }
805 });
806}
807
808template<typename T>
810 const Span<int> curve_indices,
811 const OffsetIndices<int> mesh_offsets,
812 MutableSpan<T> dst)
813{
814 /* This unnecessarily instantiates the "is single" case (which should be handled elsewhere if
815 * it's ever used for attributes), but the alternative is duplicating the function for spans and
816 * other virtual arrays. */
817 devirtualize_varray(src, [&](const auto src) {
818 threading::parallel_for(curve_indices.index_range(), 512, [&](IndexRange range) {
819 for (const int i : range) {
820 dst.slice(mesh_offsets[i]).fill(src[curve_indices[i]]);
821 }
822 });
823 });
824}
825
827 const Span<int> curve_indices,
828 const AttrDomain dst_domain,
829 const GVArray &src,
830 GMutableSpan dst)
831{
832 Span<int> offsets;
833 switch (dst_domain) {
835 offsets = mesh_offsets.vert;
836 break;
837 case AttrDomain::Edge:
838 offsets = mesh_offsets.edge;
839 break;
840 case AttrDomain::Face:
841 offsets = mesh_offsets.face;
842 break;
844 offsets = mesh_offsets.loop;
845 break;
846 default:
848 return;
849 }
850 attribute_math::to_static_type(src.type(), [&]<typename T>() {
851 copy_indices_to_offset_ranges(src.typed<T>(), curve_indices, offsets, dst.typed<T>());
852 });
853}
854
855static void write_sharp_bezier_edges(const CurvesInfo &curves_info,
856 const ResultOffsets &offsets,
857 MutableAttributeAccessor mesh_attributes,
858 SpanAttributeWriter<bool> &sharp_edges)
859{
860 const CurvesGeometry &profile = curves_info.profile;
862 return;
863 }
864 const VArraySpan<int8_t> handle_types_left{profile.handle_types_left()};
865 const VArraySpan<int8_t> handle_types_right{profile.handle_types_right()};
866 if (!handle_types_left.contains(BEZIER_HANDLE_VECTOR) &&
867 !handle_types_right.contains(BEZIER_HANDLE_VECTOR))
868 {
869 return;
870 }
871
872 sharp_edges = mesh_attributes.lookup_or_add_for_write_span<bool>("sharp_edge", AttrDomain::Edge);
873
874 const OffsetIndices profile_points_by_curve = profile.points_by_curve();
875 const VArray<int8_t> types = profile.curve_types();
876 foreach_curve_combination(curves_info, offsets, [&](const CombinationInfo &info) {
877 if (types[info.i_profile] == CURVE_TYPE_BEZIER) {
878 const IndexRange points = profile_points_by_curve[info.i_profile];
880 info.main_segment_num,
882 handle_types_left.slice(points),
883 handle_types_right.slice(points),
884 sharp_edges.span.slice(info.edge_range));
885 }
886 });
887}
888
890 const CurvesGeometry &profile,
891 const VArray<float> &scales,
892 const bool fill_caps,
893 const std::optional<float> miter_limit_angle,
894 const AttributeFilter &attribute_filter)
895{
896 /* Convert the limit turn angle to the maximum allowed miter scale factor (`1 / cos(angle / 2)`).
897 * At or past a 180 degree turn there is effectively no clamp. */
898 const std::optional<float> miter_scale_limit = [&]() -> std::optional<float> {
899 if (!miter_limit_angle) {
900 return std::nullopt;
901 }
902 return *miter_limit_angle >= std::numbers::pi_v<float> ?
903 std::numeric_limits<float>::max() :
904 1.0f / math::cos(*miter_limit_angle / 2.0f);
905 }();
906
907 const CurvesInfo curves_info = get_curves_info(main, profile);
908
909 const ResultOffsets offsets = calculate_result_offsets(curves_info, fill_caps);
910 if (offsets.vert.last() == 0) {
911 return nullptr;
912 }
913
914 /* Add the position attribute later so it can be shared in some cases. */
916 0, offsets.edge.last(), offsets.face.last(), offsets.loop.last());
917 mesh->attribute_storage.wrap().remove("position");
918 mesh->verts_num = offsets.vert.last();
919
920 MutableSpan<int2> edges = mesh->edges_for_write();
921 MutableSpan<int> face_offsets = mesh->face_offsets_for_write();
922 MutableSpan<int> corner_verts = mesh->corner_verts_for_write();
923 MutableSpan<int> corner_edges = mesh->corner_edges_for_write();
924 MutableAttributeAccessor mesh_attributes = mesh->attributes_for_write();
925
926 foreach_curve_combination(curves_info, offsets, [&](const CombinationInfo &info) {
928 info.edge_range.start(),
929 info.face_range.start(),
930 info.loop_range.start(),
931 info.main_points.size(),
932 info.profile_points.size(),
933 info.main_cyclic,
934 info.profile_cyclic,
935 fill_caps,
936 edges,
937 corner_verts,
938 corner_edges,
939 face_offsets);
940 });
941
942 if (fill_caps) {
943 /* TODO: This is used to keep the tests passing after refactoring mesh shade smooth flags. It
944 * can be removed if the tests are updated and the final shading results will be the same. */
945 SpanAttributeWriter<bool> sharp_faces = mesh_attributes.lookup_or_add_for_write_span<bool>(
946 "sharp_face", AttrDomain::Face);
947 foreach_curve_combination(curves_info, offsets, [&](const CombinationInfo &info) {
949 const int face_num = info.main_segment_num * info.profile_segment_num;
950 const int cap_face_offset = info.face_range.start() + face_num;
951 sharp_faces.span[cap_face_offset] = true;
952 sharp_faces.span[cap_face_offset + 1] = true;
953 }
954 });
955 sharp_faces.finish();
956 }
957
958 Vector<std::byte> eval_buffer;
959
960 /* Make sure curve attributes can be interpolated. */
961 main.ensure_can_interpolate_to_evaluated();
962
963 build_mesh_positions(curves_info, offsets, scales, miter_scale_limit, eval_buffer, *mesh);
964
965 mesh->tag_overlapping_none();
966 if (!offsets.any_single_point_main) {
967 /* If there are no single point curves, every combination will have at least loose edges. */
968 mesh->tag_loose_verts_none();
969 if (!offsets.any_single_point_profile) {
970 /* If there are no single point profiles, every combination will have faces. */
971 mesh->tag_loose_edges_none();
972 }
973 }
974
975 SpanAttributeWriter<bool> sharp_edges;
976 write_sharp_bezier_edges(curves_info, offsets, mesh_attributes, sharp_edges);
977 if (fill_caps) {
978 if (!sharp_edges) {
979 sharp_edges = mesh_attributes.lookup_or_add_for_write_span<bool>("sharp_edge",
981 }
982 foreach_curve_combination(curves_info, offsets, [&](const CombinationInfo &info) {
983 if (info.main_cyclic || !info.profile_cyclic) {
984 return;
985 }
986 const int main_edges_start = info.edge_range.start();
987 const int last_ring_index = info.main_points.size() - 1;
988 const int profile_edges_start = main_edges_start +
990 const int last_ring_edge_offset = profile_edges_start +
991 info.profile_segment_num * last_ring_index;
992
993 sharp_edges.span.slice(profile_edges_start, info.profile_segment_num).fill(true);
994 sharp_edges.span.slice(last_ring_edge_offset, info.profile_segment_num).fill(true);
995 });
996 }
997 sharp_edges.finish();
998
999 const AttributeAccessor main_attributes = main.attributes();
1000 main_attributes.foreach_attribute([&](const AttributeIter &iter) {
1001 if (!should_add_attribute_to_mesh(main_attributes,
1002 mesh_attributes,
1003 iter.name,
1004 {iter.domain, iter.data_type},
1005 attribute_filter))
1006 {
1007 return;
1008 }
1009
1010 const AttrDomain src_domain = iter.domain;
1011 const AttrType type = iter.data_type;
1012 const GAttributeReader src = iter.get();
1013 const AttrDomain dst_domain = get_attribute_domain_for_mesh(mesh_attributes, iter.name);
1014 const CommonVArrayInfo info = src.varray.common_info();
1016 const GPointer value(src.varray.type(), info.data);
1017 if (mesh_attributes.add(iter.name, dst_domain, type, bke::AttributeInitValue(value))) {
1018 return;
1019 }
1020 }
1021
1022 if (src_domain == AttrDomain::Point) {
1024 curves_info, iter.name, offsets, dst_domain, src, eval_buffer, mesh_attributes);
1025 }
1026 else if (src_domain == AttrDomain::Curve) {
1028 iter.name, dst_domain, type);
1029 if (dst) {
1031 offsets, offsets.main_indices, dst_domain, *src, dst.span);
1032 }
1033 dst.finish();
1034 }
1035 });
1036
1037 /* Make sure profile attributes can be interpolated. */
1039
1040 const AttributeAccessor profile_attributes = profile.attributes();
1041 profile_attributes.foreach_attribute([&](const AttributeIter &iter) {
1042 if (main_attributes.contains(iter.name)) {
1043 return;
1044 }
1045 if (!should_add_attribute_to_mesh(profile_attributes,
1046 mesh_attributes,
1047 iter.name,
1048 {iter.domain, iter.data_type},
1049 attribute_filter))
1050 {
1051 return;
1052 }
1053 const AttrDomain src_domain = iter.domain;
1054 const AttrType type = iter.data_type;
1055 const GVArray src = *iter.get();
1056 const AttrDomain dst_domain = get_attribute_domain_for_mesh(mesh_attributes, iter.name);
1057 const CommonVArrayInfo info = src.common_info();
1059 const GPointer value(src.type(), info.data);
1060 if (mesh_attributes.add(iter.name, dst_domain, type, bke::AttributeInitValue(value))) {
1061 return;
1062 }
1063 }
1064
1066 iter.name, dst_domain, type);
1067 if (!dst) {
1068 return;
1069 }
1070
1071 if (src_domain == AttrDomain::Point) {
1073 offsets,
1074 dst_domain,
1075 evaluate_attribute(src, profile, eval_buffer),
1076 dst.span);
1077 }
1078 else if (src_domain == AttrDomain::Curve) {
1080 offsets, offsets.profile_indices, dst_domain, src, dst.span);
1081 }
1082
1083 dst.finish();
1084 });
1085
1086 return mesh;
1087}
1088
1090{
1091 CurvesGeometry curves(1, 1);
1092 curves.offsets_for_write().last() = 1;
1093 curves.positions_for_write().fill(float3(0.0f));
1094 curves.fill_curve_types(CURVE_TYPE_POLY);
1095
1096 return curves;
1097}
1098
1099Mesh *curve_to_wire_mesh(const CurvesGeometry &curve, const AttributeFilter &attribute_filter)
1100{
1101 static const CurvesGeometry vert_curve = get_curve_single_vert();
1102 return curve_to_mesh_sweep(curve, vert_curve, {}, false, std::nullopt, attribute_filter);
1103}
1104
1105} // namespace blender::bke
Low-level operations for curves.
CustomData interface, see also DNA_customdata_types.h.
#define BLI_assert_unreachable()
#define ELEM(...)
const T & last(const int64_t n=0) const
Definition BLI_array.hh:307
Span< T > typed() const
const CPPType & type() const
const void * data() const
CommonVArrayInfo common_info() const
void materialize(void *dst) const
constexpr int64_t size() const
constexpr IndexRange()=default
constexpr int64_t start() const
constexpr MutableSpan slice(const int64_t start, const int64_t size) const
Definition BLI_span.hh:579
constexpr void fill(const T &value) const
Definition BLI_span.hh:523
constexpr Span slice(int64_t start, int64_t size) const
Definition BLI_span.hh:141
constexpr const T & first() const
Definition BLI_span.hh:319
constexpr int64_t size() const
Definition BLI_span.hh:256
constexpr IndexRange index_range() const
Definition BLI_span.hh:405
constexpr bool is_empty() const
Definition BLI_span.hh:264
std::optional< T > get_if_single() const
void reinitialize(const int64_t new_size)
void foreach_attribute(const FunctionRef< void(const AttributeIter &)> fn) const
bool contains(StringRef name) const
std::optional< AttributeMetaData > lookup_meta_data(StringRef name) const
GAttributeReader lookup(const StringRef name) const
int domain_size(const AttrDomain domain) const
bool is_builtin(const StringRef name) const
GAttributeReader get() const
Span< float3 > evaluated_tangents() const
VArray< int8_t > curve_types() const
void ensure_can_interpolate_to_evaluated() const
AttributeAccessor attributes() const
Span< int > bezier_evaluated_offsets_for_curve(int curve_index) const
VArray< int8_t > handle_types_left() const
OffsetIndices< int > evaluated_points_by_curve() const
bool has_curve_with_type(CurveType type) const
Span< float3 > evaluated_positions() const
VArray< int8_t > handle_types_right() const
OffsetIndices< int > points_by_curve() const
Span< float3 > evaluated_normals() const
bool add(const StringRef name, const AttrDomain domain, const AttrType data_type, const AttributeInit &initializer)
GSpanAttributeWriter lookup_or_add_for_write_span(StringRef name, AttrDomain domain, AttrType data_type, const AttributeInit &initializer=AttributeInitDefaultValue())
GSpanAttributeWriter lookup_or_add_for_write_only_span(StringRef name, AttrDomain domain, AttrType data_type)
constexpr bool contains(const T &value) const
constexpr Span slice(int64_t start, int64_t size) const
#define main()
float3x3 scale(float3x3 mat, float2 scale)
#define T
void copy(const GVArray &src, GMutableSpan dst, exec_mode::Mode mode=exec_mode::parallel)
void to_static_type(const CPPType &cpp_type, Fn &&fn)
bool point_is_sharp(Span< int8_t > handle_types_left, Span< int8_t > handle_types_right, int index)
int segments_num(const int points_num, const bool cyclic)
static bool has_caps(const bool main_cyclic, const bool profile_cyclic, const int profile_segment_num)
static void copy_main_point_data_to_mesh_verts(const Span< T > src, const int profile_point_num, MutableSpan< T > dst)
static void copy_indices_to_offset_ranges(const VArray< T > &src, const Span< int > curve_indices, const OffsetIndices< int > mesh_offsets, MutableSpan< T > dst)
static GSpan evaluate_attribute(const GVArray &src, const CurvesGeometry &curves, Vector< std::byte > &buffer)
static void copy_curve_domain_attribute_to_mesh(const ResultOffsets &mesh_offsets, const Span< int > curve_indices, const AttrDomain dst_domain, const GVArray &src, GMutableSpan dst)
static void build_mesh_positions(const CurvesInfo &curves_info, const ResultOffsets &offsets, const VArray< float > &scales, const std::optional< float > miter_scale_limit, Vector< std::byte > &eval_buffer, Mesh &mesh)
static CurvesInfo get_curves_info(const CurvesGeometry &main, const CurvesGeometry &profile)
static void copy_profile_point_data_to_mesh_edges(const Span< T > src, const int main_segment_num, MutableSpan< T > dst)
static CurvesGeometry get_curve_single_vert()
static float4x4 build_point_matrix_miter_scale(const float3 &location_prev, const float3 &location, const float3 &location_next, const float3 &tangent, const float3 &normal, const float miter_scale_limit)
static AttrDomain get_attribute_domain_for_mesh(const AttributeAccessor &mesh_attributes, const StringRef name)
Mesh * curve_to_mesh_sweep(const CurvesGeometry &main, const CurvesGeometry &profile, const VArray< float > &scales, bool fill_caps, std::optional< float > miter_limit_angle, const bke::AttributeFilter &attribute_filter={})
static void copy_main_point_data_to_mesh_faces(const Span< T > src, const int main_segment_num, const int profile_segment_num, MutableSpan< T > dst)
static void foreach_curve_combination(const CurvesInfo &info, const ResultOffsets &offsets, const Fn &fn)
static void copy_profile_point_domain_attribute_to_mesh(const CurvesInfo &curves_info, const ResultOffsets &offsets, const AttrDomain dst_domain, const GSpan src_all, GMutableSpan dst_all)
static void mark_bezier_vector_edges_sharp(const int profile_point_num, const int main_segment_num, const Span< int > control_point_offsets, const Span< int8_t > handle_types_left, const Span< int8_t > handle_types_right, MutableSpan< bool > sharp_edges)
static void fill_mesh_topology(const int vert_offset, const int edge_offset, const int face_offset, const int loop_offset, const int main_point_num, const int profile_point_num, const bool main_cyclic, const bool profile_cyclic, const bool fill_caps, MutableSpan< int2 > edges, MutableSpan< int > corner_verts, MutableSpan< int > corner_edges, MutableSpan< int > face_offsets)
static void write_sharp_bezier_edges(const CurvesInfo &curves_info, const ResultOffsets &offsets, MutableAttributeAccessor mesh_attributes, SpanAttributeWriter< bool > &sharp_edges)
static ResultOffsets calculate_result_offsets(const CurvesInfo &info, const bool fill_caps)
static bool try_sharing_point_data(const CurvesGeometry &main, const StringRef name, const GAttributeReader &src, MutableAttributeAccessor mesh_attributes)
static void copy_profile_point_data_to_mesh_verts(const Span< T > src, const int main_point_num, MutableSpan< T > dst)
static void copy_main_point_data_to_mesh_edges(const Span< T > src, const int profile_point_num, const int main_segment_num, const int profile_segment_num, MutableSpan< T > dst)
static bool try_direct_evaluate_point_data(const CurvesGeometry &main, const GAttributeReader &src, GMutableSpan dst)
Mesh * curve_to_wire_mesh(const CurvesGeometry &curve, const bke::AttributeFilter &attribute_filter={})
static float4x4 build_point_matrix(const float3 &location, const float3 &tangent, const float3 &normal)
static int segments_num_no_duplicate_edge(const int points_num, const bool cyclic)
static void copy_main_point_domain_attribute_to_mesh(const CurvesInfo &curves_info, const StringRef name, const ResultOffsets &offsets, const AttrDomain dst_domain, const GAttributeReader &src_attribute, Vector< std::byte > &eval_buffer, MutableAttributeAccessor mesh_attributes)
AttrType cpp_type_to_attribute_type(const CPPType &type)
static void fill_mesh_positions(const Span< float3 > main_positions, const Span< float3 > profile_positions, const Span< float3 > tangents, const Span< float3 > normals, const Span< float > scales, const bool main_cyclic, const std::optional< float > miter_scale_limit, MutableSpan< float3 > mesh_positions)
static bool should_add_attribute_to_mesh(const AttributeAccessor &curve_attributes, const AttributeAccessor &mesh_attributes, const StringRef name, const AttributeMetaData &meta_data, const AttributeFilter &attribute_filter)
static bool offsets_contain_single_point(const OffsetIndices< int > offsets)
static void copy_profile_point_data_to_mesh_faces(const Span< T > src, const int main_segment_num, const int profile_segment_num, MutableSpan< T > dst)
T cos(const AngleRadianBase< T > &a)
T sqrt(const T &a)
MatBase< T, NumCol, NumRow > scale(const MatBase< T, NumCol, NumRow > &mat, const VectorT &scale)
QuaternionBase< T > normalize_and_get_length(const QuaternionBase< T > &q, T &out_length)
T dot(const QuaternionBase< T > &a, const QuaternionBase< T > &b)
T min(const T &a, const T &b)
AxisSigned cross(const AxisSigned a, const AxisSigned b)
MatBase< T, NumCol, NumRow > normalize(const MatBase< T, NumCol, NumRow > &a)
bool is_equal(const MatBase< T, NumCol, NumRow > &a, const MatBase< T, NumCol, NumRow > &b, const T epsilon=T(0))
VecBase< T, 3 > transform_point(const CartesianBasis &basis, const VecBase< T, 3 > &v)
void parallel_invoke(Functions &&...functions)
Definition BLI_task.hh:197
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
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
__int64 int64_t
Definition BKE_text.h:90
void devirtualize_varray(const VArray< T > &varray, const Func &func, bool enable=true)
MatBase< float, 4, 4 > float4x4
VecBase< int32_t, 2 > int2
Mesh * BKE_mesh_new_nomain(int verts_num, int edges_num, int faces_num, int corners_num)
VecBase< float, 3 > float3
bool allow_skip(const StringRef name) const
const CurvesGeometry & profile
const ImplicitSharingInfo * sharing_info