static void RuntimeInitializeOnLoad()
{
Debug.Log("Insight: adding Network[Early/Late]Update to Unity...");
PlayerLoopSystem playerLoop =
#if UNITY_2019_3_OR_NEWER
PlayerLoop.GetCurrentPlayerLoop();
#else
PlayerLoop.GetDefaultPlayerLoop();
#endif
AddToPlayerLoop(NetworkEarlyUpdate, typeof(InsightLoop), ref playerLoop, typeof(EarlyUpdate), AddMode.End);
AddToPlayerLoop(NetworkLateUpdate, typeof(InsightLoop), ref playerLoop, typeof(PreLateUpdate), AddMode.End);
PlayerLoop.SetPlayerLoop(playerLoop);
}
public static void Initialize(ref PlayerLoopSystem playerLoop)
{
yielders = new ContinuationQueue[14];
runners = new PlayerLoopRunner[14];
var copyList = playerLoop.subSystemList.ToArray();
// Initialization
copyList[0].subSystemList = InsertRunner(copyList[0], typeof(UniTaskLoopRunners.UniTaskLoopRunnerYieldInitialization), yielders[0] = new ContinuationQueue(PlayerLoopTiming.Initialization),
typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastYieldInitialization), yielders[1] = new ContinuationQueue(PlayerLoopTiming.LastInitialization),
typeof(UniTaskLoopRunners.UniTaskLoopRunnerInitialization), runners[1] = new PlayerLoopRunner(PlayerLoopTiming.Initialization),
typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastInitialization), runners[1] = new PlayerLoopRunner(PlayerLoopTiming.LastInitialization));
// EarlyUpdate
copyList[1].subSystemList = InsertRunner(copyList[1], typeof(UniTaskLoopRunners.UniTaskLoopRunnerYieldEarlyUpdate), yielders[2] = new ContinuationQueue(PlayerLoopTiming.EarlyUpdate),
typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastYieldEarlyUpdate), yielders[3] = new ContinuationQueue(PlayerLoopTiming.LastEarlyUpdate),
typeof(UniTaskLoopRunners.UniTaskLoopRunnerEarlyUpdate), runners[2] = new PlayerLoopRunner(PlayerLoopTiming.EarlyUpdate),
typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastEarlyUpdate), runners[3] = new PlayerLoopRunner(PlayerLoopTiming.LastEarlyUpdate));
// FixedUpdate
copyList[2].subSystemList = InsertRunner(copyList[2], typeof(UniTaskLoopRunners.UniTaskLoopRunnerYieldFixedUpdate), yielders[4] = new ContinuationQueue(PlayerLoopTiming.FixedUpdate),
typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastYieldFixedUpdate), yielders[5] = new ContinuationQueue(PlayerLoopTiming.LastFixedUpdate),
typeof(UniTaskLoopRunners.UniTaskLoopRunnerFixedUpdate), runners[4] = new PlayerLoopRunner(PlayerLoopTiming.FixedUpdate),
typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastFixedUpdate), runners[5] = new PlayerLoopRunner(PlayerLoopTiming.LastFixedUpdate));
// PreUpdate
copyList[3].subSystemList = InsertRunner(copyList[3], typeof(UniTaskLoopRunners.UniTaskLoopRunnerYieldPreUpdate), yielders[6] = new ContinuationQueue(PlayerLoopTiming.PreUpdate),
typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastYieldPreUpdate), yielders[7] = new ContinuationQueue(PlayerLoopTiming.LastPreUpdate),
typeof(UniTaskLoopRunners.UniTaskLoopRunnerPreUpdate), runners[6] = new PlayerLoopRunner(PlayerLoopTiming.PreUpdate),
typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastPreUpdate), runners[7] = new PlayerLoopRunner(PlayerLoopTiming.LastPreUpdate));
// Update
copyList[4].subSystemList = InsertRunner(copyList[4], typeof(UniTaskLoopRunners.UniTaskLoopRunnerYieldUpdate), yielders[8] = new ContinuationQueue(PlayerLoopTiming.Update),
typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastYieldUpdate), yielders[9] = new ContinuationQueue(PlayerLoopTiming.LastUpdate),
typeof(UniTaskLoopRunners.UniTaskLoopRunnerUpdate), runners[8] = new PlayerLoopRunner(PlayerLoopTiming.Update),
typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastUpdate), runners[9] = new PlayerLoopRunner(PlayerLoopTiming.LastUpdate));
// PreLateUpdate
copyList[5].subSystemList = InsertRunner(copyList[5], typeof(UniTaskLoopRunners.UniTaskLoopRunnerYieldPreLateUpdate), yielders[10] = new ContinuationQueue(PlayerLoopTiming.PreLateUpdate),
typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastYieldPreLateUpdate), yielders[11] = new ContinuationQueue(PlayerLoopTiming.LastPreLateUpdate),
typeof(UniTaskLoopRunners.UniTaskLoopRunnerPreLateUpdate), runners[10] = new PlayerLoopRunner(PlayerLoopTiming.PreLateUpdate),
typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastPreLateUpdate), runners[11] = new PlayerLoopRunner(PlayerLoopTiming.LastPreLateUpdate));
// PostLateUpdate
copyList[6].subSystemList = InsertRunner(copyList[6], typeof(UniTaskLoopRunners.UniTaskLoopRunnerYieldPostLateUpdate), yielders[12] = new ContinuationQueue(PlayerLoopTiming.PostLateUpdate),
typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastYieldPostLateUpdate), yielders[13] = new ContinuationQueue(PlayerLoopTiming.LastPostLateUpdate),
typeof(UniTaskLoopRunners.UniTaskLoopRunnerPostLateUpdate), runners[12] = new PlayerLoopRunner(PlayerLoopTiming.PostLateUpdate),
typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastPostLateUpdate), runners[13] = new PlayerLoopRunner(PlayerLoopTiming.LastPostLateUpdate));
playerLoop.subSystemList = copyList;
PlayerLoop.SetPlayerLoop(playerLoop);
}
public static PlayerLoopSystem CopySystem(PlayerLoopSystem system)
{
// PlayerLoopSystem is a struct.
var copy = system;
// but the sub system list is an array.
if (system.subSystemList != null)
{
copy.subSystemList = new PlayerLoopSystem[system.subSystemList.Length];
for (int i = 0; i < copy.subSystemList.Length; i++)
{
copy.subSystemList[i] = CopySystem(system.subSystemList[i]);
}
}
return(copy);
}
private void BuildNodeTree()
{
managersById.Clear();
worldsById.Clear();
recordersByManager.Clear();
hideNodesById.Clear();
var currentID = kAllEntitiesItemId + 1;
lastPlayerLoop = ScriptBehaviourUpdateOrder.CurrentPlayerLoop;
rootNode = BuildNodesForPlayerLoopSystem(ScriptBehaviourUpdateOrder.CurrentPlayerLoop, ref currentID)
?? new HideNode(new TreeViewItem {
id = currentID, displayName = "Root"
});
return;
}
static PlayerLoopSystem[] InsertRunner(PlayerLoopSystem loopSystem, Type loopRunnerYieldType, ContinuationQueue cq, Type loopRunnerType, PlayerLoopRunner runner) {
var yieldLoop = new PlayerLoopSystem {
type = loopRunnerYieldType,
updateDelegate = cq.Run
};
var runnerLoop = new PlayerLoopSystem {
type = loopRunnerType,
updateDelegate = runner.Run
};
var dest = new PlayerLoopSystem[loopSystem.subSystemList.Length + 2];
Array.Copy(loopSystem.subSystemList, 0, dest, 2, loopSystem.subSystemList.Length);
dest[0] = yieldLoop;
dest[1] = runnerLoop;
return dest;
}
static void InsertSubsystem(
ref PlayerLoopSystem parentSystem,
Type before,
PlayerLoopSystem newSystem,
PlayerLoopSystem newPostSystem)
{
var source = parentSystem.subSystemList;
var insertIndex = -1;
for (var i = 0; i < source.Length; i++)
{
if (source[i].type == before)
{
insertIndex = i;
}
}
if (insertIndex < 0)
{
throw new ArgumentException($"{before.FullName} not in system {parentSystem} {parentSystem.type.FullName}");
}
var dest = new PlayerLoopSystem[source.Length + 2];
for (var i = 0; i < dest.Length; i++)
{
if (i == insertIndex)
{
dest[i] = newSystem;
}
else if (i == dest.Length - 1)
{
dest[i] = newPostSystem;
}
else if (i < insertIndex)
{
dest[i] = source[i];
}
else
{
dest[i] = source[i - 1];
}
}
parentSystem.subSystemList = dest;
}
public virtual void Setup()
{
m_PreviousPlayerLoop = PlayerLoop.GetCurrentPlayerLoop();
m_PreviousWorld = World.DefaultGameObjectInjectionWorld;
DefaultWorldInitialization.Initialize("Test World", true);
m_Manager = World.DefaultGameObjectInjectionWorld.EntityManager;
m_Window = CreateWindow();
m_AssertHelper = new TestHierarchyHelper(m_Window.State);
World.DefaultGameObjectInjectionWorld.GetOrCreateSystem <SceneSystem>().LoadSceneAsync(m_SubScene.SceneGUID, new SceneSystem.LoadParameters
{
Flags = SceneLoadFlags.BlockOnImport | SceneLoadFlags.BlockOnStreamIn
});
World.DefaultGameObjectInjectionWorld.Update();
}
public static void Initialize(ref PlayerLoopSystem playerLoop)
{
yielders = new ContinuationQueue[7];
runners = new PlayerLoopRunner[7];
var copyList = playerLoop.subSystemList.ToArray();
copyList[0].subSystemList = InsertRunner(copyList[0], typeof(UniTaskLoopRunners.UniTaskLoopRunnerYieldInitialization), yielders[0] = new ContinuationQueue(), typeof(UniTaskLoopRunners.UniTaskLoopRunnerInitialization), runners[0] = new PlayerLoopRunner());
copyList[1].subSystemList = InsertRunner(copyList[1], typeof(UniTaskLoopRunners.UniTaskLoopRunnerYieldEarlyUpdate), yielders[1] = new ContinuationQueue(), typeof(UniTaskLoopRunners.UniTaskLoopRunnerEarlyUpdate), runners[1] = new PlayerLoopRunner());
copyList[2].subSystemList = InsertRunner(copyList[2], typeof(UniTaskLoopRunners.UniTaskLoopRunnerYieldFixedUpdate), yielders[2] = new ContinuationQueue(), typeof(UniTaskLoopRunners.UniTaskLoopRunnerFixedUpdate), runners[2] = new PlayerLoopRunner());
copyList[3].subSystemList = InsertRunner(copyList[3], typeof(UniTaskLoopRunners.UniTaskLoopRunnerYieldPreUpdate), yielders[3] = new ContinuationQueue(), typeof(UniTaskLoopRunners.UniTaskLoopRunnerPreUpdate), runners[3] = new PlayerLoopRunner());
copyList[4].subSystemList = InsertRunner(copyList[4], typeof(UniTaskLoopRunners.UniTaskLoopRunnerYieldUpdate), yielders[4] = new ContinuationQueue(), typeof(UniTaskLoopRunners.UniTaskLoopRunnerUpdate), runners[4] = new PlayerLoopRunner());
copyList[5].subSystemList = InsertRunner(copyList[5], typeof(UniTaskLoopRunners.UniTaskLoopRunnerYieldPreLateUpdate), yielders[5] = new ContinuationQueue(), typeof(UniTaskLoopRunners.UniTaskLoopRunnerPreLateUpdate), runners[5] = new PlayerLoopRunner());
copyList[6].subSystemList = InsertRunner(copyList[6], typeof(UniTaskLoopRunners.UniTaskLoopRunnerYieldPostLateUpdate), yielders[6] = new ContinuationQueue(), typeof(UniTaskLoopRunners.UniTaskLoopRunnerPostLateUpdate), runners[6] = new PlayerLoopRunner());
playerLoop.subSystemList = copyList;
PlayerLoop.SetPlayerLoop(playerLoop);
}
static void Insert(ref PlayerLoopSystem playerLoopSystem, Type playerLoopType, Func <List <PlayerLoopSystem>, bool> function)
{
for (int i = 0; i < playerLoopSystem.subSystemList.Length; i++)
{
var mainSystem = playerLoopSystem.subSystemList[i];
if (mainSystem.type == playerLoopType)
{
var subSystemList = new List <PlayerLoopSystem>(mainSystem.subSystemList);
if (function(subSystemList))
{
mainSystem.subSystemList = subSystemList.ToArray();
playerLoopSystem.subSystemList[i] = mainSystem;
PlayerLoop.SetPlayerLoop(playerLoopSystem);
return;
}
}
}
}
static void DrawSystem(ref PlayerLoopSystem loop)
{
EditorGUILayout.BeginVertical();
EditorGUILayout.LabelField(loop.type != null ? loop.type.ToString() : "null");
EditorGUILayout.BeginHorizontal();
EditorGUILayout.Space(8);
EditorGUILayout.BeginVertical();
if (loop.subSystemList != null)
{
for (int i = 0; i < loop.subSystemList.Length; i++)
{
DrawSystem(ref loop.subSystemList[i]);
}
}
EditorGUILayout.EndVertical();
EditorGUILayout.EndHorizontal();
EditorGUILayout.EndVertical();
}
private static PlayerLoopSystem InsertWorldManagersInPlayerLoop(PlayerLoopSystem defaultPlayerLoop,
params World[] worlds)
{
var systemList = new List <InsertionBucket>();
foreach (var world in worlds)
{
if (world.BehaviourManagers.Count() == 0)
{
continue;
}
systemList.AddRange(CreateSystemDependencyList(world.BehaviourManagers, defaultPlayerLoop));
}
var ecsPlayerLoop = CreatePlayerLoop(systemList, defaultPlayerLoop);
return(ecsPlayerLoop);
}
private static bool InsertAfter <T>(PlayerLoopSystem subSystem, ref PlayerLoopSystem parentSystem)
where T : struct
{
var subSystems = parentSystem.subSystemList?.ToList();
if (subSystems == default)
{
return(false);
}
bool found = false;
for (int i = 0; i < subSystems.Count; i++)
{
var s = subSystems[i];
if (s.type == typeof(T))
{
found = true;
subSystems.Insert(i + 1, subSystem);
break;
}
}
if (!found)
{
for (int i = 0; i < subSystems.Count; i++)
{
var s = subSystems[i];
if (InsertAfter <T>(subSystem, ref s))
{
found = true;
subSystems[i] = s;
break;
}
}
}
if (found)
{
parentSystem.subSystemList = subSystems.ToArray();
}
return(found);
}
void Awake()
{
foreach (World world in World.AllWorlds)
{
if (world.Name == "Server World")
{
serverWorld = world;
server = serverWorld.GetOrCreateManager <Server>();
}
if (world.Name == "Client World")
{
clientWorld = world;
client = clientWorld.GetOrCreateManager <Client>();
}
}
CustomUpdateSystem customUpdateSystem = new CustomUpdateSystem(new ComponentSystem[] { client, server });
PlayerLoopSystem playerLoopSystem = ScriptBehaviourUpdateOrder.CurrentPlayerLoop;
PlayerLoopSystem[] subsystems = playerLoopSystem.subSystemList;
for (int i = 0; i < subsystems.Length; i++)
{
PlayerLoopSystem system = subsystems[i];
if (system.type == typeof(FixedUpdate))
{
PlayerLoopSystem fixedUpdateSystem = system;
List <PlayerLoopSystem> fixedUpdateSystems = new List <PlayerLoopSystem>(system.subSystemList);
PlayerLoopSystem customPlayerLoop = new PlayerLoopSystem();
customPlayerLoop.type = typeof(CustomUpdateSystem);
customPlayerLoop.updateDelegate = customUpdateSystem.FixedUpdate;
fixedUpdateSystems.Add(customPlayerLoop);
fixedUpdateSystem.subSystemList = fixedUpdateSystems.ToArray();
playerLoopSystem.subSystemList[i] = fixedUpdateSystem;
}
}
ScriptBehaviourUpdateOrder.SetPlayerLoop(playerLoopSystem);
}
// Start is called before the first frame update
public void Setup()
{
if (Application.IsPlaying(gameObject))
{
DontDestroyOnLoad(gameObject);
PlayerLoopSystem loopSystemRoot = PlayerLoop.GetCurrentPlayerLoop();
EditPhysics(ref loopSystemRoot, false);
//physicsLoopSystem.
//physicsLoopSystem.updateDelegate
PlayerLoop.SetPlayerLoop(loopSystemRoot);
//Debug.Log(PhysXLib.AddNumberses(12, 7));
}
}
void ValidatePostAppendPlayerLoop(PlayerLoopSystem playerLoop, Type targetStageType, ComponentSystemBase system)
{
if (playerLoop.type == targetStageType)
{
Assert.IsTrue(IsSystemInSubsystemList(playerLoop.subSystemList, system));
}
else
{
Assert.IsFalse(IsSystemInSubsystemList(playerLoop.subSystemList, system));
}
if (playerLoop.subSystemList != null)
{
for (int i = 0; i < playerLoop.subSystemList.Length; ++i)
{
ValidatePostAppendPlayerLoop(playerLoop.subSystemList[i], targetStageType, system);
}
}
}
static PlayerLoopSystem[] InsertRunner(PlayerLoopSystem loopSystem, Type loopRunnerYieldType,
ContinuationQueue cq, Type loopRunnerType, PlayerLoopRunner runner)
{
#if UNITY_EDITOR
EditorApplication.playModeStateChanged += (state) =>
{
if (state == PlayModeStateChange.EnteredEditMode ||
state == PlayModeStateChange.EnteredPlayMode)
{
return;
}
if (runner != null)
{
runner.Clear();
}
if (cq != null)
{
cq.Clear();
}
};
#endif
var yieldLoop = new PlayerLoopSystem
{
type = loopRunnerYieldType,
updateDelegate = cq.Run
};
var runnerLoop = new PlayerLoopSystem
{
type = loopRunnerType,
updateDelegate = runner.Run
};
var source = loopSystem.subSystemList // Remove items from previous initializations.
.Where(ls => ls.type != loopRunnerYieldType && ls.type != loopRunnerType).ToArray();
var dest = new PlayerLoopSystem[source.Length + 2];
Array.Copy(source, 0, dest, 2, source.Length);
dest[0] = yieldLoop;
dest[1] = runnerLoop;
return(dest);
}
private static void FindNativeStuff(PlayerLoopSystem playerLoopSystem, Dictionary <IntPtr, List <Type> > ptrToSystems, Func <PlayerLoopSystem, IntPtr> grabPtr)
{
var ptr = grabPtr(playerLoopSystem);
if (!ptrToSystems.ContainsKey(ptr))
{
ptrToSystems[ptr] = new List <Type>();
}
ptrToSystems[ptr].Add(playerLoopSystem.type);
if (playerLoopSystem.subSystemList != null)
{
foreach (var subSystem in playerLoopSystem.subSystemList)
{
FindNativeStuff(subSystem, ptrToSystems, grabPtr);
}
}
}
static void InsertPlayerLoopSystem()
{
var customSystem = new PlayerLoopSystem()
{
type = typeof(MemoryPool), updateDelegate = OnEndOfFrame
};
var playerLoop = PlayerLoop.GetCurrentPlayerLoop();
for (var i = 0; i < playerLoop.subSystemList.Length; i++)
{
ref var phase = ref playerLoop.subSystemList[i];
if (phase.type == typeof(UnityEngine.PlayerLoop.PostLateUpdate))
{
phase.subSystemList = phase.subSystemList
.Concat(new [] { customSystem }).ToArray();
break;
}
}
static PlayerLoopSystem[] InsertRunner(PlayerLoopSystem loopSystem, Type loopRunnerYieldType, ContinuationQueue cq, Type loopRunnerType, PlayerLoopRunner runner)
{
var yieldLoop = new PlayerLoopSystem
{
type = loopRunnerYieldType,
#if UNITY_EDITOR
updateDelegate = () =>
{
if (Application.isPlaying)
{
cq.Run();
}
}
#else
updateDelegate = cq.Run
#endif
};
var runnerLoop = new PlayerLoopSystem
{
type = loopRunnerType,
#if UNITY_EDITOR
updateDelegate = () =>
{
if (Application.isPlaying)
{
runner.Run();
}
}
#else
updateDelegate = runner.Run
#endif
};
var source = loopSystem.subSystemList // Remove items from previous initializations.
.Where(ls => ls.type != loopRunnerYieldType && ls.type != loopRunnerType).ToArray();
var dest = new PlayerLoopSystem[source.Length + 2];
Array.Copy(source, 0, dest, 2, source.Length);
dest[0] = yieldLoop;
dest[1] = runnerLoop;
return(dest);
}
private void SetStuff(World world)
{
var playerLoop = PlayerLoop.GetCurrentPlayerLoop();
for (int i = 0; i < playerLoop.subSystemList.Length; i++)
{
ComponentSystemGroup mgr;
var group = playerLoop.subSystemList[i];
if (@group.type == typeof(FixedUpdate))
{
mgr = world.GetOrCreateSystem <SimulationSystemGroup>();
}
else if (@group.type == typeof(PreLateUpdate))
{
mgr = world.GetOrCreateSystem <PresentationSystemGroup>();
}
else if (@group.type == typeof(Initialization))
{
mgr = world.GetOrCreateSystem <InitializationSystemGroup>();
}
else
{
continue;
}
var newSubsystemList = new PlayerLoopSystem[@group.subSystemList.Length + 1];
for (var ii = 0; ii < @group.subSystemList.Length; ++ii)
{
newSubsystemList[ii] = @group.subSystemList[ii];
}
insertManagerIntoSubsystemListMethod.MakeGenericMethod(mgr.GetType())
.Invoke(null, new object[] { newSubsystemList, @group.subSystemList.Length + 0, mgr });
playerLoop.subSystemList[i].subSystemList = newSubsystemList;
}
PlayerLoop.SetPlayerLoop(playerLoop);
}
public override void Setup()
{
base.Setup();
#if !UNITY_DOTSRUNTIME
// unit tests preserve the current player loop to restore later, and start from a blank slate.
m_PreviousPlayerLoop = PlayerLoop.GetCurrentPlayerLoop();
PlayerLoop.SetPlayerLoop(PlayerLoop.GetDefaultPlayerLoop());
#endif
m_PreviousWorld = World.DefaultGameObjectInjectionWorld;
World = World.DefaultGameObjectInjectionWorld = new World("Test World");
m_Manager = World.EntityManager;
m_ManagerDebug = new EntityManager.EntityManagerDebug(m_Manager);
// Many ECS tests will only pass if the Jobs Debugger enabled;
// force it enabled for all tests, and restore the original value at teardown.
JobsDebuggerWasEnabled = JobsUtility.JobDebuggerEnabled;
JobsUtility.JobDebuggerEnabled = true;
}
private static void AddSystem <T>(ref PlayerLoopSystem def) where T : ComponentSystemBase
{
var list = new PlayerLoopSystem[def.subSystemList.Length + 1];
def.subSystemList.CopyTo(list, 0);
list[def.subSystemList.Length].type = typeof(T);
var type = Assembly.GetAssembly(typeof(ScriptBehaviourUpdateOrder)).GetTypes()
.FirstOrDefault(x => x.Name == "DummyDelegateWrapper");
if (type != null)
{
var instance = Activator.CreateInstance(type, LineWorld.World.GetOrCreateSystem <T>());
list[def.subSystemList.Length].updateDelegate = (PlayerLoopSystem.UpdateFunction)type
.GetMethod("TriggerUpdate")
?.CreateDelegate(typeof(PlayerLoopSystem.UpdateFunction),
instance);
}
def.subSystemList = list;
}
static void InsertPlayerLoopSystem()
{
var customSystem = new PlayerLoopSystem()
{
type = typeof(MidiSystemWrangler),
updateDelegate = () => _driver?.Update()
};
var playerLoop = PlayerLoop.GetCurrentPlayerLoop();
for (var i = 0; i < playerLoop.subSystemList.Length; i++)
{
ref var phase = ref playerLoop.subSystemList[i];
if (phase.type == typeof(UnityEngine.PlayerLoop.EarlyUpdate))
{
phase.subSystemList =
phase.subSystemList.Concat(new [] { customSystem }).ToArray();
break;
}
}
static void RemoveWorldFromPlayerLoopSystem(World world, ref PlayerLoopSystem pls)
{
if (pls.subSystemList == null || pls.subSystemList.Length == 0)
{
return;
}
var newSubsystemList = new List <PlayerLoopSystem>(pls.subSystemList.Length);
for (int i = 0; i < pls.subSystemList.Length; ++i)
{
RemoveWorldFromPlayerLoopSystem(world, ref pls.subSystemList[i]);
if (!IsDelegateForWorldSystem(world, pls.subSystemList[i]))
{
newSubsystemList.Add(pls.subSystemList[i]);
}
}
pls.subSystemList = newSubsystemList.ToArray();
}
static PlayerLoopSystem[] InsertRunner(PlayerLoopSystem loopSystem, Type loopRunnerYieldType, ContinuationQueue cq, Type loopRunnerType, PlayerLoopRunner runner)
{
var yieldLoop = new PlayerLoopSystem
{
type = loopRunnerYieldType,
#if UNITY_EDITOR
updateDelegate = () =>
{
if (Application.isPlaying)
{
cq.Run();
}
}
#else
updateDelegate = cq.Run
#endif
};
var runnerLoop = new PlayerLoopSystem
{
type = loopRunnerType,
#if UNITY_EDITOR
updateDelegate = () =>
{
if (Application.isPlaying)
{
runner.Run();
}
}
#else
updateDelegate = runner.Run
#endif
};
var dest = new PlayerLoopSystem[loopSystem.subSystemList.Length + 2];
Array.Copy(loopSystem.subSystemList, 0, dest, 2, loopSystem.subSystemList.Length);
dest[0] = yieldLoop;
dest[1] = runnerLoop;
return(dest);
}
static PlayerLoopSystem[] InsertRunner(PlayerLoopSystem loopSystem, Type loopRunnerYieldType,
ContinuationQueue cq, Type loopRunnerType, PlayerLoopRunner runner)
{
#if UNITY_EDITOR
EditorApplication.playModeStateChanged += (state) =>
{
if (state == PlayModeStateChange.EnteredEditMode || state == PlayModeStateChange.EnteredPlayMode)
{
return;
}
if (runner != null)
{
runner.Clear();
}
if (cq != null)
{
cq.Clear();
}
};
#endif
var yieldLoop = new PlayerLoopSystem
{
type = loopRunnerYieldType,
updateDelegate = cq.Run
};
var runnerLoop = new PlayerLoopSystem
{
type = loopRunnerType,
updateDelegate = runner.Run
};
var dest = new PlayerLoopSystem[loopSystem.subSystemList.Length + 2];
Array.Copy(loopSystem.subSystemList, 0, dest, 2, loopSystem.subSystemList.Length);
dest[0] = yieldLoop;
dest[1] = runnerLoop;
return(dest);
}
public static void SetupLateAwake(Corner corner)
{
// 初期化順リストに追加
hookObject.uninitialized.Add(corner);
// 現行のplayerLoopにLateAwakeをcallするタイミングを追加
var currentPlayerLoop = PlayerLoop.GetCurrentPlayerLoop();
var currentPlayerLoopSubSystems = currentPlayerLoop.subSystemList;
for (var i = 0; i < currentPlayerLoopSubSystems.Length; i++)
{
var system = currentPlayerLoopSubSystems[i];
if (system.type == typeof(UnityEngine.PlayerLoop.Initialization))
{
var targetSystemList = system.subSystemList.ToList();
if (targetSystemList.Where(sys => sys.type == typeof(LateAwakeSystem)).Any())
{
// すでにセットされているので何もしない
return;
}
var initializer = new PlayerLoopSystem()
{
type = typeof(LateAwakeSystem),
updateDelegate = hookObject.LateAwake
};
// 先頭に導入 initializer が先頭に来るようにすると、このフレームで着火する。
targetSystemList.Insert(0, initializer);
// 上書き
currentPlayerLoopSubSystems[i].subSystemList = targetSystemList.ToArray();
PlayerLoop.SetPlayerLoop(currentPlayerLoop);
// セット完了したので終了する
return;
}
}
}
static void RuntimeInitializeOnLoad()
{
// get loop
// TODO 2019 has GetCURRENTPlayerLoop which is safe to use without
// breaking other custom system's custom loops. Let's use Default
// for now until we upgrade to 2019 so we have the same behaviour
// at all times (instead of different loop behavior on 2018/2019)
PlayerLoopSystem playerLoop = PlayerLoop.GetDefaultPlayerLoop();
// add NetworkEarlyUpdate to the end of EarlyUpdate so it runs after
// any Unity initializations but before the first Update/FixedUpdate
AddToPlayerLoop(NetworkEarlyUpdate, typeof(NetworkLoop), ref playerLoop, typeof(EarlyUpdate), AddMode.End);
// add NetworkLateUpdate to the end of PreLateUpdate so it runs after
// LateUpdate(). adding to the beginning of PostLateUpdate doesn't
// actually work.
AddToPlayerLoop(NetworkLateUpdate, typeof(NetworkLoop), ref playerLoop, typeof(PreLateUpdate), AddMode.End);
// set the new loop
PlayerLoop.SetPlayerLoop(playerLoop);
}
static bool IsWorldInPlayerLoopSystem(World world, PlayerLoopSystem pls)
{
// Is *this* system a delegate for a component system associated with the current World?
if (IsDelegateForWorldSystem(world, pls))
{
return(true);
}
// How about anything in the subsystem list?
if (pls.subSystemList != null)
{
for (int i = 0; i < pls.subSystemList.Length; ++i)
{
if (IsWorldInPlayerLoopSystem(world, pls.subSystemList[i]))
{
return(true);
}
}
}
// Nope.
return(false);
}
/// <summary>
/// Add system in front of subSystem list of T
/// </summary>
/// <typeparam name="T">type of system to search for</typeparam>
/// <param name="system">system to search through</param>
/// <param name="addition">system ti insert</param>
/// <returns>returns false if system T was not found</returns>
public static bool AddToLoop <T>(ref PlayerLoopSystem system, PlayerLoopSystem addition)
{
if (system.type == typeof(T))
{
List <PlayerLoopSystem> systems = new List <PlayerLoopSystem>(system.subSystemList);
systems.Insert(0, addition);
system.subSystemList = systems.ToArray();
return(true);
}
if (system.subSystemList != null)
{
for (int i = 0; i < system.subSystemList.Length; i++)
{
if (AddToLoop <T>(ref system.subSystemList[i], addition))
{
return(true);
}
}
}
return(false);
}