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); }