29 if (points_num == 0) {
32 if (points_num <= 2) {
38static inline bool has_caps(
const bool main_cyclic,
39 const bool profile_cyclic,
40 const int profile_segment_num)
42 return !main_cyclic && profile_cyclic && profile_segment_num > 2;
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,
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
128 face_offsets[ring_face_offset + i_profile] = ring_segment_loop_offset;
130 corner_verts[ring_segment_loop_offset] = ring_vert_offset + i_profile;
131 corner_edges[ring_segment_loop_offset] = ring_edge_start + i_profile;
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;
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;
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;
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;
149 face_offsets[cap_face_offset] = cap_loop_offset;
150 face_offsets[cap_face_offset + 1] = cap_loop_offset + profile_segment_num;
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;
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) :
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;
170 const int main_segment_num,
176 const int main_edges_start = 0;
178 sharp_edges.
slice(main_edges_start, main_segment_num).
fill(
true);
181 for (
const int i :
IndexRange(profile_point_num).drop_front(1)) {
183 const int offset = main_edges_start + main_segment_num * control_point_offsets[i];
184 sharp_edges.
slice(offset, main_segment_num).
fill(
true);
194 matrix.
x_axis() = tangent;
204 const float3 &location_next,
207 const float miter_scale_limit)
213 if (length_in < 1e-10f || length_out < 1e-10f) {
216 const float cos_turn =
math::dot(dir_in, dir_out);
217 if (cos_turn >= 1.0f || cos_turn == -1.0f) {
232 const bool main_cyclic,
233 const std::optional<float> miter_scale_limit,
236 const bool is_end = !main_cyclic && (i_ring == 0 || i_ring == main_positions.
size() - 1);
238 if (!miter_scale_limit || is_end) {
239 point_matrix =
build_point_matrix(main_positions[i_ring], normals[i_ring], tangents[i_ring]);
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;
245 main_positions[i_ring],
246 main_positions[i_ring_next],
262 const bool main_cyclic,
263 const std::optional<float> miter_scale_limit,
266 if (profile_positions.
size() == 1) {
267 for (
const int i_ring : main_positions.
index_range()) {
269 main_positions, tangents, normals, scales, main_cyclic, miter_scale_limit, i_ring);
274 for (
const int i_ring : main_positions.
index_range()) {
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()) {
280 point_matrix, profile_positions[i_profile]);
296 return {
main, profile,
main.cyclic(), profile.cyclic()};
302 if (offsets[i].size() == 1) {
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);
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;
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) {
363 const int profile_segment_num = curves::segments_num(profile_point_num,
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;
370 vert_offset += main_point_num * profile_point_num;
374 edge_offset += main_point_num * profile_segment_num +
375 main_segment_num * profile_point_num;
378 face_offset += tube_face_num + (caps ? 2 : 0);
382 loop_offset += tube_face_num * 4 + (caps ? profile_segment_num * 2 : 0);
388 result.vert.last() = vert_offset;
389 result.edge.last() = edge_offset;
390 result.loop.last() = loop_offset;
391 result.face.last() = face_offset;
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;
420 std::optional<AttributeMetaData> meta_data = mesh_attributes.
lookup_meta_data(name);
425 return meta_data->domain;
435 if (
ELEM(name,
"position",
".edge_verts",
".corner_vert",
".corner_edge")) {
439 if (name ==
"custom_normal") {
481 curves.interpolate_to_evaluated(src_buffer, eval);
516 for (const int i : range) {
517 const int i_main = offsets.main_indices[i];
518 const int i_profile = offsets.profile_indices[i];
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()) {
526 const bool main_cyclic = info.main_cyclic[i_main];
527 const bool profile_cyclic = info.profile_cyclic[i_profile];
532 fn(CombinationInfo{i_main,
538 curves::segments_num(main_points.size(), main_cyclic),
539 curves::segments_num(profile_points.size(), profile_cyclic),
551 const std::optional<float> miter_scale_limit,
557 const bool ignore_profile_position = profile_positions.
size() == 1 &&
559 if (ignore_profile_position) {
576 if (ignore_profile_position) {
600 const int profile_point_num,
604 const int ring_vert_start = i_ring * profile_point_num;
605 dst.
slice(ring_vert_start, profile_point_num).
fill(src[i_ring]);
611 const int profile_point_num,
612 const int main_segment_num,
613 const int profile_segment_num,
616 const int edges_start = profile_point_num * main_segment_num;
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]);
625 const int main_segment_num,
626 const int profile_segment_num,
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]);
646 return mesh_attributes.
add(
657 if (dst.
size() !=
main.evaluated_points_num()) {
682 if (!dst_attribute) {
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));
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));
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));
719 case AttrDomain::Corner:
723 BLI_assert_unreachable();
727 dst_attribute.finish();
732 const int main_point_num,
735 for (
const int i_ring :
IndexRange(main_point_num)) {
736 const int profile_vert_start = i_ring * src.
size();
738 dst[profile_vert_start + i_profile] = src[i_profile];
745 const int main_segment_num,
749 const int profile_edge_offset = i_profile * main_segment_num;
750 dst.
slice(profile_edge_offset, main_segment_num).
fill(src[i_profile]);
756 const int main_segment_num,
757 const int profile_segment_num,
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];
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));
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));
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));
798 case AttrDomain::Corner:
802 BLI_assert_unreachable();
819 for (const int i : range) {
820 dst.slice(mesh_offsets[i]).fill(src[curve_indices[i]]);
833 switch (dst_domain) {
835 offsets = mesh_offsets.
vert;
838 offsets = mesh_offsets.
edge;
841 offsets = mesh_offsets.
face;
844 offsets = mesh_offsets.
loop;
851 copy_indices_to_offset_ranges(src.typed<T>(), curve_indices, offsets, dst.typed<T>());
882 handle_types_left.
slice(points),
883 handle_types_right.
slice(points),
892 const bool fill_caps,
893 const std::optional<float> miter_limit_angle,
898 const std::optional<float> miter_scale_limit = [&]() -> std::optional<float> {
899 if (!miter_limit_angle) {
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);
917 mesh->attribute_storage.wrap().remove(
"position");
951 sharp_faces.
span[cap_face_offset] =
true;
952 sharp_faces.
span[cap_face_offset + 1] =
true;
961 main.ensure_can_interpolate_to_evaluated();
965 mesh->tag_overlapping_none();
968 mesh->tag_loose_verts_none();
971 mesh->tag_loose_edges_none();
988 const int profile_edges_start = main_edges_start +
990 const int last_ring_edge_offset = profile_edges_start +
1004 {iter.domain, iter.data_type},
1024 curves_info, iter.
name, offsets, dst_domain, src, eval_buffer, mesh_attributes);
1028 iter.
name, dst_domain, type);
1048 {iter.domain, iter.data_type},
1066 iter.
name, dst_domain, type);
1092 curves.offsets_for_write().last() = 1;
Low-level operations for curves.
CustomData interface, see also DNA_customdata_types.h.
#define BLI_assert_unreachable()
const T & last(const int64_t n=0) const
const CPPType & type() const
const void * data() const
CommonVArrayInfo common_info() const
GSpan get_internal_span() const
const CPPType & type() 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
constexpr void fill(const T &value) const
constexpr Span slice(int64_t start, int64_t size) const
constexpr const T & first() const
constexpr int64_t size() const
constexpr IndexRange index_range() const
constexpr bool is_empty() const
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
IndexRange index_range() const
float3x3 scale(float3x3 mat, float2 scale)
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)
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)
void parallel_for(const IndexRange range, const int64_t grain_size, const Function &function, const TaskSizeHints &size_hints=detail::TaskSizeHints_Static(1))
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
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
static MatBase identity()
bool allow_skip(const StringRef name) const
IndexRange profile_points
const CurvesGeometry & profile
VArraySpan< bool > profile_cyclic
const CurvesGeometry & main
VArraySpan< bool > main_cyclic
const ImplicitSharingInfo * sharing_info
bool any_single_point_profile
Array< int > main_indices
bool any_single_point_main
Array< int > profile_indices
MutableVArraySpan< T > span