Blender V5.3
node_geo_input_tangent.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
5#include "BLI_task.hh"
6
7#include "BKE_curves.hh"
8
10
12
14{
15 b.add_output<decl::Vector>("Tangent"_ustr).structure_type(StructureType::Field);
16}
17
19{
20 const OffsetIndices points_by_curve = curves.points_by_curve();
21 const OffsetIndices evaluated_points_by_curve = curves.evaluated_points_by_curve();
22 const VArray<int8_t> types = curves.curve_types();
23 const VArray<int> resolutions = curves.resolution();
24 const VArray<bool> cyclic = curves.cyclic();
25 const Span<float3> positions = curves.positions();
26
27 const Span<float3> evaluated_tangents = curves.evaluated_tangents();
28
29 Array<float3> results(curves.points_num());
30
31 threading::parallel_for(curves.curves_range(), 128, [&](IndexRange range) {
32 for (const int i_curve : range) {
33 const IndexRange points = points_by_curve[i_curve];
34 const IndexRange evaluated_points = evaluated_points_by_curve[i_curve];
35
36 MutableSpan<float3> curve_tangents = results.as_mutable_span().slice(points);
37
38 switch (types[i_curve]) {
39 case CURVE_TYPE_CATMULL_ROM: {
40 Span<float3> tangents = evaluated_tangents.slice(evaluated_points);
41 const int resolution = resolutions[i_curve];
42 for (const int i : IndexRange(points.size())) {
43 curve_tangents[i] = tangents[resolution * i];
44 }
45 break;
46 }
47 case CURVE_TYPE_POLY:
48 curve_tangents.copy_from(evaluated_tangents.slice(evaluated_points));
49 break;
50 case CURVE_TYPE_BEZIER: {
51 Span<float3> tangents = evaluated_tangents.slice(evaluated_points);
52 curve_tangents.first() = tangents.first();
53 const Span<int> offsets = curves.bezier_evaluated_offsets_for_curve(i_curve);
54 for (const int i : IndexRange(points.size()).drop_front(1)) {
55 curve_tangents[i] = tangents[offsets[i]];
56 }
57 break;
58 }
59 case CURVE_TYPE_NURBS: {
60 const Span<float3> curve_positions = positions.slice(points);
61 bke::curves::poly::calculate_tangents(curve_positions, cyclic[i_curve], curve_tangents);
62 break;
63 }
64 }
65 }
66 });
67 return results;
68}
69
71 const AttrDomain domain)
72{
73 const VArray<int8_t> types = curves.curve_types();
74 if (curves.is_single_type(CURVE_TYPE_POLY)) {
75 return curves.adapt_domain<float3>(
76 VArray<float3>::from_span(curves.evaluated_tangents()), AttrDomain::Point, domain);
77 }
78
80
81 if (domain == AttrDomain::Point) {
82 return VArray<float3>::from_container(std::move(tangents));
83 }
84
85 if (domain == AttrDomain::Curve) {
86 return curves.adapt_domain<float3>(
87 VArray<float3>::from_container(std::move(tangents)), AttrDomain::Point, AttrDomain::Curve);
88 }
89
90 return nullptr;
91}
92
94 public:
95 TangentFieldInput() : bke::CurvesFieldInput(CPPType::get<float3>(), "Tangent node") {}
96
98 const AttrDomain domain,
99 const IndexMask & /*mask*/) const final
100 {
102 }
103
104 void hash_unique(UniqueHashBytes &hash, fn::FieldHashDeep & /*deep_hash_cache*/) const override
105 {
106 static constexpr int8_t id = 0;
107 hash.add(&id);
108 }
109
110 std::optional<AttrDomain> preferred_domain(const bke::CurvesGeometry & /*curves*/) const final
111 {
112 return AttrDomain::Point;
113 }
114};
115
117{
119}
120
121static void node_register()
122{
123 static bke::bNodeType ntype;
124
125 geo_node_type_base(&ntype, "GeometryNodeInputTangent"_ustr, GEO_NODE_INPUT_TANGENT);
126 ntype.ui_name = "Curve Tangent";
127 ntype.ui_description = "Retrieve the direction of curves at each control point";
128 ntype.enum_name_legacy = "INPUT_TANGENT";
129 ntype.nclass = NODE_CLASS_INPUT;
131 ntype.declare = node_declare;
133}
134NOD_REGISTER_NODE(node_register)
135
136} // namespace blender::nodes::node_geo_input_tangent_cc
Low-level operations for curves.
#define NODE_CLASS_INPUT
Definition BKE_node.hh:478
#define GEO_NODE_INPUT_TANGENT
#define final(a, b, c)
Definition BLI_hash_c.hh:21
#define NOD_REGISTER_NODE(REGISTER_FUNC)
static VArray from_span(Span< T > values)
static VArray from_container(ContainerT container)
uint64_t hash() const
Definition field.cc:185
static Field from_input(Args &&...args)
void set_output(const UString identifier, T &&value)
void hash_unique(UniqueHashBytes &hash, fn::FieldHashDeep &) const override
GVArray get_varray_for_context(const bke::CurvesGeometry &curves, const AttrDomain domain, const IndexMask &) const final
std::optional< AttrDomain > preferred_domain(const bke::CurvesGeometry &) const final
void node_register_type(bNodeType &ntype)
Definition node.cc:2920
static VArray< float3 > construct_curve_tangent_gvarray(const bke::CurvesGeometry &curves, const AttrDomain domain)
static Array< float3 > curve_tangent_point_domain(const bke::CurvesGeometry &curves)
static void node_declare(NodeDeclarationBuilder &b)
static void node_geo_exec(GeoNodeExecParams params)
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
VecBase< float, 3 > float3
void geo_node_type_base(bke::bNodeType *ntype, UString idname, const std::optional< int16_t > legacy_type)
signed char int8_t
Definition BKE_text.h:76
Defines a node type.
Definition BKE_node.hh:265
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