Blender V5.3
BKE_node_runtime.hh
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2023 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
9#pragma once
10
11#include <memory>
12
13#include "BLI_cache_mutex.hh"
16#include "BLI_mutex.hh"
17#include "BLI_set.hh"
18#include "BLI_ustring.hh"
19#include "BLI_utility_mixins.hh"
20#include "BLI_vector.hh"
21#include "BLI_vector_set.hh"
22
23#include "DNA_node_types.h"
24
25#include "BKE_node.hh"
27
29#include "NOD_warning.hh"
30
31namespace blender {
32
33struct bNode;
34struct bNodeSocket;
35struct bNodeTree;
36
38 bNodeSocket *in = nullptr;
39 bNodeSocket *out = nullptr;
40
41 friend bool operator==(const bNodeInternalLink &a, const bNodeInternalLink &b) = default;
42};
43
44namespace nodes {
45struct EvalDependencies;
47class NodeDeclaration;
51}
52namespace rl = reference_lifetimes;
53namespace gizmos {
55}
56} // namespace nodes
57namespace bke {
58struct bNodeType;
59class bNodeTreeZones;
60} // namespace bke
61
65
66namespace bke {
67
73
75 int32_t operator()(const bNode *value) const
76 {
77 return value->identifier;
78 }
79};
81
83 std::string tooltip;
84};
85
91 private:
92 int to_node_id_;
93 int input_socket_index_;
94 int input_link_index_;
95
96 public:
98 explicit NodeLinkKey(const bNodeLink &link);
99
100 bNodeLink *try_find(bNodeTree &ntree) const;
101 const bNodeLink *try_find(const bNodeTree &ntree) const;
102
104 {
105 return get_default_hash(this->to_node_id_, this->input_socket_index_, this->input_link_index_);
106 }
107
108 friend bool operator==(const NodeLinkKey &a, const NodeLinkKey &b) = default;
109};
110
120
128 public:
140
146
148 bool is_updating = false;
149
155
157 std::unique_ptr<LoggedZoneGraphs> logged_zone_graphs;
158
165
173
175 std::shared_ptr<nodes::GeneratedTreeSrnaData> geometry_nodes_srna_data;
177 std::shared_ptr<nodes::GeneratedTreeSrnaData> compositor_nodes_srna_data;
179 std::shared_ptr<nodes::GeneratedTreeSrnaData> compositor_effect_nodes_srna_data;
181 std::shared_ptr<nodes::GeneratedTreeSrnaData> scene_compositor_effect_srna_data;
182
184 std::unique_ptr<node_tree_reference_lifetimes::ReferenceLifetimesInfo> reference_lifetimes_info;
185 std::unique_ptr<nodes::gizmos::TreeGizmoPropagation> gizmo_propagation;
186 std::unique_ptr<nodes::StructureTypeInterface> structure_type_interface;
187
194
201 std::shared_ptr<const nodes::GeometryNodesLazyFunctionGraphInfo>
203
208 nullptr;
209
215
222
228 std::atomic<bool> topology_cache_exists = false;
233 mutable std::atomic<int> allow_use_dirty_topology_cache = 0;
234
236 std::shared_ptr<bNodeTreeZones> tree_zones;
237
242 std::shared_ptr<bNodeTreeZones> last_valid_zones;
244
250
257 std::unique_ptr<nodes::EvalDependencies> eval_dependencies;
258
272};
273
329
331 float min_y;
332 float max_y;
333 bool fill_node_end = false;
334};
335
337 public:
343 std::optional<float> header_center_y;
344 std::optional<bNodePanelExtent> content_extent;
347};
348
431
433
438
440 private:
441 const bNodeTree &tree_;
442
443 public:
444 AllowUsingOutdatedInfo(const bNodeTree &tree) : tree_(tree)
445 {
446 tree_.runtime->allow_use_dirty_topology_cache.fetch_add(1);
447 }
448
450 {
451 tree_.runtime->allow_use_dirty_topology_cache.fetch_sub(1);
452 }
453};
454
455/* If result is not true then this means that the last node tree editing operation was not covered
456 * by the topology cache update ensure call. All derivative information about topology is not
457 * available. You should call "tree.ensure_topology_cache();" first.
458 */
460{
461 if (!tree.runtime->topology_cache_exists) {
462 return false;
463 }
464 if (tree.runtime->allow_use_dirty_topology_cache.load() > 0) {
465 return true;
466 }
468 return false;
469 }
470 return true;
471}
472
474{
475 const bNodeTree *ntree = node.runtime->owner_tree;
476 if (ntree == nullptr) {
477 return false;
478 }
479 return topology_cache_is_available(*ntree);
480}
481
482inline bool topology_cache_is_available(const bNodeSocket &socket)
483{
484 const bNode *node = socket.runtime->owner_node;
485 if (node == nullptr) {
486 return false;
487 }
489}
490
491} // namespace node_tree_runtime
492
496
497} // namespace bke
498
499/* -------------------------------------------------------------------- */
502
503inline Span<const bNode *> bNodeTree::all_nodes() const
504{
505 return this->runtime->nodes_by_id.as_span();
506}
507
508inline Span<bNode *> bNodeTree::all_nodes()
509{
510 return this->runtime->nodes_by_id;
511}
512
513inline bNode *bNodeTree::node_by_id(const int32_t identifier)
514{
515 BLI_assert(identifier >= 0);
516 bNode *const *node = this->runtime->nodes_by_id.lookup_key_ptr_as(identifier);
517 return node ? *node : nullptr;
518}
519
520inline const bNode *bNodeTree::node_by_id(const int32_t identifier) const
521{
522 BLI_assert(identifier >= 0);
523 const bNode *const *node = this->runtime->nodes_by_id.lookup_key_ptr_as(identifier);
524 return node ? *node : nullptr;
525}
526
527inline Span<bNode *> bNodeTree::nodes_by_type(const UString type_idname)
528{
530 return this->runtime->nodes_by_type.lookup(bke::node_type_find(type_idname));
531}
532
533inline Span<const bNode *> bNodeTree::nodes_by_type(const UString type_idname) const
534{
536 return this->runtime->nodes_by_type.lookup(bke::node_type_find(type_idname));
537}
538
539inline Span<const bNode *> bNodeTree::toposort_left_to_right() const
540{
542 return this->runtime->toposort_left_to_right;
543}
544
545inline Span<const bNode *> bNodeTree::toposort_right_to_left() const
546{
548 return this->runtime->toposort_right_to_left;
549}
550
551inline Span<bNode *> bNodeTree::toposort_left_to_right()
552{
554 return this->runtime->toposort_left_to_right;
555}
556
557inline Span<bNode *> bNodeTree::toposort_right_to_left()
558{
560 return this->runtime->toposort_right_to_left;
561}
562
563inline Span<const bNode *> bNodeTree::group_nodes() const
564{
566 return this->runtime->group_nodes;
567}
568
569inline Span<bNode *> bNodeTree::group_nodes()
570{
572 return this->runtime->group_nodes;
573}
574
575inline bool bNodeTree::has_available_link_cycle() const
576{
578 return this->runtime->has_available_link_cycle;
579}
580
581inline bool bNodeTree::has_undefined_nodes_or_sockets() const
582{
585}
586
587inline bNode *bNodeTree::group_output_node()
588{
590 return this->runtime->group_output_node;
591}
592
593inline const bNode *bNodeTree::group_output_node() const
594{
596 return this->runtime->group_output_node;
597}
598
599inline Span<bNode *> bNodeTree::group_input_nodes()
600{
601 return this->nodes_by_type("NodeGroupInput"_ustr);
602}
603
604inline Span<const bNode *> bNodeTree::group_input_nodes() const
605{
606 return this->nodes_by_type("NodeGroupInput"_ustr);
607}
608
609inline Span<const bNodeSocket *> bNodeTree::all_input_sockets() const
610{
612 return this->runtime->input_sockets;
613}
614
615inline Span<bNodeSocket *> bNodeTree::all_input_sockets()
616{
618 return this->runtime->input_sockets;
619}
620
621inline Span<const bNodeSocket *> bNodeTree::all_output_sockets() const
622{
624 return this->runtime->output_sockets;
625}
626
627inline Span<bNodeSocket *> bNodeTree::all_output_sockets()
628{
630 return this->runtime->output_sockets;
631}
632
633inline Span<const bNodeSocket *> bNodeTree::all_sockets() const
634{
636 return this->runtime->sockets;
637}
638
639inline Span<bNodeSocket *> bNodeTree::all_sockets()
640{
642 return this->runtime->sockets;
643}
644
645inline Span<bNode *> bNodeTree::root_frames() const
646{
648 return this->runtime->root_frames;
649}
650
651inline Span<bNodeLink *> bNodeTree::all_links()
652{
654 return this->runtime->links;
655}
656
657inline Span<const bNodeLink *> bNodeTree::all_links() const
658{
660 return this->runtime->links;
661}
662
663inline MutableSpan<bNestedNodeRef> bNodeTree::nested_node_refs_span()
664{
665 return {this->nested_node_refs, this->nested_node_refs_num};
666}
667
668inline Span<bNestedNodeRef> bNodeTree::nested_node_refs_span() const
669{
670 return {this->nested_node_refs, this->nested_node_refs_num};
671}
672
673inline void bNodeTree::ensure_interface_cache() const
674{
675 this->tree_interface.ensure_items_cache();
676}
677
678inline Span<bNodeTreeInterfaceSocket *> bNodeTree::interface_inputs()
679{
680 BLI_assert(this->tree_interface.items_cache_is_available());
681 return this->tree_interface.runtime->inputs_;
682}
683
684inline Span<const bNodeTreeInterfaceSocket *> bNodeTree::interface_inputs() const
685{
686 BLI_assert(this->tree_interface.items_cache_is_available());
687 return this->tree_interface.runtime->inputs_.as_span();
688}
689
690inline Span<bNodeTreeInterfaceSocket *> bNodeTree::interface_outputs()
691{
692 BLI_assert(this->tree_interface.items_cache_is_available());
693 return this->tree_interface.runtime->outputs_;
694}
695
696inline Span<const bNodeTreeInterfaceSocket *> bNodeTree::interface_outputs() const
697{
698 BLI_assert(this->tree_interface.items_cache_is_available());
699 return this->tree_interface.runtime->outputs_.as_span();
700}
701
702inline Span<bNodeTreeInterfaceItem *> bNodeTree::interface_items()
703{
704 BLI_assert(this->tree_interface.items_cache_is_available());
705 return this->tree_interface.runtime->items_;
706}
707
708inline Span<const bNodeTreeInterfaceItem *> bNodeTree::interface_items() const
709{
710 BLI_assert(this->tree_interface.items_cache_is_available());
711 return this->tree_interface.runtime->items_.as_span();
712}
713
714inline int bNodeTree::interface_input_index(const bNodeTreeInterfaceSocket &io_socket) const
715{
716 BLI_assert(this->tree_interface.items_cache_is_available());
717 return this->tree_interface.runtime->inputs_.index_of_as(io_socket.identifier);
718}
719
720inline int bNodeTree::interface_output_index(const bNodeTreeInterfaceSocket &io_socket) const
721{
722 BLI_assert(this->tree_interface.items_cache_is_available());
723 return this->tree_interface.runtime->outputs_.index_of_as(io_socket.identifier);
724}
725
726inline int bNodeTree::interface_item_index(const bNodeTreeInterfaceItem &io_item) const
727{
728 BLI_assert(this->tree_interface.items_cache_is_available());
729 return this->tree_interface.runtime->items_.index_of_as(&io_item);
730}
731
732inline int bNodeTree::interface_input_index_by_identifier(const StringRef identifier) const
733{
734 return this->tree_interface.input_index_by_identifier(identifier);
735}
736
737inline int bNodeTree::interface_output_index_by_identifier(const StringRef identifier) const
738{
739 return this->tree_interface.output_index_by_identifier(identifier);
740}
741
743
744/* -------------------------------------------------------------------- */
747
748inline int bNode::index() const
749{
750 const int index = this->runtime->index_in_tree;
751 /* The order of nodes should always be consistent with the `nodes_by_id` vector. */
752 BLI_assert(index ==
753 this->runtime->owner_tree->runtime->nodes_by_id.index_of_as(this->identifier));
754 return index;
755}
756
757inline Span<bNodeSocket *> bNode::input_sockets()
758{
760 return this->runtime->inputs;
761}
762
763inline Span<bNodeSocket *> bNode::output_sockets()
764{
766 return this->runtime->outputs;
767}
768
769inline Span<const bNodeSocket *> bNode::input_sockets() const
770{
772 return this->runtime->inputs;
773}
774
775inline Span<const bNodeSocket *> bNode::output_sockets() const
776{
778 return this->runtime->outputs;
779}
780
781inline IndexRange bNode::input_socket_indices_in_tree() const
782{
784 const int num_inputs = this->runtime->inputs.size();
785 if (num_inputs == 0) {
786 return {};
787 }
788 return IndexRange::from_begin_size(this->input_socket(0).index_in_tree(), num_inputs);
789}
790
791inline IndexRange bNode::output_socket_indices_in_tree() const
792{
794 const int num_outputs = this->runtime->outputs.size();
795 if (num_outputs == 0) {
796 return {};
797 }
798 return IndexRange::from_begin_size(this->output_socket(0).index_in_tree(), num_outputs);
799}
800
801inline IndexRange bNode::input_socket_indices_in_all_inputs() const
802{
804 const int num_inputs = this->runtime->inputs.size();
805 if (num_inputs == 0) {
806 return {};
807 }
808 return IndexRange::from_begin_size(this->input_socket(0).index_in_all_inputs(), num_inputs);
809}
810
811inline IndexRange bNode::output_socket_indices_in_all_outputs() const
812{
814 const int num_outputs = this->runtime->outputs.size();
815 if (num_outputs == 0) {
816 return {};
817 }
818 return IndexRange::from_begin_size(this->output_socket(0).index_in_all_outputs(), num_outputs);
819}
820
821inline bNodeSocket &bNode::input_socket(int index)
822{
824 return *this->runtime->inputs[index];
825}
826
827inline bNodeSocket &bNode::output_socket(int index)
828{
830 return *this->runtime->outputs[index];
831}
832
833inline const bNodeSocket &bNode::input_socket(int index) const
834{
836 return *this->runtime->inputs[index];
837}
838
839inline const bNodeSocket &bNode::output_socket(int index) const
840{
842 return *this->runtime->outputs[index];
843}
844
845inline const bNodeSocket *bNode::input_by_identifier(UString identifier) const
846{
848 return this->runtime->inputs_by_identifier.lookup_default_as(identifier, nullptr);
849}
850
851inline const bNodeSocket *bNode::output_by_identifier(UString identifier) const
852{
854 return this->runtime->outputs_by_identifier.lookup_default_as(identifier, nullptr);
855}
856
857inline bNodeSocket *bNode::input_by_identifier(UString identifier)
858{
860 return this->runtime->inputs_by_identifier.lookup_default_as(identifier, nullptr);
861}
862
863inline bNodeSocket *bNode::output_by_identifier(UString identifier)
864{
866 return this->runtime->outputs_by_identifier.lookup_default_as(identifier, nullptr);
867}
868
869inline const bNodeTree &bNode::owner_tree() const
870{
872 return *this->runtime->owner_tree;
873}
874
875inline bNodeTree &bNode::owner_tree()
876{
878 return *this->runtime->owner_tree;
879}
880
881inline StringRefNull bNode::label_or_name() const
882{
883 if (this->label[0] == '\0') {
884 return this->name;
885 }
886 return this->label;
887}
888
889inline bool bNode::is_muted() const
890{
891 return this->flag & NODE_MUTED;
892}
893
894inline bool bNode::is_selected() const
895{
896 return this->flag & NODE_SELECT;
897}
898
899inline bool bNode::is_reroute() const
900{
901 return this->type_legacy == NODE_REROUTE;
902}
903
904inline bool bNode::is_frame() const
905{
906 return this->type_legacy == NODE_FRAME;
907}
908
909inline bool bNode::is_group() const
910{
912}
913
914inline bool bNode::is_custom_group() const
915{
916 return this->type_legacy == NODE_CUSTOM_GROUP;
917}
918
919inline bool bNode::is_group_input() const
920{
921 return this->type_legacy == NODE_GROUP_INPUT;
922}
923
924inline bool bNode::is_group_output() const
925{
926 return this->type_legacy == NODE_GROUP_OUTPUT;
927}
928
929inline bool bNode::is_undefined() const
930{
931 return this->typeinfo == &bke::NodeTypeUndefined;
932}
933
934inline bool bNode::is_type(const UString query_idname) const
935{
936 return this->typeinfo->is_type(query_idname);
937}
938
939inline Span<bNodeInternalLink> bNode::internal_links() const
940{
941 return this->runtime->internal_links;
942}
943
944inline bool bNode::is_dangling_reroute() const
945{
947 return this->runtime->is_dangling_reroute;
948}
949
950inline Span<bNode *> bNode::direct_children_in_frame() const
951{
953 BLI_assert(this->is_frame());
954 return this->runtime->direct_children_in_frame;
955}
956
957inline const nodes::NodeDeclaration *bNode::declaration() const
958{
959 return this->runtime->declaration;
960}
961
962inline Span<bNodePanelState> bNode::panel_states() const
963{
965}
966
967inline MutableSpan<bNodePanelState> bNode::panel_states()
968{
970}
971
973
974/* -------------------------------------------------------------------- */
977
978inline bool bNodeLink::is_muted() const
979{
980 return this->flag & NODE_LINK_MUTED;
981}
982
983inline bool bNodeLink::is_available() const
984{
985 return this->fromsock->is_available() && this->tosock->is_available();
986}
987
988inline bool bNodeLink::is_used() const
989{
990 return !this->is_muted() && this->is_available();
991}
992
994
995/* -------------------------------------------------------------------- */
998
999inline int bNodeSocket::index() const
1000{
1002 return this->runtime->index_in_node;
1003}
1004
1005inline int bNodeSocket::index_in_tree() const
1006{
1008 return this->runtime->index_in_all_sockets;
1009}
1010
1011inline int bNodeSocket::index_in_all_inputs() const
1012{
1014 BLI_assert(this->is_input());
1015 return this->runtime->index_in_inout_sockets;
1016}
1017
1018inline int bNodeSocket::index_in_all_outputs() const
1019{
1021 BLI_assert(this->is_output());
1022 return this->runtime->index_in_inout_sockets;
1023}
1024
1025inline UString bNodeSocket::identifier_ustr() const
1026{
1027 return this->runtime->identifier_ustr;
1028}
1029
1030inline bool bNodeSocket::is_user_hidden() const
1031{
1032 return (this->flag & SOCK_HIDDEN) != 0;
1033}
1034
1035inline bool bNodeSocket::is_inactive() const
1036{
1037 /* Gray out inputs that do not affect the output of the node currently.
1038 * Don't gray out any inputs if the node has no outputs (in which case no input can affect the
1039 * output). Otherwise, viewer node inputs would be inactive. */
1040 return this->is_input() && !this->affects_node_output() &&
1041 !this->owner_node().output_sockets().is_empty();
1042}
1043
1044inline bool bNodeSocket::is_available() const
1045{
1046 return (this->flag & SOCK_UNAVAIL) == 0;
1047}
1048
1049inline bool bNodeSocket::is_panel_collapsed() const
1050{
1051 return (this->flag & SOCK_PANEL_COLLAPSED) != 0;
1052}
1053
1054inline bool bNodeSocket::is_visible() const
1055{
1056 return !this->is_user_hidden() && this->is_available() && this->inferred_socket_visibility();
1057}
1058
1059inline bool bNodeSocket::is_icon_visible() const
1060{
1061 return this->is_visible() &&
1062 (this->owner_node().flag & NODE_COLLAPSED || !this->is_panel_collapsed());
1063}
1064
1065inline bool bNodeSocket::may_be_field() const
1066{
1067 return ELEM(this->runtime->inferred_structure_type,
1068 nodes::StructureType::Field,
1069 nodes::StructureType::Dynamic);
1070}
1071
1072inline bNode &bNodeSocket::owner_node()
1073{
1075 return *this->runtime->owner_node;
1076}
1077
1078inline const bNodeTree &bNodeSocket::owner_tree() const
1079{
1081 return *this->runtime->owner_node->runtime->owner_tree;
1082}
1083
1084inline bNodeTree &bNodeSocket::owner_tree()
1085{
1087 return *this->runtime->owner_node->runtime->owner_tree;
1088}
1089
1090inline Span<const bNodeSocket *> bNodeSocket::logically_linked_sockets() const
1091{
1093 return this->runtime->logically_linked_sockets;
1094}
1095
1096inline Span<const bNodeLink *> bNodeSocket::directly_linked_links() const
1097{
1099 return this->runtime->directly_linked_links;
1100}
1101
1102inline Span<bNodeLink *> bNodeSocket::directly_linked_links()
1103{
1105 return this->runtime->directly_linked_links;
1106}
1107
1108inline Span<const bNodeSocket *> bNodeSocket::directly_linked_sockets() const
1109{
1111 return this->runtime->directly_linked_sockets;
1112}
1113
1114inline Span<bNodeSocket *> bNodeSocket::directly_linked_sockets()
1115{
1117 return this->runtime->directly_linked_sockets;
1118}
1119
1120inline bool bNodeSocket::is_directly_linked() const
1121{
1122 return !this->directly_linked_links().is_empty();
1123}
1124
1125inline bool bNodeSocket::is_logically_linked() const
1126{
1127 return !this->logically_linked_sockets().is_empty();
1128}
1129
1130inline const bNodeSocket *bNodeSocket::internal_link_input() const
1131{
1133 BLI_assert(this->in_out == SOCK_OUT);
1134 return this->runtime->internal_link_input;
1135}
1136
1137template<typename T> T *bNodeSocket::default_value_typed()
1138{
1139 return static_cast<T *>(this->default_value);
1140}
1141
1142template<typename T> const T *bNodeSocket::default_value_typed() const
1143{
1144 return static_cast<const T *>(this->default_value);
1145}
1146
1147inline bool bNodeSocket::is_input() const
1148{
1149 return this->in_out == SOCK_IN;
1150}
1151
1152inline bool bNodeSocket::is_output() const
1153{
1154 return this->in_out == SOCK_OUT;
1155}
1156
1157inline bool bNodeSocket::is_multi_input() const
1158{
1159 return this->flag & SOCK_MULTI_INPUT;
1160}
1161
1162inline const bNode &bNodeSocket::owner_node() const
1163{
1165 return *this->runtime->owner_node;
1166}
1167
1169
1170/* -------------------------------------------------------------------- */
1173
1174inline bool bNodePanelState::is_collapsed() const
1175{
1176 return flag & NODE_PANEL_COLLAPSED;
1177}
1178
1179inline bool bNodePanelState::is_parent_collapsed() const
1180{
1182}
1183
1184inline bool bNodePanelState::has_visible_content() const
1185{
1187}
1188
1190
1191} // namespace blender
#define NODE_REROUTE
Definition BKE_node.hh:867
#define NODE_CUSTOM_GROUP
Definition BKE_node.hh:870
#define NODE_GROUP_OUTPUT
Definition BKE_node.hh:869
#define NODE_GROUP
Definition BKE_node.hh:865
#define NODE_FRAME
Definition BKE_node.hh:866
#define NODE_GROUP_INPUT
Definition BKE_node.hh:868
#define BLI_assert(a)
#define ELEM(...)
static constexpr IndexRange from_begin_size(const int64_t begin, const int64_t size)
bool is_empty() const
int64_t index_of_as(const ForwardKey &key) const
const Key * lookup_key_ptr_as(const ForwardKey &key) const
Span< Key > as_span() const
std::optional< float > header_center_y
std::optional< bNodePanelExtent > content_extent
Array< bNodePanelRuntime > panels
Vector< bNode * > direct_children_in_frame
Vector< bNodeSocket * > outputs
Map< UString, bNodeSocket * > inputs_by_identifier
Vector< bNodeInternalLink > internal_links
Vector< bNodeSocket * > inputs
Map< UString, bNodeSocket * > outputs_by_identifier
nodes::NodeDeclaration * declaration
Vector< bNodeSocket * > logically_linked_skipped_sockets
Vector< bNodeSocket * > directly_linked_sockets
Vector< bNodeSocket * > logically_linked_sockets
Vector< bNodeLink * > directly_linked_links
nodes::StructureType inferred_structure_type
const nodes::SocketDeclaration * declaration
MultiValueMap< NodeLinkKey, NodeLinkError > link_errors
std::unique_ptr< LoggedZoneGraphs > logged_zone_graphs
Vector< bNodeSocket * > output_sockets
std::unique_ptr< node_tree_reference_lifetimes::ReferenceLifetimesInfo > reference_lifetimes_info
std::shared_ptr< nodes::GeneratedTreeSrnaData > compositor_effect_nodes_srna_data
std::shared_ptr< nodes::GeneratedTreeSrnaData > scene_compositor_effect_srna_data
Array< nodes::socket_usage_inference::SocketUsage > inferenced_socket_usage
Vector< bNodeSocket * > sockets
CacheMutex geometry_nodes_lazy_function_graph_info_mutex
std::unique_ptr< nodes::EvalDependencies > eval_dependencies
std::unique_ptr< nodes::StructureTypeInterface > structure_type_interface
std::unique_ptr< nodes::gizmos::TreeGizmoPropagation > gizmo_propagation
Set< const bNodeSocket * > sockets_on_active_gizmo_paths
std::atomic< bool > topology_cache_exists
std::shared_ptr< const nodes::GeometryNodesLazyFunctionGraphInfo > geometry_nodes_lazy_function_graph_info
MultiValueMap< const bNodeType *, bNode * > nodes_by_type
std::shared_ptr< nodes::GeneratedTreeSrnaData > geometry_nodes_srna_data
std::shared_ptr< bNodeTreeZones > tree_zones
std::shared_ptr< bNodeTreeZones > last_valid_zones
std::atomic< int > allow_use_dirty_topology_cache
Map< int32_t, VectorSet< nodes::NodeWarning > > shader_node_errors
std::shared_ptr< nodes::GeneratedTreeSrnaData > compositor_nodes_srna_data
Vector< bNodeSocket * > input_sockets
const nodes::GeometryNodesLazyFunctionGraphInfo * self_geometry_nodes_lazy_function_graph_info
NonCopyable(const NonCopyable &other)=delete
NonMovable(NonMovable &&other)=delete
#define index(i)
#define T
bool topology_cache_is_available(const bNodeTree &tree)
void preprocess_geometry_node_tree_for_evaluation(bNodeTree &tree_cow)
CustomIDVectorSet< bNode *, NodeIDGetter > NodeIDVectorSet
bNodeType * node_type_find(UString idname)
Definition node.cc:2883
bNodeType NodeTypeUndefined
Definition node.cc:134
BMesh Iterators.
unsigned __int64 uint64_t
Definition BKE_text.h:91
unsigned int uint32_t
Definition BKE_text.h:81
VecBase< float, 2 > float2
VectorSet< T, InlineBufferCapacity, DefaultProbingStrategy, CustomIDHash< T, GetIDFn >, CustomIDEqual< T, GetIDFn > > CustomIDVectorSet
unsigned char uint8_t
Definition BKE_text.h:79
std::mutex Mutex
Definition BLI_mutex.hh:51
signed int int32_t
Definition BKE_text.h:78
@ SOCK_PANEL_COLLAPSED
@ NODE_PANEL_COLLAPSED
@ NODE_PANEL_PARENT_COLLAPSED
@ NODE_PANEL_CONTENT_VISIBLE
constexpr uint64_t get_default_hash(const T &v, const Args &...args)
Definition BLI_hash.hh:252
signed char int8_t
Definition BKE_text.h:76
bke::bNodeSocketRuntime * runtime
eNodeSocketInOut in_out
bke::bNodeTreeInterfaceRuntime * runtime
bNodeTreeInterface tree_interface
bke::bNodeTreeRuntime * runtime
bNestedNodeRef * nested_node_refs
bke::bNodeRuntime * runtime
bNodePanelState * panel_states_array
bke::bNodeType * typeinfo
Map< int, std::string > graph_by_zone_id
int32_t operator()(const bNode *value) const
bNodeLink * try_find(bNodeTree &ntree) const
friend bool operator==(const NodeLinkKey &a, const NodeLinkKey &b)=default
NodeLinkKey(const bNodeLink &link)
Defines a node type.
Definition BKE_node.hh:265
bool is_type(UString query_idname) const
Definition BKE_node.hh:1342