HideNode CreateNodeForManager(int id, ComponentSystemBase system)
{
var active = true;
if (!(system is ComponentSystemGroup))
{
managersById.Add(id, system);
worldsById.Add(id, system.World);
var recorder = Recorder.Get($"{system.World?.Name ?? "none"} {system.GetType().FullName}");
if (!recordersByManager.ContainsKey(system))
{
recordersByManager.Add(system, new AverageRecorder(recorder));
}
else
{
UnityEngine.Debug.LogError("System added twice: " + system);
}
recorder.enabled = true;
active = false;
}
var name = getWorldSelection() == null ? $"{system.GetType().Name} ({system.World?.Name ?? "none"})" : system.GetType().Name;
var item = new TreeViewItem {
id = id, displayName = name
};
var hideNode = new HideNode(item)
{
Active = active
};
hideNodesById.Add(id, hideNode);
return(hideNode);
}
private HideNode CreateNodeForManager(int id, ComponentSystemBase system)
{
var active = true;
if (!(system is ComponentSystemGroup))
{
managersById.Add(id, system);
worldsById.Add(id, system.World);
var recorder = Recorder.Get($"{system.World.Name} {system.GetType().FullName}");
recordersByManager.Add(system, new AverageRecorder(recorder));
recorder.enabled = true;
active = false;
}
var name = getWorldSelection() == null ? $"{system.GetType().Name} ({system.World.Name})" : system.GetType().Name;
var item = new TreeViewItem {
id = id, displayName = name
};
var hideNode = new HideNode(item)
{
Active = active
};
hideNodesById.Add(id, hideNode);
return(hideNode);
}
/// <summary>
/// Adds a system to the player loop in the same way that <see cref="Unity.Entities.ScriptBehaviourUpdateOrder"/> does.
///
/// One difference is that this does not check to see if the system is already added. It is up to the users of this
/// method to ensure that they do not add systems multiple times.
/// </summary>
/// <param name="parent">
/// Must be one of the top level types already in the player loop such as
/// <see cref="UnityEngine.PlayerLoop.FixedUpdate"/> or <see cref="UnityEngine.PlayerLoop.Update"/>.
/// </param>
/// <param name="system">
/// The system to be added to the player loop.
/// </param>
/// <exception cref="Exception">
/// An exception is thrown if the reflection components could not be initialized or the parent type was not in the player
/// loop.
/// </exception>
public static void AddSubSystem(Type parent, ComponentSystemBase system)
{
ValidateReflectionComponents();
PlayerLoopSystem currentPlayerLoop = PlayerLoop.GetCurrentPlayerLoop();
for (int i = 0; i < currentPlayerLoop.subSystemList.Length; i++)
{
if (currentPlayerLoop.subSystemList[i].type == parent)
{
PlayerLoopSystem[] oldSubSystems = currentPlayerLoop.subSystemList[i].subSystemList;
PlayerLoopSystem[] newSubSystems = new PlayerLoopSystem[oldSubSystems.Length + 1];
Array.Copy(oldSubSystems, newSubSystems, oldSubSystems.Length);
newSubSystems[oldSubSystems.Length].type = system.GetType();
newSubSystems[oldSubSystems.Length].updateDelegate = CreateDummyWrapper(system);
currentPlayerLoop.subSystemList[i].subSystemList = newSubSystems;
PlayerLoop.SetPlayerLoop(currentPlayerLoop);
return;
}
}
throw new Exception($"Could not add {system.GetType().Name} to player loop. Are you sure {parent.Name} is in the player loop?");
}
private static TreeViewState GetStateForSystem(ComponentSystemBase system, List <TreeViewState> states, List <string> stateNames)
{
if (system == null)
{
return(new TreeViewState());
}
var currentSystemName = system.GetType().FullName;
var stateForCurrentSystem = states.Where((t, i) => stateNames[i] == currentSystemName).FirstOrDefault();
if (stateForCurrentSystem != null)
{
return(stateForCurrentSystem);
}
stateForCurrentSystem = new TreeViewState();
if (system.ComponentGroups != null && system.ComponentGroups.Length > 0)
{
stateForCurrentSystem.expandedIDs = new List <int> {
1
}
}
;
states.Add(stateForCurrentSystem);
stateNames.Add(currentSystemName);
return(stateForCurrentSystem);
}
private static List <EntityArchetypeQuery> GetQueriesForSystem(ComponentSystemBase system)
{
if (queriesBySystem.TryGetValue(system, out var queries))
{
return(queries);
}
queries = new List <EntityArchetypeQuery>();
var currentType = system.GetType();
while (currentType != null)
{
foreach (var field in currentType.GetFields(BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public))
{
if (field.FieldType == typeof(EntityArchetypeQuery))
{
queries.Add(field.GetValue(system) as EntityArchetypeQuery);
}
}
currentType = currentType.BaseType;
}
return(queries);
}
public static TreeViewState GetStateForSystem(ComponentSystemBase system, ref List <TreeViewState> states, ref List <string> stateNames)
{
if (system == null)
{
return(new TreeViewState());
}
if (states == null)
{
states = new List <TreeViewState>();
stateNames = new List <string>();
}
var currentSystemName = system.GetType().Name.ToString();
TreeViewState stateForCurrentSystem = null;
for (var i = 0; i < states.Count; ++i)
{
if (stateNames[i] == currentSystemName)
{
stateForCurrentSystem = states[i];
break;
}
}
if (stateForCurrentSystem == null)
{
stateForCurrentSystem = new TreeViewState();
states.Add(stateForCurrentSystem);
stateNames.Add(currentSystemName);
}
return(stateForCurrentSystem);
}
public static void LogChunksCount(ComponentSystemBase system, int chunks)
{
if (!_instance.LogResults)
{
return;
}
UnityEngine.Debug.Log(system.GetType().Name + " chunks = " + chunks);
}
public static void LogSumResults(ComponentSystemBase system, double noTag, double firstTag, double secondTag, double total)
{
if (!_instance.LogResults)
{
return;
}
UnityEngine.Debug.Log(system.GetType().Name +
$" {noTag:F2} / {firstTag:F2} / {secondTag:F2} total={total:F2}");
}
public Type GetSystemType()
{
if (!Valid)
{
return(null);
}
return(Managed != null?Managed.GetType() : SystemBaseRegistry.GetStructType(StatePointer->UnmanagedMetaIndex));
}
public Type GetSystemType()
{
if (Managed != null)
{
return(Managed.GetType());
}
else
{
return(SystemBaseRegistry.GetStructType(StatePointer->UnmanagedMetaIndex));
}
}
private void GetInstances(Type type)
{
if (window.selectedWorld != null)
{
activeInstance = window.selectedWorld.GetExistingManager(type) as ComponentSystemBase;
}
else
{
activeInstance = null;
}
if (instance == null || instance.GetType() != type)
{
instance = Activator.CreateInstance(type) as ComponentSystemBase;
}
}
static void Parse(ComponentSystemBase system, PlayerLoopSystemGraph graph, IPlayerLoopNode parent = null)
{
IPlayerLoopNode node;
graph.AllSystems.Add(system);
switch (system)
{
case ComponentSystemGroup group:
var groupNode = Pool <ComponentGroupNode> .GetPooled();
groupNode.Value = group;
node = groupNode;
foreach (var s in group.Systems)
{
Parse(s, graph, node);
}
break;
default:
var systemNode = Pool <ComponentSystemBaseNode> .GetPooled();
systemNode.Value = system;
node = systemNode;
var recorder = Recorder.Get($"{system.World?.Name ?? "none"} {system.GetType().FullName}");
var recorderKey = new RecorderKey
{
World = system.World,
Group = (ComponentSystemGroup)((ComponentGroupNode)parent).System,
System = system
};
if (!graph.RecordersBySystem.ContainsKey(recorderKey))
{
graph.RecordersBySystem.Add(recorderKey, new AverageRecorder(recorder));
}
else
{
UnityEngine.Debug.LogError("System added twice: " + system);
}
recorder.enabled = true;
break;
}
AddToGraph(graph, node, parent);
}
private IEnumerable <ComponentSystemGroup> GetSystemGroup(ComponentSystemBase system)
{
var updateInGroupAttributes = TypeManager.GetSystemAttributes(
system.GetType(),
typeof(UpdateInGroupAttribute));
if (updateInGroupAttributes.Length == 0)
{
yield return(_simulationSystemGroup);
}
else
{
foreach (var attr in updateInGroupAttributes)
{
if (attr is UpdateInGroupAttribute uga)
{
if (_world.GetExistingSystem(uga.GroupType) is ComponentSystemGroup systemGroup)
{
yield return(systemGroup);
}
}
}
}
}
