public void TestTypeSearcherItemUnityObject()
{
var item = new TypeSearcherItem(typeof(Object).GenerateTypeHandle(), "UnityEngine.Object");
Assert.AreEqual(item.Type, typeof(Object).GenerateTypeHandle());
Assert.AreEqual(item.Name, "UnityEngine.Object");
}
public void TestTypeSearcherItemString()
{
var item = new TypeSearcherItem(typeof(string).GenerateTypeHandle(), typeof(string).FriendlyName());
Assert.AreEqual(item.Type, typeof(string).GenerateTypeHandle());
Assert.AreEqual(item.Name, typeof(string).FriendlyName());
}
void CreateFieldItems(SearcherItem root, Type type, int depth)
{
var operators = GetOperatorsFromType(type);
foreach (var op in operators)
{
root.AddChild(op);
}
depth--;
if (depth <= 0)
{
return;
}
var infos = GetMemberInfos(type);
foreach (var info in infos)
{
var itemType = info.MemberType == MemberTypes.Field
? (info as FieldInfo)?.FieldType
: (info as PropertyInfo)?.PropertyType;
var item = new TypeSearcherItem(itemType.GenerateTypeHandle(m_Stencil), info.Name);
CreateFieldItems(item, itemType, depth);
// We only display item with binary operators
if (item.HasChildren)
{
root.AddChild(item);
}
}
}
public void TestTypeSearcherItemSystemObject()
{
var item = new TypeSearcherItem(typeof(object).GenerateTypeHandle(), "System.Object");
Assert.AreEqual(item.Type, typeof(object).GenerateTypeHandle());
Assert.AreEqual(item.Name, "System.Object");
}
public void TestTypeSearcherItemString()
{
Stencil stencil = ScriptableObject.CreateInstance <TestStencil>();
var item = new TypeSearcherItem(typeof(string).GenerateTypeHandle(stencil), typeof(string).FriendlyName());
Assert.AreEqual(item.Type, typeof(string).GenerateTypeHandle(stencil));
Assert.AreEqual(item.Name, typeof(string).FriendlyName());
}
public void TestTypeSearcherItemUnityObject()
{
Stencil stencil = ScriptableObject.CreateInstance <TestStencil>();
var item = new TypeSearcherItem(typeof(Object).GenerateTypeHandle(stencil), "UnityEngine.Object");
Assert.AreEqual(item.Type, typeof(Object).GenerateTypeHandle(stencil));
Assert.AreEqual(item.Name, "UnityEngine.Object");
}
internal static TypeSearcherDatabase AddTypesInheritingFrom <T>(this TypeSearcherDatabase self)
{
var baseType = typeof(T);
self.RegisterTypesFromMetadata((items, metadata) =>
{
if (!metadata.IsAssignableTo(baseType))
{
return(false);
}
var classItem = new TypeSearcherItem(metadata.TypeHandle, metadata.FriendlyName);
return(items.TryAddClassItem(self.Stencil, classItem, metadata));
});
return(self);
}
public override TypeSearcherDatabase AddGraphs()
{
RegisterTypes(items =>
{
var assetGUIDs = AssetDatabase.FindAssets($"t:{typeof(VSGraphAssetModel).Name}");
var graphs = assetGUIDs.Select(p =>
AssetDatabase.LoadAssetAtPath <VSGraphAssetModel>(AssetDatabase.GUIDToAssetPath(p))
).Where(x => x.GraphModel?.Stencil.GetType() != typeof(MacroStencil) &&
x.GraphModel?.Stencil.GetType() != typeof(EcsStencil));
foreach (var meta in graphs.Select(graph => graph.GenerateTypeHandle(m_Stencil).GetMetadata(m_Stencil)))
{
var graphItem = new TypeSearcherItem(meta.TypeHandle, meta.Name);
items.TryAddGraphItem(graphItem, meta);
}
});
return(this);
}
public SearcherDatabase Build()
{
var items = new List <SearcherItem>();
foreach (var component in m_Query.Components)
{
var handle = component.Component.TypeHandle;
var componentItem = new TypeSearcherItem(handle, handle.Name(m_Stencil));
CreateFieldItems(componentItem, handle.Resolve(m_Stencil), k_Depth);
// We only display components with fields
if (componentItem.HasChildren)
{
items.Add(componentItem);
}
}
return(SearcherDatabase.Create(items, "", false));
}
public EcsTypeSearcherDatabase AddMonoBehaviourComponents()
{
RegisterTypesFromMetadata((items, metadata) =>
{
var type = metadata.TypeHandle.Resolve(m_Stencil);
if (EcsStencil.IsValidGameObjectComponentType(type))
{
var item = new TypeSearcherItem(metadata.TypeHandle, metadata.FriendlyName);
var root = "GameObject Components";
var path = BuildPath(root, metadata);
items.AddAtPath(item, path);
return(true);
}
return(false);
});
return(this);
}
public EcsTypeSearcherDatabase AddComponents()
{
RegisterTypesFromMetadata((items, metadata) =>
{
var type = metadata.TypeHandle.Resolve(m_Stencil);
if (typeof(IComponentData).IsAssignableFrom(type) ||
typeof(ISharedComponentData).IsAssignableFrom(type))
{
var item = new TypeSearcherItem(metadata.TypeHandle, metadata.FriendlyName);
var root = typeof(IComponentData).IsAssignableFrom(type) ? "Component Data" : "Shared Component Data";
var path = BuildPath(root, metadata);
items.AddAtPath(item, path);
return(true);
}
return(false);
});
return(this);
}
