Blender V5.3
list_function_eval.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2025 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
9#include "BLI_array_utils.hh"
10#include "NOD_geometry_exec.hh"
14
15#include "list_function_eval.hh"
16
17namespace blender::nodes {
18
20 const IndexMask &mask,
21 ResourceScope & /*scope*/) const
22{
23 const auto *id_field_input = dynamic_cast<const bke::IDAttributeFieldInput *>(&field_input);
24
25 const auto *index_field_input = dynamic_cast<const fn::IndexFieldInput *>(&field_input);
26
27 if (id_field_input == nullptr && index_field_input == nullptr) {
28 return {};
29 }
30
32}
33
35{
36 const CPPType &cpp_type = field.cpp_type();
37 GArray array(cpp_type, count);
38
39 ListFieldContext context{};
40 fn::FieldEvaluator evaluator{context, count};
41 evaluator.add_with_destination(std::move(field), array);
42 evaluator.evaluate();
43
44 return GList::from_garray(std::move(array));
45}
46
48{
49 mf::SignatureBuilder builder{"Sample Index", signature_};
50 builder.single_input<int>("Index");
51 builder.single_output("Value", list_->cpp_type());
52 this->set_signature(&signature_);
53}
54
56 mf::Params params,
57 mf::Context /*context*/) const
58{
59 const VArraySpan<int> indices = params.readonly_single_input<int>(0, "Index");
60 GMutableSpan dst = params.uninitialized_single_output(1, "Value");
61
62 IndexMaskMemory memory;
63 const IndexMask valid_indices = array_utils::indices_in_range(
64 mask, indices, IndexRange(list_->size()), memory);
65
66 if (valid_indices.size() != mask.size()) {
67 const IndexMask invalid_indices = valid_indices.complement(mask, memory);
68 list_->cpp_type().fill_construct_indices(
69 list_->cpp_type().default_value(), dst.data(), invalid_indices);
70 }
71
72 const GList::DataVariant &data = list_->data();
73 if (const auto *array_data = std::get_if<nodes::GList::ArrayData>(&data)) {
74 const GSpan src(list_->cpp_type(), array_data->data, list_->size());
75 valid_indices.foreach_index(
76 [&](const int i) { list_->cpp_type().copy_construct(src[indices[i]], dst[i]); });
77 }
78 else if (const auto *single_data = std::get_if<nodes::GList::SingleData>(&data)) {
79 list_->cpp_type().fill_construct_indices(single_data->value, dst.data(), valid_indices);
80 }
81}
82
84{
85 static constexpr int8_t id = 0;
86 hash.add(&id);
87 hash.add(list_.get());
88}
89
91{
92 if (list->size() >= dst_size) {
93 return list;
94 }
95 if (const auto *data = std::get_if<nodes::GList::ArrayData>(&list->data())) {
96 const int64_t size = list->size();
97 BLI_assert(size > 0);
98 const CPPType &cpp_type = list->cpp_type();
99 GArray new_data(cpp_type, dst_size, NoInitialization{});
100 const int64_t chunks = dst_size / size;
101 for (const int64_t i : IndexRange(chunks)) {
102 cpp_type.copy_construct_n(data->data, new_data[i * size], size);
103 }
104 const int64_t last_chunk_size = dst_size % size;
105 if (last_chunk_size > 0) {
106 cpp_type.copy_construct_n(data->data, new_data[chunks * size], last_chunk_size);
107 }
108
109 return GList::from_garray(std::move(new_data));
110 }
111 if (const auto *data = std::get_if<nodes::GList::SingleData>(&list->data())) {
112 const CPPType &cpp_type = list->cpp_type();
113 return GList::create(cpp_type, *data, dst_size);
114 }
116 return {};
117}
118
119static void add_list_to_params(mf::ParamsBuilder &params,
120 const mf::ParamType &param_type,
121 const GList &list)
122{
123 const CPPType &cpp_type = param_type.data_type().single_type();
124 BLI_assert(cpp_type == list.cpp_type());
125 if (const auto *array_data = std::get_if<nodes::GList::ArrayData>(&list.data())) {
126 params.add_readonly_single_input(GSpan(cpp_type, array_data->data, list.size()));
127 }
128 else if (const auto *single_data = std::get_if<nodes::GList::SingleData>(&list.data())) {
129 params.add_readonly_single_input(GPointer(cpp_type, single_data->value));
130 }
131}
132
134 const int64_t output_size,
135 const MultiFunction &fn,
136 const std::shared_ptr<MultiFunction> &owned_fn,
137 const Span<SocketValueVariant *> input_values,
138 const Span<SocketValueVariant *> output_values,
139 GeoNodesUserData *user_data,
140 std::string &r_error_message)
141{
142 /* Prepare output arrays. */
143 Array<Array<SocketValueVariant>, 8> output_lists(output_values.size());
144 for (const int output_i : output_values.index_range()) {
145 output_lists[output_i].reinitialize(output_size);
146 }
147 /* Evaluate field inputs. */
148 Array<GListPtr, 8> fields_as_lists(input_values.size());
149 for (const int input_i : input_values.index_range()) {
150 const SocketValueVariant &input_variant = *input_values[input_i];
151 if (input_variant.is_context_dependent_field()) {
152 fields_as_lists[input_i] = evaluate_field_to_list(input_variant.copy_as<fn::GField>(),
153 output_size);
154 }
155 }
156
157 std::atomic<bool> error_occurred = false;
158 Mutex error_mutex;
159
160 /* Evaluate each list index individually, potentially in parallel. */
161 threading::parallel_for(IndexRange(output_size), 64, [&](const IndexRange range) {
162 Array<SocketValueVariant, 8> inputs(input_values.size());
163 Array<SocketValueVariant *, 8> input_ptrs(input_values.size());
164 for (const int input_i : input_values.index_range()) {
165 input_ptrs[input_i] = &inputs[input_i];
166 }
167 for (const int iter_i : range) {
168 if (error_occurred.load()) {
169 return;
170 }
171 /* Prepare inputs. */
172 for (const int input_i : input_values.index_range()) {
173 const mf::ParamType param_type = fn.param_type(input_i);
174 const CPPType &cpp_type = param_type.data_type().single_type();
175 const SocketValueVariant &input_variant = *input_values[input_i];
176 SocketValueVariant &elem_input = inputs[input_i];
177
178 auto store_default_single = [&]() {
179 void *ptr = elem_input.allocate_single(cpp_type);
180 cpp_type.copy_construct(cpp_type.default_value(), ptr);
181 };
182
183 auto handle_input_list = [&](const GListPtr &list) {
184 if (list) {
185 if (list->size() == 0) {
186 store_default_single();
187 }
188 else if (list->cpp_type().is<SocketValueVariant>()) {
189 elem_input = list->typed<SocketValueVariant>().varray()[iter_i % list->size()];
190 }
191 else if (list->cpp_type() == cpp_type) {
192 void *ptr = elem_input.allocate_single(cpp_type);
193 list->varray().get_to_uninitialized(iter_i % list->size(), ptr);
194 }
195 else {
196 store_default_single();
198 }
199 }
200 else {
201 store_default_single();
202 }
203 };
204
205 if (input_variant.is_list()) {
206 handle_input_list(*input_variant.get_if<GListPtr>());
207 }
208 else if (input_variant.is_context_dependent_field()) {
209 handle_input_list(fields_as_lists[input_i]);
210 }
211 else if (input_variant.is_single()) {
212 elem_input = input_variant;
213 }
214 else {
216 }
217 }
218 Array<SocketValueVariant *, 8> output_ptrs(output_values.size());
219 for (const int output_i : output_values.index_range()) {
220 if (output_values[output_i]) {
221 output_ptrs[output_i] = &output_lists[output_i][iter_i];
222 }
223 else {
224 /* This output is ignored. */
225 output_ptrs[output_i] = nullptr;
226 }
227 }
228 std::string sub_error_message;
230 fn, owned_fn, input_ptrs, output_ptrs, user_data, sub_error_message))
231 {
232 std::lock_guard lock{error_mutex};
233 error_occurred.store(true);
234 r_error_message = sub_error_message;
235 return;
236 }
237 }
238 });
239 if (error_occurred.load()) {
240 return false;
241 }
242 for (const int output_i : output_values.index_range()) {
243 if (output_values[output_i]) {
244 output_values[output_i]->emplace<GListPtr>(
245 GList::from_container(std::move(output_lists[output_i])));
246 }
247 }
248 return true;
249}
250
252 const MultiFunction &fn,
253 const std::shared_ptr<MultiFunction> &owned_fn,
254 const Span<SocketValueVariant *> input_values,
255 const Span<SocketValueVariant *> output_values,
256 GeoNodesUserData *user_data,
257 std::string &r_error_message)
258{
259 int64_t max_size = 0;
260 bool evaluate_individual = false;
261 for (const int i : input_values.index_range()) {
262 SocketValueVariant &input_variant = *input_values[i];
263 const mf::ParamType param_type = fn.param_type(i);
264 const CPPType &cpp_type = param_type.data_type().single_type();
265 if (input_variant.is_list()) {
266 if (GListPtr list = *input_variant.get_if<nodes::GListPtr>()) {
267 max_size = std::max(max_size, list->size());
268 if (list->cpp_type() != cpp_type) {
269 evaluate_individual = true;
270 }
271 }
272 }
273 }
274
275 if (evaluate_individual) {
276 /* Can't use a single MultiFunction evaluation, because a list contains more complex types. */
278 max_size, fn, owned_fn, input_values, output_values, user_data, r_error_message);
279 }
280
281 const IndexMask mask(max_size);
282 mf::ParamsBuilder params{fn, &mask};
283 mf::ContextBuilder context;
284 context.user_data(user_data);
285
286 Array<GListPtr, 8> input_lists(input_values.size());
287 for (const int i : input_values.index_range()) {
288 const mf::ParamType param_type = fn.param_type(params.next_param_index());
289 const CPPType &cpp_type = param_type.data_type().single_type();
290 SocketValueVariant &input_variant = *input_values[i];
291 if (input_variant.is_single()) {
292 const void *value = input_variant.get().get();
293 params.add_readonly_single_input(GPointer(cpp_type, value));
294 }
295 else if (input_variant.is_list()) {
296 GListPtr list_ptr = std::move(*input_variant.get_if<GListPtr>());
297 if (!list_ptr || list_ptr->size() == 0) {
298 params.add_readonly_single_input(GPointer(cpp_type, cpp_type.default_value()));
299 continue;
300 }
301 input_lists[i] = create_repeated_list(std::move(list_ptr), max_size);
302 add_list_to_params(params, param_type, *input_lists[i]);
303 }
304 else if (input_variant.is_context_dependent_field()) {
305 fn::GField field = std::move(*input_variant.get_if<fn::GField>());
306 input_lists[i] = evaluate_field_to_list(std::move(field), max_size);
307 add_list_to_params(params, param_type, *input_lists[i]);
308 }
309 else {
310 /* This function should not be called when there are other types like grids in the inputs. */
312 params.add_readonly_single_input(GPointer(cpp_type, cpp_type.default_value()));
313 }
314 }
315 for (const int i : output_values.index_range()) {
316 if (output_values[i] == nullptr) {
317 params.add_ignored_single_output("");
318 continue;
319 }
320 SocketValueVariant &output_variant = *output_values[i];
321 const mf::ParamType param_type = fn.param_type(params.next_param_index());
322 const CPPType &cpp_type = param_type.data_type().single_type();
323 GArray array(cpp_type, max_size, NoInitialization{});
324
325 params.add_uninitialized_single_output(GMutableSpan(cpp_type, array.data(), max_size));
326 output_variant.emplace<GListPtr>(GList::from_garray(std::move(array)));
327 }
328 fn.call(mask, params, context);
329 return true;
330}
331
332} // namespace blender::nodes
volatile int lock
#define BLI_assert_unreachable()
void reinitialize(const int64_t new_size)
Definition BLI_array.hh:430
void copy_construct_n(const void *src, void *dst, int64_t n) const
void copy_construct(const void *src, void *dst) const
const void * default_value() const
GPointer()=default
const void * get() const
GSpan()=default
constexpr IndexRange()=default
constexpr int64_t size() const
Definition BLI_span.hh:256
constexpr IndexRange index_range() const
Definition BLI_span.hh:405
void * allocate_single(const CPPType &type)
int add_with_destination(GField field, GVMutableArray dst)
const CPPType & cpp_type() const
Definition FN_field.hh:518
static GVArray get_index_varray(const IndexMask &mask)
Definition field.cc:536
void foreach_index(Fn &&fn, Mode mode=exec_mode::serial) const
IndexMask complement(const IndexMask &universe, LinearAllocator<> &memory) const
static GListPtr from_garray(GArray<> array)
static GListPtr from_container(ContainerT &&container)
std::variant< ArrayData, SingleData > DataVariant
static GListPtr create(const CPPType &type, DataVariant data, const int64_t size)
GVArray get_varray_for_input(const FieldInput &field_input, const IndexMask &mask, ResourceScope &) const override
void call(const IndexMask &mask, mf::Params params, mf::Context) const override
void hash_unique(UniqueHashBytes &hash) const override
IndexMask indices_in_range(const IndexMask &universe, Span< int > values, IndexRange range, LinearAllocator<> &memory)
GListPtr evaluate_field_to_list(GField field, const int64_t count)
static bool execute_multi_function_on_value_variant__list_individual(const int64_t output_size, const MultiFunction &fn, const std::shared_ptr< MultiFunction > &owned_fn, const Span< SocketValueVariant * > input_values, const Span< SocketValueVariant * > output_values, GeoNodesUserData *user_data, std::string &r_error_message)
bool execute_multi_function_on_value_variant__list(const MultiFunction &fn, const std::shared_ptr< MultiFunction > &owned_fn, const Span< SocketValueVariant * > input_values, const Span< SocketValueVariant * > output_values, GeoNodesUserData *user_data, std::string &r_error_message)
bool execute_multi_function_on_value_variant(const MultiFunction &fn, const std::shared_ptr< MultiFunction > &owned_fn, const Span< SocketValueVariant * > input_values, const Span< SocketValueVariant * > output_values, GeoNodesUserData *user_data, std::string &r_error_message)
static GListPtr create_repeated_list(GListPtr list, const int64_t dst_size)
static void add_list_to_params(mf::ParamsBuilder &params, const mf::ParamType &param_type, const GList &list)
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
BMesh const char void * data
std::mutex Mutex
Definition BLI_mutex.hh:51
signed char int8_t
Definition BKE_text.h:76
#define hash
Definition noise_c.cc:156