1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
|
/* SPDX-License-Identifier: GPL-2.0-or-later */
#include "BKE_curves.hh"
#include "BLI_task.hh"
#include "node_geometry_util.hh"
namespace blender::nodes::node_geo_curve_topology_points_of_curve_cc {
static void node_declare(NodeDeclarationBuilder &b)
{
b.add_input<decl::Int>(N_("Curve Index"))
.implicit_field(implicit_field_inputs::index)
.description(N_("The curve to retrieve data from. Defaults to the curve from the context"));
b.add_input<decl::Float>(N_("Weights"))
.supports_field()
.hide_value()
.description(N_("Values used to sort the curve's points. Uses indices by default"));
b.add_input<decl::Int>(N_("Sort Index"))
.min(0)
.supports_field()
.description(N_("Which of the sorted points to output"));
b.add_output<decl::Int>(N_("Point Index"))
.dependent_field()
.description(N_("A point of the curve, chosen by the sort index"));
b.add_output<decl::Int>(N_("Total"))
.dependent_field()
.description(N_("The number of points in the curve"));
}
class PointsOfCurveInput final : public bke::CurvesFieldInput {
const Field<int> curve_index_;
const Field<int> sort_index_;
const Field<float> sort_weight_;
public:
PointsOfCurveInput(Field<int> curve_index, Field<int> sort_index, Field<float> sort_weight)
: bke::CurvesFieldInput(CPPType::get<int>(), "Point of Curve"),
curve_index_(std::move(curve_index)),
sort_index_(std::move(sort_index)),
sort_weight_(std::move(sort_weight))
{
category_ = Category::Generated;
}
GVArray get_varray_for_context(const bke::CurvesGeometry &curves,
const eAttrDomain domain,
const IndexMask mask) const final
{
const bke::CurvesFieldContext context{curves, domain};
fn::FieldEvaluator evaluator{context, &mask};
evaluator.add(curve_index_);
evaluator.add(sort_index_);
evaluator.evaluate();
const VArray<int> curve_indices = evaluator.get_evaluated<int>(0);
const VArray<int> indices_in_sort = evaluator.get_evaluated<int>(1);
const bke::CurvesFieldContext point_context{curves, ATTR_DOMAIN_POINT};
fn::FieldEvaluator point_evaluator{point_context, curves.points_num()};
point_evaluator.add(sort_weight_);
point_evaluator.evaluate();
const VArray<float> all_sort_weights = point_evaluator.get_evaluated<float>(0);
Array<int> point_of_curve(mask.min_array_size());
threading::parallel_for(mask.index_range(), 256, [&](const IndexRange range) {
/* Reuse arrays to avoid allocation. */
Array<float> sort_weights;
Array<int> sort_indices;
for (const int selection_i : mask.slice(range)) {
const int curve_i = curve_indices[selection_i];
const int index_in_sort = indices_in_sort[selection_i];
if (!curves.curves_range().contains(curve_i)) {
point_of_curve[selection_i] = 0;
continue;
}
const IndexRange points = curves.points_for_curve(curve_i);
/* Retrieve the weights for each point. */
sort_weights.reinitialize(points.size());
all_sort_weights.materialize_compressed(IndexMask(points), sort_weights.as_mutable_span());
/* Sort a separate array of compressed indices corresponding to the compressed weights.
* This allows using `materialize_compressed` to avoid virtual function call overhead
* when accessing values in the sort weights. However, it means a separate array of
* indices within the compressed array is necessary for sorting. */
sort_indices.reinitialize(points.size());
std::iota(sort_indices.begin(), sort_indices.end(), 0);
std::stable_sort(sort_indices.begin(), sort_indices.end(), [&](int a, int b) {
return sort_weights[a] < sort_weights[b];
});
const int index_in_sort_wrapped = mod_i(index_in_sort, points.size());
point_of_curve[selection_i] = points[sort_indices[index_in_sort_wrapped]];
}
});
return VArray<int>::ForContainer(std::move(point_of_curve));
}
uint64_t hash() const override
{
return 26978695677882;
}
bool is_equal_to(const fn::FieldNode &other) const override
{
if (const auto *typed = dynamic_cast<const PointsOfCurveInput *>(&other)) {
return typed->curve_index_ == curve_index_ && typed->sort_index_ == sort_index_ &&
typed->sort_weight_ == sort_weight_;
}
return false;
}
};
class CurvePointCountInput final : public bke::CurvesFieldInput {
public:
CurvePointCountInput() : bke::CurvesFieldInput(CPPType::get<int>(), "Curve Point Count")
{
category_ = Category::Generated;
}
GVArray get_varray_for_context(const bke::CurvesGeometry &curves,
const eAttrDomain domain,
const IndexMask /*mask*/) const final
{
if (domain != ATTR_DOMAIN_CURVE) {
return {};
}
return VArray<int>::ForFunc(curves.curves_num(), [&, curves](const int64_t curve_i) {
return curves.points_num_for_curve(curve_i);
});
}
uint64_t hash() const final
{
return 903847569873762;
}
bool is_equal_to(const fn::FieldNode &other) const final
{
if (dynamic_cast<const CurvePointCountInput *>(&other)) {
return true;
}
return false;
}
};
static void node_geo_exec(GeoNodeExecParams params)
{
const Field<int> curve_index = params.extract_input<Field<int>>("Curve Index");
if (params.output_is_required("Total")) {
params.set_output("Total",
Field<int>(std::make_shared<FieldAtIndexInput>(
curve_index,
Field<int>(std::make_shared<CurvePointCountInput>()),
ATTR_DOMAIN_CURVE)));
}
if (params.output_is_required("Point Index")) {
params.set_output("Point Index",
Field<int>(std::make_shared<PointsOfCurveInput>(
curve_index,
params.extract_input<Field<int>>("Sort Index"),
params.extract_input<Field<float>>("Weights"))));
}
}
} // namespace blender::nodes::node_geo_curve_topology_points_of_curve_cc
void register_node_type_geo_curve_topology_points_of_curve()
{
namespace file_ns = blender::nodes::node_geo_curve_topology_points_of_curve_cc;
static bNodeType ntype;
geo_node_type_base(
&ntype, GEO_NODE_CURVE_TOPOLOGY_POINTS_OF_CURVE, "Points of Curve", NODE_CLASS_INPUT);
ntype.geometry_node_execute = file_ns::node_geo_exec;
ntype.declare = file_ns::node_declare;
nodeRegisterType(&ntype);
}
|
