Blender V5.3
node_geo_menu_switch.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_array_utils.hh"
6
9
10#include "DNA_node_types.h"
11
12#include "FN_multi_function.hh"
13
15#include "UI_resources.hh"
16
18#include "NOD_rna_define.hh"
19#include "NOD_socket.hh"
24
25#include "BLO_read_write.hh"
26
27#include "RNA_enum_types.hh"
28#include "RNA_prototypes.hh"
29
31#include "BKE_screen.hh"
32
33#include "WM_api.hh"
34
35#include "COM_node_operation.hh"
36#include "COM_result.hh"
37#include "COM_utilities.hh"
38
39namespace blender {
40
42
44
46{
47 b.use_custom_socket_order();
48 b.allow_any_socket_order();
49
50 const bNodeTree *ntree = b.tree_or_null();
51 const bNode *node = b.node_or_null();
52 if (node == nullptr) {
53 return;
54 }
55 const NodeMenuSwitch &storage = node_storage(*node);
56 const eNodeSocketDatatype data_type = storage.data_type;
57
58 StructureType value_structure_type = StructureType::Dynamic;
59 StructureType menu_structure_type = value_structure_type;
60
61 if (ntree->type == NTREE_COMPOSIT) {
62 const bool is_single_compositor_type = compositor::Result::is_single_value_only_type(
64 if (is_single_compositor_type) {
65 value_structure_type = StructureType::Single;
66 }
67 menu_structure_type = StructureType::Single;
68 }
69
70 b.add_output(data_type, "Output"_ustr)
71 .propagate_all()
72 .inferred_structure_type()
73 .structure_type(value_structure_type);
74
75 b.add_default_layout();
76
77 auto &menu = b.add_input<decl::Menu>("Menu"_ustr);
78 menu.default_value(MenuValue(storage.enum_definition.items().is_empty() ?
79 0 :
80 storage.enum_definition.items().first().identifier));
81 menu.structure_type(menu_structure_type);
82 menu.optional_label();
83
84 for (const NodeEnumItem &enum_item : storage.enum_definition.items()) {
85 const UString name(enum_item.name);
87 auto &input = b.add_input(data_type, name, identifier)
88 .socket_name_ptr(
89 &ntree->id, *MenuSwitchItemsAccessor::item_srna, &enum_item, "name")
90 .compositor_realization_mode(CompositorInputRealizationMode::None)
91 .description("Becomes the output value if it is chosen by the menu input");
92 /* Labels are ugly in combination with data-block pickers and are usually disabled. */
93 input.optional_label(ELEM(data_type,
101 SOCK_MASK,
102 SOCK_SOUND));
103 input.structure_type(value_structure_type);
104 b.add_output<decl::Bool>(name, identifier)
105 .align_with_previous()
106 .description("True if this item is chosen by the menu input")
107 .inferred_structure_type({menu.index()})
108 .propagate_references({menu.index()});
109 }
110
111 b.add_input<decl::Extend>(""_ustr, "__extend__"_ustr)
112 .structure_type(StructureType::Dynamic)
113 .custom_draw(socket_items::ui::draw_extend_socket_fn<MenuSwitchItemsAccessor>());
114}
115
116static void node_layout(ui::Layout &layout, bContext * /*C*/, PointerRNA *ptr)
117{
118 layout.prop(ptr, "data_type", UI_ITEM_NONE, "", ICON_NONE);
119}
120
121static void node_init(bNodeTree *tree, bNode *node)
122{
123 NodeMenuSwitch *data = MEM_new<NodeMenuSwitch>(__func__);
124 data->data_type = tree->type == NTREE_GEOMETRY ? SOCK_GEOMETRY : SOCK_RGBA;
125 data->enum_definition.next_identifier = 0;
126 data->enum_definition.items_array = nullptr;
127 data->enum_definition.items_num = 0;
128 node->storage = data;
129
132}
133
135{
137 MEM_delete(reinterpret_cast<NodeMenuSwitch *>(node->storage));
138}
139
140static void node_copy_storage(bNodeTree * /*dst_tree*/, bNode *dst_node, const bNode *src_node)
141{
142 const NodeMenuSwitch &src_storage = node_storage(*src_node);
143 NodeMenuSwitch *dst_storage = MEM_new<NodeMenuSwitch>(__func__, dna::shallow_copy(src_storage));
144 dst_node->storage = dst_storage;
145
147}
148
150{
151 const eNodeSocketDatatype data_type = params.other_socket().type;
152 if (params.in_out() == SOCK_IN) {
153 if (data_type == SOCK_MENU) {
154 params.add_item(IFACE_("Menu"), [](LinkSearchOpParams &params) {
155 bNode &node = params.add_node("GeometryNodeMenuSwitch"_ustr);
156 params.update_and_connect_available_socket(node, "Menu"_ustr);
157 });
158 }
159 }
160 else {
161 if (data_type != SOCK_MENU) {
162 params.add_item(IFACE_("Output"), [](LinkSearchOpParams &params) {
163 bNode &node = params.add_node("GeometryNodeMenuSwitch"_ustr);
164 node_storage(node).data_type = params.socket.type;
165 params.update_and_connect_available_socket(node, "Output"_ustr);
166 });
167 }
168 }
169}
170
175class MenuSwitchFn : public mf::MultiFunction {
176 const NodeEnumDefinition &enum_def_;
177 const CPPType &type_;
178 mf::Signature signature_;
179
180 public:
181 MenuSwitchFn(const NodeEnumDefinition &enum_def, const CPPType &type)
182 : enum_def_(enum_def), type_(type)
183 {
184 mf::SignatureBuilder builder{"Menu Switch", signature_};
185 builder.single_input<MenuValue>("Menu");
186 for (const NodeEnumItem &enum_item : enum_def.items()) {
187 builder.single_input(enum_item.name, type);
188 }
189 builder.single_output("Output", type, mf::ParamFlag::SupportsUnusedOutput);
190 this->set_signature(&signature_);
191 }
192
193 void call(const IndexMask &mask, mf::Params params, mf::Context /*context*/) const override
194 {
195 const int value_inputs_start = 1;
196 const int inputs_num = enum_def_.items_num;
197 const VArray<MenuValue> values = params.readonly_single_input<MenuValue>(0, "Menu");
198 /* Use one extra mask at the end for invalid indices. */
199 const int invalid_index = inputs_num;
200
201 GMutableSpan value_output = params.uninitialized_single_output_if_required(1 + inputs_num,
202 "Output");
203
204 auto find_item_index = [&](const MenuValue value) -> int {
205 for (const int i : enum_def_.items().index_range()) {
206 const NodeEnumItem &item = enum_def_.items()[i];
207 if (item.identifier == value.value) {
208 return i;
209 }
210 }
211 return invalid_index;
212 };
213
214 if (const std::optional<MenuValue> value = values.get_if_single()) {
215 const int index = find_item_index(*value);
216 if (index < inputs_num) {
217 if (!value_output.is_empty()) {
218 const GVArray inputs = params.readonly_single_input(value_inputs_start + index);
219 inputs.materialize_to_uninitialized(mask, value_output.data());
220 }
221 }
222 else {
223 if (!value_output.is_empty()) {
224 type_.fill_construct_indices(type_.default_value(), value_output.data(), mask);
225 }
226 }
227 return;
228 }
229
230 IndexMaskMemory memory;
231 Array<IndexMask> masks(inputs_num + 1);
233 mask, memory, [&](const int64_t i) { return find_item_index(values[i]); }, masks);
234
235 for (const int item_i : IndexRange(inputs_num)) {
236 const IndexMask &mask_for_index = masks[item_i];
237 if (!mask_for_index.is_empty() && !value_output.is_empty()) {
238 const GVArray inputs = params.readonly_single_input(value_inputs_start + item_i);
239 inputs.materialize_to_uninitialized(mask_for_index, value_output.data());
240 }
241 }
242
243 type_.fill_construct_indices(type_.default_value(), value_output.data(), masks[invalid_index]);
244 }
245
246 void hash_unique(UniqueHashBytes &hash) const override
247 {
248 static constexpr int8_t id = 0;
249 hash.add(&id);
250 hash.add(&type_);
251 hash.add(&enum_def_);
252 }
253};
254
255class MenuSwitchBoolsFn : public mf::MultiFunction {
256 private:
257 const NodeEnumDefinition &enum_def_;
258 mf::Signature signature_;
259
260 public:
261 MenuSwitchBoolsFn(const NodeEnumDefinition &enum_def) : enum_def_(enum_def)
262 {
263 mf::SignatureBuilder builder{"Menu Switch Bools", signature_};
264 builder.single_input<MenuValue>("Menu");
265 for (const NodeEnumItem &enum_item : enum_def.items()) {
266 builder.single_output(
267 enum_item.name, CPPType::get<bool>(), mf::ParamFlag::SupportsUnusedOutput);
268 }
269 this->set_signature(&signature_);
270 }
271
272 void call(const IndexMask &mask, mf::Params params, mf::Context /*context*/) const override
273 {
274 const VArray<MenuValue> values = params.readonly_single_input<MenuValue>(0, "Menu");
275
276 Array<MutableSpan<bool>> item_spans(enum_def_.items_num);
277 Vector<int> used_output_items;
278 for (const int item_i : IndexRange(enum_def_.items_num)) {
279 item_spans[item_i] = params.uninitialized_single_output_if_required<bool>(1 + item_i);
280 if (!item_spans[item_i].is_empty()) {
281 used_output_items.append(item_i);
282 }
283 }
284
285 if (const std::optional<MenuValue> value = values.get_if_single()) {
286 for (const int item_i : used_output_items) {
287 const NodeEnumItem &enum_item = enum_def_.items()[item_i];
288 const bool is_selected = enum_item.identifier == value->value;
289 index_mask::masked_fill(item_spans[item_i], is_selected, mask);
290 }
291 return;
292 }
293
294 mask.foreach_index([&](const int i) {
295 const MenuValue value = values[i];
296 for (const int item_i : used_output_items) {
297 const NodeEnumItem &enum_item = enum_def_.items_array[item_i];
298 const bool is_selected = value.value == enum_item.identifier;
299 item_spans[item_i][i] = is_selected;
300 }
301 });
302 }
303
304 void hash_unique(UniqueHashBytes &hash) const override
305 {
306 static constexpr int8_t id = 0;
307 hash.add(&id);
308 hash.add(&enum_def_);
309 }
310};
311
312class LazyFunctionForMenuSwitchNode : public LazyFunction {
313 private:
314 const bNode &node_;
315 bool can_be_field_ = false;
316 const NodeEnumDefinition &enum_def_;
317 const CPPType *field_base_type_;
318
319 public:
322 : node_(node), enum_def_(node_storage(node).enum_definition)
323 {
324 const NodeMenuSwitch &storage = node_storage(node);
325 const eNodeSocketDatatype data_type = storage.data_type;
326 can_be_field_ = socket_type_supports_fields(data_type);
327 const bke::bNodeSocketType *socket_type = bke::node_socket_type_find_static(data_type);
328 BLI_assert(socket_type != nullptr);
329 field_base_type_ = socket_type->base_cpp_type;
330
331 MutableSpan<int> lf_index_by_bsocket = lf_graph_info.mapping.lf_index_by_bsocket;
332 debug_name_ = node.name;
333 lf_index_by_bsocket[node.input_socket(0).index_in_tree()] = inputs_.append_and_get_index_as(
334 "Switch", CPPType::get<SocketValueVariant>(), lf::ValueUsage::Used);
335 for (const int i : enum_def_.items().index_range()) {
336 const NodeEnumItem &enum_item = enum_def_.items()[i];
337 lf_index_by_bsocket[node.input_socket(i + 1).index_in_tree()] =
338 inputs_.append_and_get_index_as(
339 enum_item.name, CPPType::get<bke::SocketValueVariant>(), lf::ValueUsage::Maybe);
340 }
341 lf_index_by_bsocket[node.output_socket(0).index_in_tree()] = outputs_.append_and_get_index_as(
343 }
344
345 void execute_impl(lf::Params &params, const lf::Context & /*context*/) const override
346 {
347 SocketValueVariant condition_variant = params.get_input<SocketValueVariant>(0);
348 if (condition_variant.is_context_dependent_field() && can_be_field_) {
349 this->execute_field(condition_variant.ensure_type<Field<MenuValue>>(), params);
350 }
351 else {
352 this->execute_single(condition_variant.ensure_type<MenuValue>(), params);
353 }
354 }
355
356 void execute_single(const MenuValue condition, lf::Params &params) const
357 {
358 bool output_was_set = false;
359 for (const int i : IndexRange(enum_def_.items_num)) {
360 const NodeEnumItem &enum_item = enum_def_.items_array[i];
361 const int input_index = i + 1;
362 const bool is_selected = enum_item.identifier == condition.value;
363 if (is_selected) {
364 SocketValueVariant *value_to_forward =
365 params.try_get_input_data_ptr_or_request<SocketValueVariant>(input_index);
366 if (value_to_forward == nullptr) {
367 /* Try again when the value is available. */
368 return;
369 }
370
371 params.set_output(0, std::move(*value_to_forward));
372 output_was_set = true;
373 }
374 else {
375 params.set_input_unused(input_index);
376 }
377 }
378 if (!output_was_set) {
379 /* No guarantee that the switch input matches any enum,
380 * set default outputs to ensure valid state. */
381 set_default_value_for_output_socket(params, 0, node_.output_socket(0));
382 }
383 }
384
385 void execute_field(Field<MenuValue> condition, lf::Params &params) const
386 {
387 /* When the condition is a non-constant field, we need all inputs. */
388 const int values_num = this->enum_def_.items_num;
389 Array<SocketValueVariant *, 8> input_values(values_num);
390 for (const int i : IndexRange(values_num)) {
391 const int input_index = i + 1;
392 input_values[i] = params.try_get_input_data_ptr_or_request<SocketValueVariant>(input_index);
393 }
394 if (input_values.as_span().contains(nullptr)) {
395 /* Try again when inputs are available. */
396 return;
397 }
398
399 Vector<GField> item_fields;
400 item_fields.reserve(enum_def_.items_num + 1);
401 item_fields.append(std::move(condition));
402 for (const int i : IndexRange(enum_def_.items_num)) {
403 item_fields.append(input_values[i]->extract<GField>());
404 }
405 std::unique_ptr<MultiFunction> multi_function = std::make_unique<MenuSwitchFn>(
406 enum_def_, *field_base_type_);
407 fn::FieldOperationPtr operation = FieldOperation::from(std::move(multi_function),
408 std::move(item_fields));
409
410 params.set_output(0, SocketValueVariant::from(GField(operation, 0)));
411 }
412};
413
414class LazyFunctionMenuSwitchBooleanOutputs : public LazyFunction {
415 private:
416 const NodeEnumDefinition &enum_def_;
417 bool can_be_field_ = false;
419
420 public:
423 : enum_def_(node_storage(node).enum_definition), fn_(enum_def_)
424 {
425 debug_name_ = node.name;
426 const NodeMenuSwitch &storage = node_storage(node);
427 can_be_field_ = socket_type_supports_fields(storage.data_type);
428
429 MutableSpan<int> lf_index_by_bsocket = lf_graph_info.mapping.lf_index_by_bsocket;
430 lf_index_by_bsocket[node.input_socket(0).index_in_tree()] = inputs_.append_and_get_index_as(
431 "Switch", CPPType::get<SocketValueVariant>(), lf::ValueUsage::Used);
432 for (const int i : enum_def_.items().index_range()) {
433 const NodeEnumItem &enum_item = enum_def_.items_array[i];
434 lf_index_by_bsocket[node.output_socket(i + 1).index_in_tree()] =
435 outputs_.append_and_get_index_as(enum_item.name, CPPType::get<SocketValueVariant>());
436 }
437 }
438
439 void execute_impl(lf::Params &params, const lf::Context &context) const override
440 {
441 GeoNodesUserData *user_data = dynamic_cast<GeoNodesUserData *>(context.user_data);
442 SocketValueVariant condition_variant = params.get_input<SocketValueVariant>(0);
443 if (condition_variant.is_single()) {
444 this->execute_single(condition_variant.ensure_type<MenuValue>(), params);
445 return;
446 }
447
448 Array<SocketValueVariant *> input_values = {&condition_variant};
449 Array<SocketValueVariant *> output_values(enum_def_.items_num, nullptr);
450 for (const int i : IndexRange(enum_def_.items_num)) {
451 if (params.get_output_usage(i) != lf::ValueUsage::Unused) {
452 output_values[i] = static_cast<SocketValueVariant *>(params.get_output_data_ptr(i));
453 new (output_values[i]) SocketValueVariant(false);
454 }
455 }
456 std::string error_message;
458 fn_, input_values, output_values, user_data, error_message))
459 {
460 /* Is set to default value already. */
461 }
462 for (const int i : IndexRange(enum_def_.items_num)) {
463 if (output_values[i]) {
464 params.output_set(i);
465 }
466 }
467 }
468
469 void execute_single(const MenuValue condition, lf::Params &params) const
470 {
471 for (const int i : IndexRange(enum_def_.items_num)) {
472 const NodeEnumItem &enum_item = enum_def_.items_array[i];
473 const bool is_selected = enum_item.identifier == condition.value;
474 params.set_output(i, SocketValueVariant(is_selected));
475 }
476 }
477};
478
484class LazyFunctionForMenuSwitchSocketUsage : public lf::LazyFunction {
485 const NodeEnumDefinition &enum_def_;
486
487 public:
489 : enum_def_(node_storage(node).enum_definition)
490 {
491 debug_name_ = "Menu Switch Socket Usage";
492 inputs_.append_as("Condition", CPPType::get<SocketValueVariant>());
493 for (const int i : IndexRange(enum_def_.items_num)) {
494 const NodeEnumItem &enum_item = enum_def_.items()[i];
495 outputs_.append_as(enum_item.name, CPPType::get<bool>());
496 }
497 }
498
499 void execute_impl(lf::Params &params, const lf::Context & /*context*/) const override
500 {
501 const SocketValueVariant &condition_variant = params.get_input<SocketValueVariant>(0);
502 if (condition_variant.is_context_dependent_field()) {
503 for (const int i : IndexRange(enum_def_.items_num)) {
504 params.set_output(i, true);
505 }
506 }
507 else {
508 const MenuValue value = condition_variant.copy_as<MenuValue>();
509 for (const int i : IndexRange(enum_def_.items_num)) {
510 const NodeEnumItem &enum_item = enum_def_.items()[i];
511 params.set_output(i, value.value == enum_item.identifier);
512 }
513 }
514 }
515};
516
517using namespace blender::compositor;
518
520 public:
522
523 void execute() override
524 {
525 Result &value_output = this->get_result("Output");
526 const MenuValue menu_identifier = this->get_input("Menu").get_single_value<MenuValue>();
527 const NodeEnumDefinition &enum_definition = node_storage(node()).enum_definition;
528 bool found_item = false;
529
530 for (const int i : IndexRange(enum_definition.items_num)) {
531 const NodeEnumItem &enum_item = enum_definition.items()[i];
532 const std::string identifier = MenuSwitchItemsAccessor::socket_identifier_for_item(
533 enum_item);
534 const bool is_selected = enum_item.identifier == menu_identifier.value;
535 Result &item_output = this->get_result(identifier);
536 if (item_output.should_compute()) {
537 item_output.allocate_single_value();
538 item_output.set_single_value(is_selected);
539 }
540 if (!is_selected) {
541 continue;
542 }
543 const Result &input = this->get_input(identifier);
544 value_output.share_data(input);
545 found_item = true;
546 }
547
548 if (!found_item) {
549 /* The menu identifier didn't match any item, so allocate an invalid output. */
550 value_output.allocate_invalid();
551 }
552 }
553};
554
556{
557 return new MenuSwitchOperation(context, node);
558}
559
560static void node_layout_ex(ui::Layout &layout, bContext *C, PointerRNA *ptr)
561{
562 bNodeTree &tree = *reinterpret_cast<bNodeTree *>(ptr->owner_id);
563 bNode &node = *static_cast<bNode *>(ptr->data);
564
565 layout.prop(ptr, "data_type", UI_ITEM_NONE, "", ICON_NONE);
566
567 if (ui::Layout *panel = layout.panel(C, "menu_switch_items", false, IFACE_("Menu Items"))) {
568 socket_items::ui::draw_items_list_with_operators<MenuSwitchItemsAccessor>(
569 C, panel, tree, node);
570 socket_items::ui::draw_active_item_props<MenuSwitchItemsAccessor>(
571 tree, node, [&](PointerRNA *item_ptr) {
572 panel->use_property_split_set(true);
573 panel->use_property_decorate_set(false);
574 panel->prop(item_ptr, "description", UI_ITEM_NONE, std::nullopt, ICON_NONE);
575 });
576 }
577}
578
583
589
590static void node_blend_write(const bNodeTree & /*ntree*/, const bNode &node, BlendWriter &writer)
591{
593}
594
599
601 const bNode &node,
602 const bNodeSocket &output_socket)
603{
604 const NodeMenuSwitch &storage = node_storage(node);
605 if (storage.enum_definition.items_num == 0) {
606 return nullptr;
607 }
608 if (&output_socket == node.outputs.first_) {
609 /* Default to the first enum item input. */
610 return &node.input_socket(1);
611 }
612 return nullptr;
613}
614
616 PointerRNA *ptr,
617 PropertyRNA * /*prop*/,
618 bool *r_free)
619{
620 *r_free = true;
621 const bNodeTree &ntree = *reinterpret_cast<bNodeTree *>(ptr->owner_id);
622 bke::bNodeTreeType *ntree_type = ntree.typeinfo;
623 return enum_items_filter(
626 return ntree_type->valid_socket_type(ntree_type, socket_type);
627 });
628}
629
630static void node_rna(StructRNA *srna)
631{
633 "data_type",
634 "Data Type",
635 "",
640}
641
642static void register_node()
643{
644 static bke::bNodeType ntype;
645
646 common_node_type_base(&ntype, "GeometryNodeMenuSwitch"_ustr, GEO_NODE_MENU_SWITCH);
647 ntype.ui_name = "Menu Switch";
648 ntype.ui_description = "Select from multiple inputs by name";
649 ntype.enum_name_legacy = "MENU_SWITCH";
651 ntype.declare = node_declare;
652 ntype.initfunc = node_init;
665
666 node_rna(ntype.rna_ext.srna);
667}
669
670} // namespace nodes::node_geo_menu_switch_cc
671
672namespace nodes {
673
674std::unique_ptr<LazyFunction> get_menu_switch_node_lazy_function(
675 const bNode &node, GeometryNodesLazyFunctionGraphInfo &lf_graph_info)
676{
677 using namespace node_geo_menu_switch_cc;
678 BLI_assert(node.type_legacy == GEO_NODE_MENU_SWITCH);
679 return std::make_unique<LazyFunctionForMenuSwitchNode>(node, lf_graph_info);
680}
681
683 const bNode &node, GeometryNodesLazyFunctionGraphInfo &lf_graph_info)
684{
685 using namespace node_geo_menu_switch_cc;
686 BLI_assert(node.type_legacy == GEO_NODE_MENU_SWITCH);
687 return std::make_unique<LazyFunctionMenuSwitchBooleanOutputs>(node, lf_graph_info);
688}
689
690std::unique_ptr<LazyFunction> get_menu_switch_node_socket_usage_lazy_function(const bNode &node)
691{
692 using namespace node_geo_menu_switch_cc;
693 BLI_assert(node.type_legacy == GEO_NODE_MENU_SWITCH);
694 return std::make_unique<LazyFunctionForMenuSwitchSocketUsage>(node);
695}
696
698
700{
701 writer->write_string(item.name);
702 writer->write_string(item.description);
703}
704
706{
707 BLO_read_string(reader, &item.name);
708 BLO_read_string(reader, &item.description);
709}
710
711} // namespace nodes
712} // namespace blender
#define NODE_CLASS_CONVERTER
Definition BKE_node.hh:484
#define NODE_STORAGE_FUNCS(StorageT)
Definition BKE_node.hh:1353
#define GEO_NODE_MENU_SWITCH
#define IFACE_(msgid)
#define NOD_REGISTER_NODE(REGISTER_FUNC)
#define NOD_storage_enum_accessors(member)
#define C
Definition RandGen.cpp:29
#define UI_ITEM_NONE
__forceinline float extract(const int4 &b)
Definition binning.cpp:27
#define ELEM(...)
Span< T > as_span() const
Definition BLI_array.hh:254
static const CPPType & get()
void materialize_to_uninitialized(void *dst) const
static void from_groups(const IndexMask &universe, LinearAllocator<> &memory, Fn &&get_group_index, MutableSpan< IndexMask > r_masks)
constexpr IndexRange()=default
std::optional< T > get_if_single() const
NodeOperation(Context &context, const bNode &node)
Result & get_result(StringRef identifier)
Definition operation.cc:40
Result & get_input(StringRef identifier) const
Definition operation.cc:35
void share_data(const Result &source)
Definition result.cc:996
bool should_compute() const
Definition result.cc:1124
static bool is_single_value_only_type(ResultType type)
Definition result.cc:51
void set_single_value(const T &value)
const T & get_single_value() const
static FieldOperationPtr from(std::shared_ptr< const mf::MultiFunction > fn, Vector< GField > inputs)
Definition field.cc:252
void add_item(std::string socket_name, SocketLinkOperation::LinkSocketFn fn, int weight=0)
void update_and_connect_available_socket(bNode &new_node, UString socket_name)
static SocketValueVariant from(T &&value)
void execute_impl(lf::Params &params, const lf::Context &) const override
void execute_single(const MenuValue condition, lf::Params &params) const
LazyFunctionForMenuSwitchNode(const bNode &node, GeometryNodesLazyFunctionGraphInfo &lf_graph_info)
void execute_field(Field< MenuValue > condition, lf::Params &params) const
void execute_impl(lf::Params &params, const lf::Context &) const override
void execute_impl(lf::Params &params, const lf::Context &context) const override
void execute_single(const MenuValue condition, lf::Params &params) const
LazyFunctionMenuSwitchBooleanOutputs(const bNode &node, GeometryNodesLazyFunctionGraphInfo &lf_graph_info)
void call(const IndexMask &mask, mf::Params params, mf::Context) const override
void hash_unique(UniqueHashBytes &hash) const override
MenuSwitchFn(const NodeEnumDefinition &enum_def, const CPPType &type)
void call(const IndexMask &mask, mf::Params params, mf::Context) const override
#define storage(slot, qualifiers)
#define condition(cond)
void node_register_type(bNodeType &ntype)
Definition node.cc:2920
bNodeSocketType * node_socket_type_find_static(int type, int subtype=0)
Definition node.cc:2975
void node_type_storage(bNodeType &ntype, std::optional< StringRefNull > storagename, void(*freefunc)(bNode *node), void(*copyfunc)(bNodeTree *dest_ntree, bNode *dest_node, const bNode *src_node))
Definition node.cc:6166
ResultType socket_data_type_to_result_type(const eNodeSocketDatatype data_type, const std::optional< int > dimensions=std::nullopt)
Definition utilities.cc:39
internal::ShallowDataConstRef< T > shallow_copy(const T &other)
Definition DNA_defs.h:147
ImplicitSharingPtr< FieldOperation > FieldOperationPtr
Definition FN_field.hh:44
void masked_fill(MutableSpan< T > data, const T &value, const IndexMask &mask)
static void node_blend_write(const bNodeTree &, const bNode &node, BlendWriter &writer)
static void node_layout(ui::Layout &layout, bContext *, PointerRNA *ptr)
static void node_blend_read(bNodeTree &, bNode &node, BlendDataReader &reader)
static void node_copy_storage(bNodeTree *, bNode *dst_node, const bNode *src_node)
static void node_gather_link_searches(GatherLinkSearchOpParams &params)
static const bNodeSocket * node_internally_linked_input(const bNodeTree &, const bNode &node, const bNodeSocket &output_socket)
static void node_declare(nodes::NodeDeclarationBuilder &b)
static void node_init(bNodeTree *tree, bNode *node)
static const EnumPropertyItem * data_type_items_callback(bContext *, PointerRNA *ptr, PropertyRNA *, bool *r_free)
static void node_layout_ex(ui::Layout &layout, bContext *C, PointerRNA *ptr)
static bool node_insert_link(bke::NodeInsertLinkParams &params)
static NodeOperation * get_compositor_operation(Context &context, const bNode &node)
void blend_write(BlendWriter *writer, const bNode &node)
Accessor::ItemT * add_item_with_name(bNode &node, const char *name)
void blend_read_data(BlendDataReader *reader, bNode &node)
void copy_array(const bNode &src_node, bNode &dst_node)
bool try_add_item_via_any_extend_socket(bNodeTree &ntree, bNode &extend_node, bNode &storage_node, bNodeLink &link, const std::optional< StringRef > socket_identifier=std::nullopt, typename Accessor::ItemT **r_new_item=nullptr)
PropertyRNA * RNA_def_node_enum(StructRNA *srna, const char *identifier, const char *ui_name, const char *ui_description, const EnumPropertyItem *static_items, const EnumRNAAccessors accessors, std::optional< int > default_value, const EnumPropertyItemFunc item_func, const bool allow_animation)
std::unique_ptr< LazyFunction > get_menu_switch_node_socket_usage_lazy_function(const bNode &node)
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)
bool socket_type_supports_fields(const eNodeSocketDatatype socket_type)
std::unique_ptr< LazyFunction > get_menu_switch_node_boolean_outputs_lazy_function(const bNode &node, GeometryNodesLazyFunctionGraphInfo &lf_graph_info)
void set_default_value_for_output_socket(lf::Params &params, const int lf_index, const bNodeSocket &bsocket)
std::unique_ptr< LazyFunction > get_menu_switch_node_lazy_function(const bNode &node, GeometryNodesLazyFunctionGraphInfo &lf_graph_info)
const EnumPropertyItem * enum_items_filter(const EnumPropertyItem *original_item_array, FunctionRef< bool(const EnumPropertyItem &item)> fn)
BMesh Iterators.
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
const EnumPropertyItem rna_enum_node_socket_data_type_items[]
void BLO_read_string(BlendDataReader *reader, char **ptr_p)
Definition readfile.cc:6653
signed char int8_t
Definition BKE_text.h:76
void common_node_type_base(bke::bNodeType *ntype, UString idname, const std::optional< int16_t > legacy_type)
#define hash
Definition noise_c.cc:156
void write_string(const char *data)
eNodeSocketDatatype type
bke::bNodeTreeType * typeinfo
eNodeTree_Type type
Defines a socket type.
Definition BKE_node.hh:163
const CPPType * base_cpp_type
Definition BKE_node.hh:210
bool(*) valid_socket_type(bNodeTreeType *ntreetype, bNodeSocketType *socket_type)
Definition BKE_node.hh:569
Defines a node type.
Definition BKE_node.hh:265
NodeInternallyLinkedInputFunction internally_linked_input
Definition BKE_node.hh:415
void(*) draw_buttons(ui::Layout &, bContext *C, PointerRNA *ptr)
Definition BKE_node.hh:290
NodeBlendWriteFunction blend_write_storage_content
Definition BKE_node.hh:421
void(*) register_operators()
Definition BKE_node.hh:448
std::string ui_description
Definition BKE_node.hh:271
NodeBlendDataReadFunction blend_data_read_storage_content
Definition BKE_node.hh:422
NodeGetCompositorOperationFunction get_compositor_operation
Definition BKE_node.hh:379
void(*) draw_buttons_ex(ui::Layout &, bContext *C, PointerRNA *ptr)
Definition BKE_node.hh:292
void(*) initfunc(bNodeTree *ntree, bNode *node)
Definition BKE_node.hh:320
const char * enum_name_legacy
Definition BKE_node.hh:274
NodeGatherSocketLinkOperationsFunction gather_link_search_ops
Definition BKE_node.hh:409
NodeDeclareFunction declare
Definition BKE_node.hh:393
bool ignore_inferred_input_socket_visibility
Definition BKE_node.hh:453
bool(*) insert_link(NodeInsertLinkParams &params)
Definition BKE_node.hh:364
static std::string socket_identifier_for_item(const NodeEnumItem &item)
static void blend_write_item(BlendWriter *writer, const ItemT &item)
static void blend_read_data_item(BlendDataReader *reader, ItemT &item)
PanelLayout panel(const bContext *C, StringRef idname, bool default_closed)
void prop(PointerRNA *ptr, PropertyRNA *prop, int index, int value, eUI_Item_Flag flag, std::optional< StringRef > name_opt, int icon, std::optional< StringRef > placeholder=std::nullopt)
void reserve(int new_size)
Definition vector.hh:78