Merge 4f7996b1ea into 760af804c0

editor/tree_search.cpp

@@ -19,7 +19,6 @@
 
 #ifdef LIMBOAI_MODULE
 #include "core/math/math_funcs.h"
-#include "core/templates/hash_set.h"
 #include "editor/editor_interface.h"
 #include "editor/themes/editor_scale.h"
 #include "scene/gui/separator.h"
@@ -35,7 +34,6 @@
 #include <godot_cpp/classes/style_box_flat.hpp>
 #include <godot_cpp/classes/viewport.hpp>
 #include <godot_cpp/core/math.hpp>
-#include <godot_cpp/templates/hash_set.hpp>
 
 #endif // LIMBOAI_GDEXTENSION
 
@@ -57,56 +55,52 @@ void TreeSearch::_clean_callable_cache() {
 	callable_cache = new_callable_cache;
 }
 
-// Makes all tree items invisible that don't match the following criteria:
-// 1. is a matching tree_item
-// 2. is a parent of a matching tree_item
-// 3. is any descendant of a matching tree_item
 void TreeSearch::_filter_tree(const String &p_search_mask) {
-	if (number_matches.size() == 0){
+	if (matching_entries.is_empty()) {
 		return;
 	}
-	HashSet<TreeItem *> visible_as_parent;
-	HashSet<TreeItem *> visible_as_descendant;
 
-	// Mark matching items and all their ancestors (1, 2)
-	for (int i = 0; i < matching_entries.size(); i++) {
-		TreeItem *cur_match = matching_entries[i];
-		TreeItem *current = cur_match;
-		while (current != nullptr && !visible_as_parent.has(current)) {
-			visible_as_parent.insert(current);
-			current = current->get_parent();
-		}
-	}
+	Vector<bool> item_visibilities;
+	item_visibilities.resize(ordered_tree_items.size());
+	item_visibilities.fill(false);
 
-	// Mark matching items and all their descendants (1, 3)
-	for (int i = 0; i < matching_entries.size(); i++) {
-		TreeItem *cur_match = matching_entries[i];
-		if (visible_as_descendant.has(cur_match)) {
-			continue;
-		}
-		// Descendents
-		Vector<TreeItem *> descendent_list = { cur_match };
-
-		for (int j = 0; j < descendent_list.size(); j++) {
-			TreeItem *descendent = descendent_list[j];
-			if (visible_as_descendant.has(descendent)) {
-				continue; // Skip subtree if already processed
-			}
-			visible_as_descendant.insert(descendent);
-			
-			// Collect X-level descendents (bit clunky because godot doesn't return get_children as pointers)
-			for (int k = 0; k < descendent->get_child_count(); k++) {
-				TreeItem *child = descendent->get_child(k);
-				descendent_list.push_back(child);
-			}
-		}
-	}
-
-	// Set visibility based on whether items are in either visibility set
+	// Make all entries visible that have any matching descendents. O(n)
 	for (int i = 0; i < ordered_tree_items.size(); i++) {
-		TreeItem *item = ordered_tree_items[i];
-		bool is_visible = visible_as_parent.has(item) || visible_as_descendant.has(item);
-		item->set_visible(is_visible);
+		TreeItem *entry = ordered_tree_items[i];
+		if (number_matches.has(entry) && number_matches[entry] > 0) {
+			item_visibilities.set(i, true);
+		}
+	}
+
+	// Make all descendents of matching entries visible. O(n) * log(|matching_entries|)
+	for (int i = 0; i < ordered_tree_items.size(); i++) {
+		TreeItem *entry = ordered_tree_items[i];
+		if (_vector_has_bsearch(matching_entries, entry)) {
+			// the [next_entry] at the same depth or depth above.
+			TreeItem *next_entry = entry->get_next();
+
+			// search above current depth if no [next_entry].
+			while (!next_entry && entry) {
+				entry = entry->get_parent();
+			}
+			if (entry) {
+				next_entry = entry->get_next();
+			}
+
+			// mark visible all successors upto next entry at the same depth or above
+			int j = i;
+			for (; j < ordered_tree_items.size() && ordered_tree_items[j] != next_entry; j++) {
+				item_visibilities.set(j, true);
+			}
+			i = j - 1; // every entry is only processed once.
+		}
+	}
+
+	// Apply visibility. O(n)
+	for (int i = 0; i < ordered_tree_items.size(); i++) {
+		if (!item_visibilities[i]) {
+			ordered_tree_items[i]->set_visible(false);
+		}
 	}
 }
 
@@ -176,7 +170,6 @@ void TreeSearch::_draw_highlight_item(TreeItem *p_tree_item, const Rect2 p_rect,
 	if (!p_tree_item) {
 		return;
 	}
-
 	// call any parent draw methods such as for probability FIRST.
 	p_parent_draw_method.call(p_tree_item, p_rect);