Official Quick Search Preview

Latest version of Quick Search should support file extension. You can try >=com.unity.quicksearch@3.0.0-preview.2 or >=Unity 2021.1

 

Recent version of quick search now use a dockable window that you can place wherever you want. You can try >=com.unity.quicksearch@3.0.0-preview.2 or >=Unity 2021.1

 

Sorry about that. I will notify the shortcut manager owners about this. Meanwhile you can always open the Shortcut Manager and bind your preferred shortcut to open Quick Search. In the >=2021.1 the default shortcut to open the global search was changed to CTRL+K.

 

In recent version you can create a default index that gets stored in the UserSettings/ folder. Otherwise, you can move the .index file pretty much anywhere and explicitly set the roots in json. i.e.

Assets/Anywhere/Assets.index

Code (CSharp):

1. {
2.     "name": "",
3.     "type": "asset",
4.  
5.  
6.     "roots": [
7.         "Assets",
8.         "Packages/my.cool.package
9.    ],
10.  
11.  
12.  
13.    "includes": [],
14.    "excludes": [
15.        "Temp/",
16.        "External/",
17.        "AddressableAssetsData/",
18.        "BuildReports/",
19.        "Plugins/",
20.        "Queries/",
21.        "Test/",
22.        ".cs",
23.        ".xml"
24.    ],
25.    "options": {
26.        "disabled": false,
27.        "types": true,
28.        "properties": true,
29.        "extended": false,
30.        "dependencies": false
31.    },
32.    "baseScore": 100
33. }

 

Hi, those were removed since we are now using the AssetWorker process to do the indexing. We will bring back those filters through the includes=[...] and excludes=[...] patterns in an upcoming version. These patterns will soon support regex and globs as well.

 

Yes you simply need to use

t:component_name

, i.e.

t:capsule

to find game objects that have a component with

capsule

in their type name.



You can use

=

, i.e.

t=BoxCollider

if you want to match exactly components with the type name

BoxCollider

.

 

Indeed after some investigation, there is something that changed how all assemblies get scanned after >=2020.2. I am working on a fix now. I'll ping you when this gets resolved.

 

Hi, I am not sure how you have setup your project indexes, but normally t:scene should return all .unity files.



Can you try with *.unity?

 

In >=2021.1 Quick Search is built-in, so you do not need the package anymore. The default shortcut is now CTRL+K, but you can easily change it back to want you want in the shortcut manager:

 

Sorry for the issue you've might have got in the past. Please report any performance issues you might still have and we'll address them as soon as possible. Also, in >=2021.1 if you do not open the search window, nothing should be indexed by default, therefore no resources should be consumed until the first time you use the search feature.

 

You can create multiple window instances using the API if you want. Using SearchService.ShowWindow (https://docs.unity3d.com/2021.1/Documentation/ScriptReference/Search.SearchService.ShowWindow.html) you'll be able to set reuseExisting: false in order to create a new search window instance.

Yes I think that would be a better workflow. I'll create a task on our side to prevent ESC from closing the window if it is docked and instead clear the search text field.

Issue tracker: https://issuetracker.unity3d.com/is...-should-not-close-the-search-window-if-docked

 

Ok it should now be fixed in next version. Here's a few example:

 

Now yes! The static method provider didn't have any!

Code (CSharp):

1.  
2. using NUnit.Framework;
3. using System.Collections.Generic;
4. using System.Collections;
5. using UnityEditor.Search;
6. using UnityEngine.TestTools;
7. class StaticMethodProviderTests : QuickSearchTests
8. {
9.     public static void GetPalette()
10.     {
11.     }
12.     public static void OpenTilemapPalette()
13.     {
14.     }
15.  
16.     public class TestQuery
17.     {
18.         public string query;
19.         public string expectedResult;
20.         public override string ToString() => query;
21.     }
22.  
23.     public static IEnumerable<TestQuery> TestQueryCases()
24.     {
25.         yield return new TestQuery { query = "palette", expectedResult = "StaticMethodProviderTests.GetPalette" };
26.         yield return new TestQuery { query = nameof(OpenTilemapPalette), expectedResult = "StaticMethodProviderTests.OpenTilemapPalette" };
27.         yield return new TestQuery { query = "open palette", expectedResult = "StaticMethodProviderTests.OpenTilemapPalette" };
28.         yield return new TestQuery { query = "version", expectedResult = "UnityEngine.Application.get_version" };
29.         yield return new TestQuery { query = "pref folder", expectedResult = "UnityEditorInternal.InternalEditorUtility.get_unityPreferencesFolder" };
30.     }
31.  
32.     [UnityTest]
33.     public IEnumerator RunQuery([ValueSource(nameof(TestQueryCases))] TestQuery test)
34.     {
35.         var staticMethodProvider = SearchService.GetProvider("static_methods");
36.         using (var searchContext = SearchService.CreateContext(staticMethodProvider, test.query))
37.         using (var results = SearchService.Request(searchContext))
38.         {
39.             while (results.pending)
40.                 yield return null;
41.             CollectionAssert.Contains(results.Select(r => r.description.Trim()), test.expectedResult);
42.         }
43.     }
44. }

 

Actually this bug is still in quicksearch@3.0.0-preview.3, but is fixed in >=2021.1. I will publish com.unity.quicksearch@3.0.0-preview.4 this week if all goes well for those on 2020.2.

Thanks,

 

It is unique. I believe that is because you re-use the came SearchContext. You should create a new search context for each call to SearchService.ShowWindow. i.e.

Code (CSharp):

1.  
2. [MenuItem("Test/Open Multiple Search Window")]
3. static void OpenMultipleSearchWindow()
4. {
5.     SearchService.ShowWindow(SearchService.CreateContext("pg:biome"));
6.     SearchService.ShowWindow(SearchService.CreateContext("p:width>=128"));
7.     SearchService.ShowWindow(SearchService.CreateContext("h:settings"));
8.     SearchService.ShowWindow(SearchService.CreateContext("test runner"));
9. }
10.  

 

We could do that. I'll discuss it with the team and get back to you.

 

Ok I think I know what happened with the window serialization. I will improve this in next version. When I tested I was in a DOTS project that do not do a domain reload when entering play mode.

 

Unfortunately the shortcut manager doesn't support such key sequences to trigger an action. That said, I'll try to play with this idea and see how this could be achieved. I'll get back to you.

 

Someone gave me that script you could try to play with. I haven't tried it myself yet, but the idea is to use some reflection to access a global event handler to capture some low level events. Use at your own risk.

Code (CSharp):

1. #if UNITY_EDITOR
2.     [ExecuteInEditMode]
3.     [InitializeOnLoad]
4. #endif
5.     public class SearchHotkeyListener : MonoBehaviour
6.     {
7. #if UNITY_EDITOR
8.         private static string ssListenerNameValue = "Listener";
9.         static bool ssShouldOpen(Event e, Type ssSettings)
10.         {
11.             return true;
12.         }
13.         static void ssToggleWindow(Type ssWindow)
14.         {
15.             MainWindow.Toggle();
16.         }
17.         static SearchHotkeyListener()
18.         {
19.             var ssTypes = AppDomain.CurrentDomain.GetAssemblies().SelectMany(t => t.GetTypes())
20.                 .Where(t => t.IsClass && t.Namespace == "Plawius.Search");
21.             var ssPublicSettings = ssTypes.FirstOrDefault(t => t.Name == "SearchPublicSettings");
22.             var ssWindow = ssTypes.FirstOrDefault(t => t.Name == "SearchWindow");
23.             if (ssPublicSettings == null)
24.             {
25.                 Debug.LogError("SearchPublicSettings is not found! Dll is missing? Reinstall Search, please");
26.                 return;
27.             }
28.             if (ssWindow == null)
29.             {
30.                 Debug.LogError("SearchWindow is not found! Dll is missing? Reinstall Search, please");
31.                 return;
32.             }
33.             Create(e => // will call GetAllObjects, so cannot call from static ctor
34.             {
35.                 var result = ssShouldOpen(e, ssPublicSettings);
36.                 if (result)
37.                     ssToggleWindow(ssWindow);
38.                 return result;
39.             });
40.         }
41.         public static void Create(Func<Event, bool> callback)
42.         {
43.             m_instance = null;
44.             Assert.IsNull(m_callback);
45.             m_callback = callback;
46.             EditorApplication.update += CreateInstanceIfNone;
47.         }
48.         private EditorApplication.CallbackFunction m_keyEventCallback;
49.         private EditorApplication.CallbackFunction m_updateCallback;
50.         private static Func<Event, bool> m_callback = null;
51.         private static GameObject m_instance = null;
52.         static void CreateInstanceIfNone()
53.         {
54.             foreach (var listener in Resources.FindObjectsOfTypeAll<SearchHotkeyListener>())
55.             {
56.                 DestroyImmediate(listener.gameObject, false);
57.             }
58.             if (m_instance == null && m_callback != null)
59.             {
60.                 m_instance = new GameObject(ssListenerNameValue, typeof(SearchHotkeyListener));
61.                 m_instance.hideFlags = HideFlags.HideAndDontSave | HideFlags.HideInInspector;
62.             }
63.             EditorApplication.update -= CreateInstanceIfNone;
64.         }
65.         private void Awake()
66.         {
67.             m_keyEventCallback = CheckKeyEvent;
68.             m_updateCallback = UpdateKey;
69.         }
70.         void SetCallback(bool add)
71.         {
72.             var info = typeof(EditorApplication).GetField("globalEventHandler",
73.                 System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.NonPublic);
74.             var value = (EditorApplication.CallbackFunction) info.GetValue(null);
75.             if (add)
76.                 value += m_keyEventCallback;
77.             else
78.                 value -= m_keyEventCallback;
79.             info.SetValue(null, value);
80.         }
81.         private void OnEnable()
82.         {
83.             SetCallback(true);
84.             EditorApplication.update += m_updateCallback;
85.         }
86.         private void OnDisable()
87.         {
88.             SetCallback(false);
89.             EditorApplication.update -= m_updateCallback;
90.         }
91.         private void CheckKeyEvent()
92.         {
93.             var e = Event.current;
94.             if (e != null && e.keyCode != KeyCode.None)
95.             {
96.                 if (m_callback != null && m_callback(e))
97.                     e.Use();
98.             }
99.         }
100.         void UpdateKey()
101.         {
102.             if (PendingKeyUp())
103.             {
104.                 UnityEditorInternal.InternalEditorUtility.RepaintAllViews();
105.             }
106.         }
107.         private bool PendingKeyUp()
108.         {
109.             return m_previousEvent != null && m_previousEvent.keyCode != KeyCode.None;
110.         }
111.         private Event m_previousEvent;
112.         void OnGUI()
113.         {
114.             var e = Event.current;
115.             if (EditorApplication.isPlaying)
116.             {
117.                 if (e != null && e.keyCode != KeyCode.None)
118.                 {
119.                     if (m_callback != null && m_callback(e))
120.                         e.Use();
121.                 }
122.             }
123.             else
124.             {
125.                 // only have Layer and Repaint
126.                 if (e != null && e.type == EventType.Repaint)
127.                 {
128.                     if (m_previousEvent != null)
129.                     {
130.                         if (e.keyCode != m_previousEvent.keyCode && m_previousEvent.keyCode != KeyCode.None)
131.                         {
132.                             m_previousEvent.type = EventType.KeyUp;
133.                             if (m_callback != null)
134.                                 m_callback(m_previousEvent);
135.                         }
136.                     }
137.                     m_previousEvent = new Event(e);
138.                 }
139.             }
140.         }
141. #endif
142.     }

 

Hi, I guess the search database object was still in memory from previous domain and the system reload it when a domain reload occurred (just like any EditorWindow or active ScriptableObject). That said you shouldn't get that error about the progress reporting.

Which version of Unity and or the quick search package are you using? If you are able to repro the issue please log an issue and we will investigate on our side.

 

I will investigate that case and get back to you. I know that sometimes we ignore one character words, but two character words should work just fine. Which version are you using exactly?

Yes that would be a good idea, but for now you can use ALT+UP and ALT+DOWN to cycle through your last searches. I think we keep the last 10 searches.

We could easily add a way to favorite search queries that do not necessarily get saved as an asset, but just save the string in your preferences for later (like a bookmark). I'll discuss this with the team.

We could do the highlight in the label too, but at first we wanted to prevent too many highlighting going on.

Folder is not a real type, therefore it doesn't got indexed like other types, but in the next release I will add word matches for

folder

and that will solve this.

Thanks for the great feedback.