示例#1
0
        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);
        }
示例#2
0
        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;
        }
示例#5
0
		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;
		}
示例#6
0
        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();
        }
示例#8
0
        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;
             }
         }
     }
 }
示例#10
0
 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);
        }
示例#12
0
        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);
        }
示例#13
0
    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);
    }
示例#14
0
    // 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);
            }
        }
    }
示例#18
0
        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;
                }
            }
示例#19
0
        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);
        }
示例#20
0
    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;
        }
示例#22
0
        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;
        }
示例#23
0
        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);
        }
示例#26
0
        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);
        }
示例#27
0
        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;
                }
            }
        }
示例#28
0
        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);
 }
示例#30
0
 /// <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);
 }