23 if (zone.
depth >= 0) {
44 zone_output_nodes.
extend(tree.nodes_by_type(zone_type->output_idname));
46 for (
const bNode *
node : zone_output_nodes) {
47 auto zone = std::make_unique<bNodeTreeZone>();
49 zone->index = zones.
size();
50 zone->output_node_id =
node->identifier;
51 r_zone_by_inout_node.
add(
node, zone.get());
52 zones.
append(std::move(zone));
55 for (
const bNode *input_node : tree.nodes_by_type(zone_type->input_idname)) {
56 if (
const bNode *output_node = zone_type->get_corresponding_output(tree, *input_node)) {
58 zone->input_node_id = input_node->identifier;
59 r_zone_by_inout_node.
add(input_node, zone);
65 for (
const std::unique_ptr<bNodeTreeZone> &zone : zones) {
66 if (!zone->input_node_id || !zone->output_node_id) {
67 r_zone_by_inout_node.
clear();
93 const int zone_i = zone->index;
94 for (
const bNode *
node : {zone->output_node()}) {
95 if (
node ==
nullptr) {
98 const BoundedBitSpan depend_on_input_flags = depend_on_input_flag_array[
node->index()];
100 if (parent_zone_i != zone_i) {
101 all_zone_relations.
add_new({all_zones[parent_zone_i], zone});
107 for (
const ZoneRelation &relation : all_zone_relations) {
108 const ZoneRelation reverse_relation{relation.child, relation.parent};
109 if (all_zone_relations.
contains(reverse_relation)) {
117 for (
const int a : all_zone_relations.
index_range()) {
128 const int transitive_relation_i = all_zone_relations.
index_of_try(transitive_relation);
129 if (transitive_relation_i != -1) {
134 std::ranges::sort(transitive_relations, std::greater<>());
137 for (
const int i : transitive_relations) {
141 return zone_relations;
151 bool found_node_in_multiple_zones =
false;
154 const BoundedBitSpan depend_on_input_flags = depend_on_input_flag_array[node_i];
161 if (parent_zone ==
nullptr) {
168 if (iter_zone == parent_zone) {
177 if (iter_zone == zone) {
182 found_node_in_multiple_zones =
true;
184 if (parent_zone ==
nullptr) {
190 r_zone_by_node_id.
add(
node.identifier, parent_zone->
index);
194 r_zone_by_node_id.
add_overwrite(item.key->identifier, item.value->index);
196 return found_node_in_multiple_zones;
201 tree.ensure_topology_cache();
202 for (
const bNodeLink *link : tree.all_links()) {
203 if (!link->is_available()) {
206 if (link->is_muted()) {
209 if (link->fromnode->is_dangling_reroute()) {
216 if (from_zone == to_zone) {
221 zone->border_links.append(link);
228 tree.ensure_topology_cache();
229 if (tree.has_available_link_cycle()) {
236 std::unique_ptr<bNodeTreeZones> tree_zones = std::make_unique<bNodeTreeZones>();
237 tree_zones->tree = &tree;
241 tree_zones->zones_ptrs =
find_zone_nodes(tree, *tree_zones, zone_by_inout_node);
242 for (
const std::unique_ptr<bNodeTreeZone> &zone : tree_zones->zones_ptrs) {
243 tree_zones->zones.append(zone.get());
246 const int zones_num = tree_zones->zones.size();
247 const int nodes_num = all_nodes.
size();
255 const int node_i =
node->index();
261 if (!input_socket->is_available()) {
264 for (
const bNodeLink *link : input_socket->directly_linked_links()) {
265 if (link->is_muted()) {
268 const bNode &from_node = *link->fromnode;
269 const int from_node_i = from_node.index();
270 depend_on_input_flags |= depend_on_input_flag_array[from_node_i];
271 depend_on_output_flags |= depend_on_output_flag_array[from_node_i];
277 depend_on_input_flags[zone->index].set();
283 if (
const bNode *zone_input_node = zone->input_node()) {
284 const int input_node_i = zone_input_node->index();
285 depend_on_input_flags |= depend_on_input_flag_array[input_node_i];
286 depend_on_output_flags |= depend_on_output_flag_array[input_node_i];
289 depend_on_input_flags[zone->index].reset();
290 depend_on_output_flags[zone->index].set();
301 tree_zones->zones, depend_on_input_flag_array);
302 if (!zone_relations) {
309 relation.parent->child_zones.append(relation.child);
310 BLI_assert(relation.child->parent_zone ==
nullptr);
311 relation.child->parent_zone = relation.parent;
317 for (
bNodeTreeZone *zone = main_zone; zone; zone = zone->parent_zone) {
318 if (!found_zones.
add(zone)) {
331 if (zone->depth == 0) {
332 tree_zones->root_zones.append(zone);
339 depend_on_input_flag_array,
341 tree_zones->zone_by_node_id,
342 tree_zones->node_ids_outside_zones);
343 if (found_node_in_multiple_zones) {
347 for (
const UString output_idname : {
"NodeGroupOutput"_ustr,
348 "ShaderNodeOutputMaterial"_ustr,
349 "ShaderNodeOutputLight"_ustr,
350 "ShaderNodeOutputWorld"_ustr,
351 "ShaderNodeOutputAOV"_ustr})
353 for (
const bNode *
node : tree.nodes_by_type(output_idname)) {
354 if (tree_zones->zone_by_node_id.contains(
node->identifier)) {
363 const int zone_i = tree_zones->zone_by_node_id.lookup_default(
node->identifier, -1);
382 tree.ensure_topology_cache();
399 for (
const bNodeTreeZone *zone = zones->
zones[zone_i]; zone; zone = zone->parent_zone) {
421 if (zone ==
nullptr) {
425 if (socket.is_input()) {
430 if (socket.is_output()) {
443 return this->
zones[zone_i];
449 if (from_zone == to_zone) {
480 zones_to_enter.
append(zone);
482 std::reverse(zones_to_enter.
begin(), zones_to_enter.
end());
483 return zones_to_enter;
493 const bNode &output_bnode)
const
495 tree.ensure_topology_cache();
496 for (
const bNode *
node : tree.nodes_by_type(this->input_idname)) {
505 const bNode &input_bnode)
const
512 return const_cast<bNode *
>(
518 return const_cast<bNode *
>(
543 node_types.
append(zone_type->input_type);
544 node_types.
append(zone_type->output_type);
556 node_types.
append(zone_type->input_type);
568 node_types.
append(zone_type->output_type);
578 if (
ELEM(node_type, zone_type->input_type, zone_type->output_type)) {
604 for (
const int i :
nodes.index_range()) {
605 nodes[i] = tree.node_by_id(node_ids[i]);
633 stream << zone.
index <<
": Parent index: ";
644 stream <<
"; Border Links: {\n";
void ensure(const FunctionRef< void()> compute_cache)
bool add_overwrite(const Key &key, const Value &value)
bool add(const Key &key, const Value &value)
Value lookup_default(const Key &key, const Value &default_value) const
bool contains(const Key &key) const
ItemIterator items() const &
constexpr int64_t size() const
constexpr IndexRange index_range() const
constexpr bool contains(const T &value) const
int64_t index_of_try(const Key &key) const
IndexRange index_range() const
bool contains(const Key &key) const
Span< Key > as_span() const
void add_new(const Key &key)
void remove_and_reorder(const int64_t index)
void append(const T &value)
void extend(Span< T > array)
void append_non_duplicates(const T &value)
CacheMutex tree_zones_cache_mutex
std::shared_ptr< bNodeTreeZones > tree_zones
std::shared_ptr< bNodeTreeZones > last_valid_zones
bool contains_zone_recursively(const bNodeTreeZone &other_zone) const
Vector< int > child_node_ids
Vector< const bNode * > child_nodes() const
bNodeTreeZone * parent_zone
friend std::ostream & operator<<(std::ostream &stream, const bNodeTreeZone &zone)
std::optional< int > output_node_id
const bNode * output_node() const
Vector< const bNodeLink * > border_links
bool contains_node_recursively(const bNode &node) const
std::optional< int > input_node_id
const bNode * input_node() const
Vector< const bNodeTreeZone * > get_zones_to_enter_from_root(const bNodeTreeZone *zone) const
Vector< const bNodeTreeZone * > get_zones_to_enter(const bNodeTreeZone *outer_zone, const bNodeTreeZone *inner_zone) const
bool link_between_zones_is_allowed(const bNodeTreeZone *from_zone, const bNodeTreeZone *to_zone) const
Vector< int > node_ids_outside_zones
Vector< const bNode * > nodes_outside_zones() const
Vector< bNodeTreeZone * > zones
const bNodeTreeZone * get_zone_by_node(const int32_t node_id) const
Map< int, int > zone_by_node_id
friend std::ostream & operator<<(std::ostream &stream, const bNodeTreeZones &zones)
const bNodeTreeZone * get_zone_by_socket(const bNodeSocket &socket) const
bool link_between_sockets_is_allowed(const bNodeSocket &from, const bNodeSocket &to) const
const bNode * get_corresponding_input(const bNodeTree &tree, const bNode &output_bnode) const
virtual const int & get_corresponding_output_id(const bNode &input_bnode) const =0
const bNode * get_corresponding_output(const bNodeTree &tree, const bNode &input_bnode) const
bool has_common_set_bits(const BitSpanT &...args)
void foreach_1_index(const BitSpanT &data, Fn &&fn)
const bNodeZoneType * zone_type_by_node_type(const int node_type)
static void update_zone_depths(bNodeTreeZone &zone)
static std::optional< Vector< ZoneRelation > > get_direct_zone_relations(const Span< bNodeTreeZone * > all_zones, const BitGroupVector<> &depend_on_input_flag_array)
static Vector< const bNodeZoneType * > & get_zone_types_vector()
static Vector< std::unique_ptr< bNodeTreeZone > > find_zone_nodes(const bNodeTree &tree, bNodeTreeZones &owner, Map< const bNode *, bNodeTreeZone * > &r_zone_by_inout_node)
Span< int > all_zone_output_node_types()
static void update_zone_border_links(const bNodeTree &tree, bNodeTreeZones &tree_zones)
Span< const bNodeZoneType * > all_zone_types()
static Vector< const bNode * > node_ids_to_vector(const bNodeTree &tree, const Vector< int > &node_ids)
Span< int > all_zone_node_types()
void register_node_zone_type(const bNodeZoneType &zone_type)
Span< int > all_zone_input_node_types()
static std::unique_ptr< bNodeTreeZones > discover_tree_zones(const bNodeTree &tree)
const bNodeTreeZones * get_tree_zones(const bNodeTree &tree)
static bool update_zone_per_node(const Span< const bNode * > all_nodes, const Span< bNodeTreeZone * > all_zones, const BitGroupVector<> &depend_on_input_flag_array, const Map< const bNode *, bNodeTreeZone * > &zone_by_inout_node, Map< int, int > &r_zone_by_node_id, Vector< int > &r_node_outside_zones)
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
unsigned __int64 uint64_t
constexpr uint64_t get_default_hash(const T &v, const Args &...args)
bke::bNodeTreeRuntime * runtime
friend bool operator==(const ZoneRelation &a, const ZoneRelation &b)=default