internal static void Sort <T>(List <T> items, GetSystemType <T> getType, Type parentType)
{
#if !NET_DOTS
lookupDictionary = null;
#endif
// Populate dictionary mapping systemType to system-and-before/after-types.
// This is clunky - it is easier to understand, and cleaner code, to
// just use a Dictionary<Type, SysAndDep>. However, Tiny doesn't currently have
// the ability to use Type as a key to a NativeHash, so we're stuck until that gets addressed.
//
// Likewise, this is important shared code. It can be done cleaner with 2 versions, but then...
// 2 sets of bugs and slightly different behavior will creep in.
//
var sysAndDep = new SysAndDep <T> [items.Count];
for (int i = 0; i < items.Count; ++i)
{
var sys = items[i];
sysAndDep[i] = new SysAndDep <T>
{
item = sys,
type = getType(sys),
updateBefore = new List <Type>(),
nAfter = 0,
};
}
for (int i = 0; i < sysAndDep.Length; ++i)
{
var systemType = sysAndDep[i].type;
var before = TypeManager.GetSystemAttributes(systemType, typeof(UpdateBeforeAttribute));
var after = TypeManager.GetSystemAttributes(systemType, typeof(UpdateAfterAttribute));
foreach (var attr in before)
{
var dep = attr as UpdateBeforeAttribute;
if (!typeof(ComponentSystemBase).IsAssignableFrom(dep.SystemType))
{
#if !NET_DOTS
Debug.LogWarning(
$"Ignoring invalid [UpdateBefore] attribute on {systemType} because {dep.SystemType} is not a subclass of {nameof(ComponentSystemBase)}.\n"
+ $"Set the target parameter of [UpdateBefore] to a system class in the same {nameof(ComponentSystemGroup)} as {systemType}.");
#else
Debug.LogWarning($"WARNING: invalid [UpdateBefore] attribute:");
Debug.LogWarning(TypeManager.GetSystemName(dep.SystemType));
Debug.LogWarning(" is not derived from ComponentSystemBase. Set the target parameter of [UpdateBefore] to a system class in the same ComponentSystemGroup.");
#endif
continue;
}
if (dep.SystemType == systemType)
{
#if !NET_DOTS
Debug.LogWarning(
$"Ignoring invalid [UpdateBefore] attribute on {systemType} because a system cannot be updated before itself.\n"
+ $"Set the target parameter of [UpdateBefore] to a different system class in the same {nameof(ComponentSystemGroup)} as {systemType}.");
#else
Debug.LogWarning($"WARNING: invalid [UpdateBefore] attribute:");
Debug.LogWarning(TypeManager.GetSystemName(systemType));
Debug.LogWarning(" depends on itself. Set the target parameter of [UpdateBefore] to a system class in the same ComponentSystemGroup.");
#endif
continue;
}
if (parentType == typeof(InitializationSystemGroup))
{
if (dep.SystemType == typeof(BeginInitializationEntityCommandBufferSystem))
{
#if !NET_DOTS
throw new ArgumentException(
$"Invalid [UpdateBefore] {dep.SystemType} attribute on {systemType}, because that system is already restricted to be first.");
#else
throw new ArgumentException($"Invalid [UpdateBefore] BeginInitializationEntityCommandBufferSystem, because that system is already restricted to be first.");
#endif
}
if (dep.SystemType == typeof(EndInitializationEntityCommandBufferSystem))
{
WarningForBeforeCheck(systemType, dep.SystemType);
continue;
}
}
if (parentType == typeof(SimulationSystemGroup))
{
if (dep.SystemType == typeof(BeginSimulationEntityCommandBufferSystem))
{
#if !NET_DOTS
throw new ArgumentException(
$"Invalid [UpdateBefore] {dep.SystemType} attribute on {systemType}, because that system is already restricted to be first.");
#else
throw new ArgumentException($"Invalid [UpdateBefore] BeginSimulationEntityCommandBufferSystem, because that system is already restricted to be first.");
#endif
}
if (dep.SystemType == typeof(LateSimulationSystemGroup))
{
WarningForBeforeCheck(systemType, dep.SystemType);
continue;
}
if (dep.SystemType == typeof(EndSimulationEntityCommandBufferSystem))
{
WarningForBeforeCheck(systemType, dep.SystemType);
continue;
}
}
if (parentType == typeof(PresentationSystemGroup))
{
if (dep.SystemType == typeof(BeginPresentationEntityCommandBufferSystem))
{
#if !NET_DOTS
throw new ArgumentException(
$"Invalid [UpdateBefore] {dep.SystemType} attribute on {systemType}, because that system is already restricted to be first.");
#else
throw new ArgumentException($"Invalid [UpdateBefore] BeginPreesntationEntityCommandBufferSystem, because that system is already restricted to be first.");
#endif
}
}
int depIndex = LookupSysAndDep(dep.SystemType, sysAndDep);
if (depIndex < 0)
{
#if !NET_DOTS
Debug.LogWarning(
$"Ignoring invalid [UpdateBefore] attribute on {systemType} because {dep.SystemType} belongs to a different {nameof(ComponentSystemGroup)}.\n"
+ $"This attribute can only order systems that are children of the same {nameof(ComponentSystemGroup)}.\n"
+ $"Make sure that both systems are in the same parent group with [UpdateInGroup(typeof({parentType})].\n"
+ $"You can also change the relative order of groups when appropriate, by using [UpdateBefore] and [UpdateAfter] attributes at the group level.");
#else
Debug.LogWarning("WARNING: invalid [UpdateBefore] dependency:");
Debug.LogWarning(TypeManager.GetSystemName(systemType));
Debug.LogWarning(" depends on a non-sibling system: ");
Debug.LogWarning(TypeManager.GetSystemName(dep.SystemType));
#endif
continue;
}
sysAndDep[i].updateBefore.Add(dep.SystemType);
sysAndDep[depIndex].nAfter++;
}
foreach (var attr in after)
{
var dep = attr as UpdateAfterAttribute;
if (!typeof(ComponentSystemBase).IsAssignableFrom(dep.SystemType))
{
#if !NET_DOTS
Debug.LogWarning(
$"Ignoring invalid [UpdateAfter] attribute on {systemType} because {dep.SystemType} is not a subclass of {nameof(ComponentSystemBase)}.\n"
+ $"Set the target parameter of [UpdateAfter] to a system class in the same {nameof(ComponentSystemGroup)} as {systemType}.");
#else
Debug.LogWarning($"WARNING: invalid [UpdateAfter] attribute:");
Debug.LogWarning(TypeManager.GetSystemName(dep.SystemType));
Debug.LogWarning(" is not derived from ComponentSystemBase. Set the target parameter of [UpdateAfter] to a system class in the same ComponentSystemGroup.");
#endif
continue;
}
if (dep.SystemType == systemType)
{
#if !NET_DOTS
Debug.LogWarning(
$"Ignoring invalid [UpdateAfter] attribute on {systemType} because a system cannot be updated after itself.\n"
+ $"Set the target parameter of [UpdateAfter] to a different system class in the same {nameof(ComponentSystemGroup)} as {systemType}.");
#else
Debug.LogWarning($"WARNING: invalid [UpdateAfter] attribute:");
Debug.LogWarning(TypeManager.GetSystemName(systemType));
Debug.LogWarning(" depends on itself. Set the target parameter of [UpdateAfter] to a system class in the same ComponentSystemGroup.");
#endif
continue;
}
if (parentType == typeof(InitializationSystemGroup))
{
if (dep.SystemType == typeof(BeginInitializationEntityCommandBufferSystem))
{
WarningForAfterCheck(systemType, dep.SystemType);
continue;
}
if (dep.SystemType == typeof(EndInitializationEntityCommandBufferSystem))
{
#if !NET_DOTS
throw new ArgumentException(
$"Invalid [UpdateAfter] {dep.SystemType} attribute on {systemType}, because that system is already restricted to be last.");
#else
throw new ArgumentException($"Invalid [UpdateAfter] EndInitializationEntityCommandBufferSystem, because that system is already restricted to be last.");
#endif
}
}
if (parentType == typeof(SimulationSystemGroup))
{
if (dep.SystemType == typeof(BeginSimulationEntityCommandBufferSystem))
{
WarningForAfterCheck(systemType, dep.SystemType);
continue;
}
if (dep.SystemType == typeof(LateSimulationSystemGroup))
{
#if !NET_DOTS
throw new ArgumentException(
$"Invalid [UpdateAfter] {dep.SystemType} attribute on {systemType}, because that system is already restricted to be last.");
#else
throw new ArgumentException($"Invalid [UpdateAfter] EndLateSimulationEntityCommandBufferSystem, because that system is already restricted to be last.");
#endif
}
if (dep.SystemType == typeof(EndSimulationEntityCommandBufferSystem))
{
#if !NET_DOTS
throw new ArgumentException(
$"Invalid [UpdateAfter] {dep.SystemType} attribute on {systemType}, because that system is already restricted to be last.");
#else
throw new ArgumentException($"Invalid [UpdateAfter] EndSimulationEntityCommandBufferSystem, because that system is already restricted to be last.");
#endif
}
}
if (parentType == typeof(PresentationSystemGroup))
{
if (dep.SystemType == typeof(BeginPresentationEntityCommandBufferSystem))
{
WarningForAfterCheck(systemType, dep.SystemType);
continue;
}
}
int depIndex = LookupSysAndDep(dep.SystemType, sysAndDep);
if (depIndex < 0)
{
#if !NET_DOTS
Debug.LogWarning(
$"Ignoring invalid [UpdateAfter] attribute on {systemType} because {dep.SystemType} belongs to a different {nameof(ComponentSystemGroup)}.\n"
+ $"This attribute can only order systems that are children of the same {nameof(ComponentSystemGroup)}.\n"
+ $"Make sure that both systems are in the same parent group with [UpdateInGroup(typeof({parentType})].\n"
+ $"You can also change the relative order of groups when appropriate, by using [UpdateBefore] and [UpdateAfter] attributes at the group level.");
#else
Debug.LogWarning("WARNING: invalid [UpdateAfter] dependency:");
Debug.LogWarning(TypeManager.GetSystemName(systemType));
Debug.LogWarning(" depends on a non-sibling system: ");
Debug.LogWarning(TypeManager.GetSystemName(dep.SystemType));
#endif
continue;
}
sysAndDep[depIndex].updateBefore.Add(systemType);
sysAndDep[i].nAfter++;
}
}
// Clear the systems list and rebuild it in sorted order from the lookup table
var readySystems = new Heap <TypeHeapElement>(items.Count);
items.Clear();
for (int i = 0; i < sysAndDep.Length; ++i)
{
if (sysAndDep[i].nAfter == 0)
{
readySystems.Insert(new TypeHeapElement(i, sysAndDep[i].type));
}
}
while (!readySystems.Empty)
{
var sysIndex = readySystems.Extract().unsortedIndex;
var sd = sysAndDep[sysIndex];
sysAndDep[sysIndex] = new SysAndDep <T>(); // "Remove()"
items.Add(sd.item);
foreach (var beforeType in sd.updateBefore)
{
int beforeIndex = LookupSysAndDep(beforeType, sysAndDep);
if (beforeIndex < 0)
{
throw new Exception("Bug in SortSystemUpdateList(), beforeIndex < 0");
}
if (sysAndDep[beforeIndex].nAfter <= 0)
{
throw new Exception("Bug in SortSystemUpdateList(), nAfter <= 0");
}
sysAndDep[beforeIndex].nAfter--;
if (sysAndDep[beforeIndex].nAfter == 0)
{
readySystems.Insert(new TypeHeapElement(beforeIndex, sysAndDep[beforeIndex].type));
}
}
}
for (int i = 0; i < sysAndDep.Length; ++i)
{
if (sysAndDep[i].item != null)
{
// Since no System in the circular dependency would have ever been added
// to the heap, we should have values for everything in sysAndDep. Check,
// just in case.
#if ENABLE_UNITY_COLLECTIONS_CHECKS
var visitedSystems = new List <Type>();
var startIndex = i;
var currentIndex = i;
while (true)
{
if (sysAndDep[currentIndex].item != null)
{
visitedSystems.Add(sysAndDep[currentIndex].type);
}
currentIndex = LookupSysAndDep(sysAndDep[currentIndex].updateBefore[0], sysAndDep);
if (currentIndex < 0 || currentIndex == startIndex || sysAndDep[currentIndex].item == null)
{
throw new CircularSystemDependencyException(visitedSystems);
}
}
#else
sysAndDep[i] = new SysAndDep <T>();
#endif
}
}
}
public TypeHeapElement(int index, Type t)
{
unsortedIndex = index;
typeName = TypeManager.GetSystemName(t);
}
internal void FlushPendingBuffers(bool playBack)
{
m_ProducerHandle.Complete();
m_ProducerHandle = new JobHandle();
int length;
#if ENABLE_UNITY_COLLECTIONS_CHECKS
length = m_PendingBuffers.Count;
#else
length = m_PendingBuffers.Length;
#endif
#if ENABLE_UNITY_COLLECTIONS_CHECKS
List <string> playbackErrorLog = null;
bool completeAllJobsBeforeDispose = false;
#endif
for (int i = 0; i < length; ++i)
{
var buffer = m_PendingBuffers[i];
if (!buffer.IsCreated)
{
continue;
}
if (playBack)
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
try
{
var system = GetSystemFromSystemID(World, buffer.SystemID);
var systemName = system != null?TypeManager.GetSystemName(system.GetType()) : "Unknown";
Profiler.BeginSample(systemName);
buffer.Playback(EntityManager);
Profiler.EndSample();
}
catch (Exception e)
{
var system = GetSystemFromSystemID(World, buffer.SystemID);
var systemType = system != null?system.GetType().ToString() : "Unknown";
var error = $"{e.Message}\nEntityCommandBuffer was recorded in {systemType} and played back in {GetType()}.\n" + e.StackTrace;
if (playbackErrorLog == null)
{
playbackErrorLog = new List <string>();
}
playbackErrorLog.Add(error);
completeAllJobsBeforeDispose = true;
}
#else
buffer.Playback(EntityManager);
#endif
}
#if ENABLE_UNITY_COLLECTIONS_CHECKS
try
{
if (completeAllJobsBeforeDispose)
{
// If we get here, there was an error during playback (potentially a race condition on the
// buffer itself), and we should wait for all jobs writing to this command buffer to complete before attempting
// to dispose of the command buffer to prevent a potential race condition.
buffer.WaitForWriterJobs();
completeAllJobsBeforeDispose = false;
}
buffer.Dispose();
}
catch (Exception e)
{
var system = GetSystemFromSystemID(World, buffer.SystemID);
var systemType = system != null?system.GetType().ToString() : "Unknown";
var error = $"{e.Message}\nEntityCommandBuffer was recorded in {systemType} and disposed in {GetType()}.\n" + e.StackTrace;
if (playbackErrorLog == null)
{
playbackErrorLog = new List <string>();
}
playbackErrorLog.Add(error);
}
#else
buffer.Dispose();
#endif
m_PendingBuffers[i] = buffer;
}
#if ENABLE_UNITY_COLLECTIONS_CHECKS
if (playbackErrorLog != null)
{
#if !NET_DOTS
var exceptionMessage = new StringBuilder();
foreach (var err in playbackErrorLog)
{
exceptionMessage.AppendLine(err);
}
#else
var exceptionMessage = "";
foreach (var err in playbackErrorLog)
{
exceptionMessage += err;
exceptionMessage += '\n';
}
#endif
throw new System.ArgumentException(exceptionMessage.ToString());
}
#endif
}
