public static void RegisterSystems(World world, SystemCategories categories)
{
var systems = new List <Type>();
if ((categories & SystemCategories.Streaming) == SystemCategories.Streaming)
{
systems.AddRange(new []
{
typeof(SceneSystemGroup),
typeof(SceneSystem),
typeof(ResolveSceneReferenceSystem),
typeof(SceneSectionStreamingSystem)
});
}
#if !UNITY_DISABLE_MANAGED_COMPONENTS
if ((categories & SystemCategories.HybridComponents) == SystemCategories.HybridComponents)
{
systems.AddRange(new []
{
typeof(CompanionGameObjectUpdateSystem),
typeof(CompanionGameObjectUpdateTransformSystem)
});
}
#endif
DefaultWorldInitialization.AddSystemsToRootLevelSystemGroups(world, systems);
}
public void Initialize(bool createClientWorld, bool createServerWorld)
{
var systems = DefaultWorldInitialization.GetAllSystems(WorldSystemFilterFlags.Default);
GenerateSystemLists(systems);
var world = new World("DefaultWorld");
World.DefaultGameObjectInjectionWorld = world;
DefaultWorldInitialization.AddSystemsToRootLevelSystemGroups(world, ExplicitDefaultWorldSystems);
var currentPlayerLoop = PlayerLoop.GetCurrentPlayerLoop();
ScriptBehaviourUpdateOrder.AddWorldToPlayerLoop(world, ref currentPlayerLoop);
PlayerLoop.SetPlayerLoop(currentPlayerLoop);
if (createClientWorld)
{
CreateClientWorld(world, "ClientWorld");
}
if (createServerWorld)
{
CreateServerWorld(world, "ServerWorld");
}
EntityWorldManager.Instance.Initialize();
}
public virtual bool Initialize(string defaultWorldName)
{
World defaultWorld = new World(defaultWorldName);
World.DefaultGameObjectInjectionWorld = defaultWorld;
var systems = DefaultWorldInitialization.GetAllSystems(WorldSystemFilterFlags.Default);
GenerateSystemList(systems);
DefaultWorldInitialization.AddSystemsToRootLevelSystemGroups(defaultWorld,
SystemStates.ExplicitDefaultWorldSystems);
ScriptBehaviourUpdateOrder.AddWorldToCurrentPlayerLoop(defaultWorld);
Config = GetBootstrapConfig();
#if !UNITY_SERVER || UNITY_EDITOR
if (Config.StartupWorld.HasFlag(TargetWorld.Client))
{
for (int i = 0; i < Config.ClientNum; i++)
{
CreateClientWorld(defaultWorld, "ClientWorld" + i);
}
}
#endif
#if UNITY_SERVER || UNITY_EDITOR
if (Config.StartupWorld.HasFlag(TargetWorld.Server))
{
CreateServerWorld(defaultWorld, "ServerWorld");
}
#endif
return(true);
}
// Add a system to the world - repects the systems'
// [UpdateInGroup] and [UpdateBefore/After] attribute settings
protected T AddSystemToWorld <T>() where T : SystemBase
{
DefaultWorldInitialization.AddSystemsToRootLevelSystemGroups(
World,
typeof(T));
return(World.GetExistingSystem <T>());
}
public void OnContextInitialized <T>(T contextHolder)
{
// Create engine root.
_submissionScheduler = new SimpleEntitiesSubmissionScheduler();
_enginesRoot = new EnginesRoot(_submissionScheduler);
// Initialize UECS.
_world = new World("SveltoWorld");
var systems = DefaultWorldInitialization.GetAllSystems(WorldSystemFilterFlags.Default);
DefaultWorldInitialization.AddSystemsToRootLevelSystemGroups(_world, systems);
World.DefaultGameObjectInjectionWorld = _world;
var syncGroup = new SyncSveltoToUECSGroup();
_world.AddSystem(syncGroup);
AddTickEngine(syncGroup);
var uecsTickGroup = new PureUECSSystemsGroup(_world);
AddTickEngine(uecsTickGroup);
// Initialize SECS
var entityFactory = _enginesRoot.GenerateEntityFactory();
}
void CreateUnityECSWorldForSvelto(SimpleEntitiesSubmissionScheduler scheduler, EnginesRoot enginesRoot)
{
world = new World("Svelto<>UECS world");
var systems = DefaultWorldInitialization.GetAllSystems(WorldSystemFilterFlags.Default);
DefaultWorldInitialization.AddSystemsToRootLevelSystemGroups(world, systems);
World.DefaultGameObjectInjectionWorld = world;
//This is the UECS group that takes care of all the UECS systems that creates entities
//it also submits Svelto entities
_sveltoUecsEntitiesSubmissionGroup = new SveltoUECSEntitiesSubmissionGroup(scheduler);
//This is the group that handles the UECS sync systems that copy the svelto entities values to UECS entities
enginesRoot.AddEngine(_sveltoUecsEntitiesSubmissionGroup);
world.AddSystem(_sveltoUecsEntitiesSubmissionGroup);
_syncSveltoToUecsGroup = new SyncSveltoToUECSGroup();
enginesRoot.AddEngine(_syncSveltoToUecsGroup);
_syncUecsToSveltoGroup = new SyncUECSToSveltoGroup();
enginesRoot.AddEngine(_syncUecsToSveltoGroup);
//This is the group that handles the UECS sync systems that copy the UECS entities values to svelto entities
//enginesRoot.AddEngine(new SveltoUECSEntitiesSubmissionGroup(scheduler, world));
enginesRoot.AddEngine(this);
_enginesRoot = enginesRoot;
}
public IEnumerator E()
{
GameObject go = null;
for (int i = 0; i < amount; i++)
{
go = new GameObject("test", typeof(WorkObjectWithoutUpdate));
var cte = go.AddComponent <ConvertToEntity>();
cte.ConversionMode = ConvertToEntity.Mode.ConvertAndInjectGameObject;
}
DefaultWorldInitialization.AddSystemsToRootLevelSystemGroups(
World.DefaultGameObjectInjectionWorld,
new List <Type> {
typeof(WorkObjectSmarterNoCopySystem)
}); // <-------
yield return(Measure.Frames().WarmupCount(10).MeasurementCount(100).Run());
var cda = World.DefaultGameObjectInjectionWorld.EntityManager.CreateEntityQuery(ComponentType
.ReadOnly <WorkObjectData>()).ToComponentDataArray <WorkObjectData>(Allocator.TempJob);
Assert.That(cda[0].timesUpdated, Is.EqualTo(110 - 1));
cda.Dispose();
}
public void CreateWorlds(bool server, int numClients)
{
if (!m_DefaultWorldInitialized)
{
DefaultWorldInitialization.AddSystemsToRootLevelSystemGroups(m_DefaultWorld,
ClientServerBootstrap.ExplicitDefaultWorldSystems);
m_DefaultWorldInitialized = true;
}
if (server)
{
if (m_ServerWorld != null)
{
throw new InvalidOperationException("Server world already created");
}
m_ServerWorld = ClientServerBootstrap.CreateServerWorld(m_DefaultWorld, "ServerTest");
}
if (numClients > 0)
{
if (m_ClientWorlds != null)
{
throw new InvalidOperationException("Client worlds already created");
}
m_ClientWorlds = new World[numClients];
for (int i = 0; i < numClients; ++i)
{
m_ClientWorlds[i] = ClientServerBootstrap.CreateClientWorld(m_DefaultWorld, $"ClientTest{i}");
}
}
}
/// <summary>
/// 创建服务端世界
/// </summary>
public World CreateServerWorld(string ServerWorldName, params string[] EnableMods)
{
//创建世界
World ServerWorld = new World(ServerWorldName);
EntityManager manager = ServerWorld.EntityManager;
//添加世界信息组件
Entity e = manager.CreateEntity(ComponentType.ReadWrite <WorldTypeInfo>());
manager.SetComponentData(e, new WorldTypeInfo()
{
type = WorldTypes.ServerWorld
});
manager.SetName(e, "WorldTypeInfo");
//为接下来将在ServerWorld中禁用的Presentation组的系统做缓存，节省查找开销
List <Type>[] types = new List <Type> [EnableMods.Length];
//轮询添加系统
for (int i = 0; i < EnableMods.Length; i++)
{
NativeModSystems mod = ModSystems[EnableMods[i]];
DefaultWorldInitialization.AddSystemsToRootLevelSystemGroups(ServerWorld, mod.DefaultWorldSystem);
DefaultWorldInitialization.AddSystemsToRootLevelSystemGroups(ServerWorld, mod.ServerSystems);
//缓存
types[i] = mod.DefaultPresentationSystems;
}
ScriptBehaviourUpdateOrder.AddWorldToCurrentPlayerLoop(ServerWorld);
//获取ServerWorld中的PresentationSystemGroup并禁止其运行
for (int i = 0; i < types.Length; i++)
{
for (int j = 0; j < types[i].Count; j++)
{
ServerWorld.GetExistingSystem(types[i][j]).Enabled = false;
}
}
return(ServerWorld);
}
void Start()
{
if (_material == null)
{
Debug.LogWarning($"You forgot to set \'{nameof(_material)}\' field in the inspector!", gameObject);
return;
}
if (_world == null)
{
_world = new World($"{nameof(EntityWorkflowSpawner)} World");
DefaultWorldInitialization.AddSystemsToRootLevelSystemGroups(
_world
, typeof(LineSegmentTransformSystem)
);
ScriptBehaviourUpdateOrder.UpdatePlayerLoop(_world, UnityEngine.LowLevel.PlayerLoop.GetCurrentPlayerLoop());
}
_entities = InstantiateLines(
world: _world,
material: _material,
lineWidth: _lineWidth,
segments: _segments,
tauFactor: _tauFactor,
worldScale: _worldScale,
matrix: transform.localToWorldMatrix,
spherize: _spherize
);
}
public void SetUp()
{
TestWorld = new World("EntityEventsTestWorld");
DefaultWorldInitialization.AddSystemsToRootLevelSystemGroups(TestWorld,
new[] { typeof(BeginInitializationEntityCommandBufferSystem) });
TestWorld.CreateSystem <EventComponentSystem>();
}
public override bool Initialize(string defaultWorldName)
{
var sceneName = UnityEngine.SceneManagement.SceneManager.GetActiveScene().name;
if (sceneName == "Asteroids" ||
sceneName == "NetCube" ||
sceneName == "LagCompensation" ||
sceneName.StartsWith("BasicPrespawnTest") ||
sceneName.StartsWith("Test"))
{
return(base.Initialize(defaultWorldName));
}
var world = new World(defaultWorldName);
World.DefaultGameObjectInjectionWorld = world;
var systems = DefaultWorldInitialization.GetAllSystems(WorldSystemFilterFlags.Default);
GenerateSystemLists(systems);
DefaultWorldInitialization.AddSystemsToRootLevelSystemGroups(world, DefaultWorldSystems);
ScriptBehaviourUpdateOrder.UpdatePlayerLoop(world);
return(true);
}
private void Start()
{
#if UNITY_DISABLE_AUTOMATIC_SYSTEM_BOOTSTRAP_RUNTIME_WORLD
//DefaultWorldInitialization.Initialize("Default World", false);
//world = World.DefaultGameObjectInjectionWorld;
world = new World("AAA");
World.DefaultGameObjectInjectionWorld = world;
var systems = DefaultWorldInitialization.GetAllSystems(WorldSystemFilterFlags.Default, false);
DefaultWorldInitialization.AddSystemsToRootLevelSystemGroups(world, systems);
ScriptBehaviourUpdateOrder.UpdatePlayerLoop(world);
var types = world.EntityManager.CreateArchetype(typeof(Translation), typeof(Rotation), typeof(Scale), typeof(LocalToWorld));
var entity = world.EntityManager.CreateEntity(types);
var scale = world.EntityManager.GetComponentData <Scale>(entity);
scale.Value = 1;
world.EntityManager.SetComponentData(entity, scale);
world.CreateSystem <ECSInputSystem>();
world.CreateSystem <ECSGpuInstancedAnimationSystem>();
Init(entity, world.EntityManager);
#endif
}
public override bool Initialize(string defaultWorldName)
{
var sceneName = UnityEngine.SceneManagement.SceneManager.GetActiveScene().name;
bool isSampleScene = (sceneName == "Asteroids" || sceneName == "NetCube" || sceneName == "LagCompensation");
bool isTestScene = (sceneName.StartsWith("BasicPrespawnTest") || sceneName.StartsWith("Test"));
if (isSampleScene || isTestScene)
{
// For the sample scenes we use a dynamic assembly list so we can build a server with a subset of the assemblies
// (only including one of the samples instead of all)
RpcSystem.DynamicAssemblyList = isSampleScene;
var success = base.Initialize(defaultWorldName);
RpcSystem.DynamicAssemblyList = false;
return(success);
}
var world = new World(defaultWorldName, WorldFlags.Game);
World.DefaultGameObjectInjectionWorld = world;
var systems = DefaultWorldInitialization.GetAllSystems(WorldSystemFilterFlags.Default);
GenerateSystemLists(systems);
DefaultWorldInitialization.AddSystemsToRootLevelSystemGroups(world, DefaultWorldSystems);
#if !UNITY_DOTSRUNTIME
ScriptBehaviourUpdateOrder.AddWorldToCurrentPlayerLoop(world);
#endif
return(true);
}
public override bool Initialize(string defaultWorldName)
{
#if UNITY_EDITOR
// TODO (timj) make this check more generic
if (UnityEditor.SceneManagement.EditorSceneManager.GetSceneAt(0).name.ToLower() != "bootstrapper")
{
IsSingleLevelPlaymode = true;
if (!GameApp.IsInitialized)
{
//SceneManager.LoadScene(0);
var go = (GameObject)GameObject.Instantiate(Resources.Load("Prefabs/Game", typeof(GameObject)));
GameDebug.Assert(GameApp.IsInitialized, "Failed to load Game prefab");
}
return(base.Initialize(defaultWorldName));
}
IsSingleLevelPlaymode = false;
#endif
var systems = DefaultWorldInitialization.GetAllSystems(WorldSystemFilterFlags.Default);
GenerateSystemLists(systems);
DefaultWorld = new World(defaultWorldName);
World.DefaultGameObjectInjectionWorld = DefaultWorld;
DefaultWorldInitialization.AddSystemsToRootLevelSystemGroups(DefaultWorld, ExplicitDefaultWorldSystems);
ScriptBehaviourUpdateOrder.UpdatePlayerLoop(DefaultWorld);
return(true);
}
public static World CreateNewDedicatedRenderingWorld(string name)
{
var world = new World(name);
{
var systems = new System.Type[] {
#if ENABLE_HYBRID_RENDERER_V2
typeof(HybridRendererSystem)
#else
typeof(RenderMeshSystemV2)
#endif
// fixes: warning from RenderMeshSystemV2
, typeof(UpdatePresentationSystemGroup)
, typeof(PresentationSystemGroup)
, typeof(StructuralChangePresentationSystemGroup)
// fixes: "Internal: deleting an allocation that is older than its permitted lifetime of 4 frames (age = 15)"
, typeof(EndSimulationEntityCommandBufferSystem)
, typeof(SegmentInitializationSystem)
, typeof(SegmentTransformSystem)
, typeof(SegmentWorldBoundsSystem)
, typeof(CreateSegmentsSystem)
};
DefaultWorldInitialization.AddSystemsToRootLevelSystemGroups(world, systems);
ScriptBehaviourUpdateOrder.AddWorldToCurrentPlayerLoop(world);
// var defaultSystems = DefaultWorldInitialization.GetAllSystems( WorldSystemFilterFlags.Default );
// DefaultWorldInitialization.AddSystemsToRootLevelSystemGroups( world , defaultSystems );
// // EntitySceneOptimization.Optimize( world );// what's this for?
// ScriptBehaviourUpdateOrder.AddWorldToCurrentPlayerLoop( world );
}
return(world);
}
private void SetUpWorld()
{
DefaultWorldInitialization.AddSystemsToRootLevelSystemGroups(w,
new List <Type> {
typeof(T), typeof(ConstantDeltaTimeSystem)
});
}
public static World CreateEntityWorld(string name, bool isEditor)
{
var systems = DefaultWorldInitialization.GetAllSystems(WorldSystemFilterFlags.Default, true);;
var world = new World(name, isEditor ? WorldFlags.Editor : WorldFlags.Game);
DefaultWorldInitialization.AddSystemsToRootLevelSystemGroups(world, FilterSystemsToPackages(systems, EntitiesPackage));
return(world);
}
private void SetUpWorld()
{
var allSystems =
DefaultWorldInitialization.GetAllSystems(WorldSystemFilterFlags.Default, requireExecuteAlways: false);
DefaultWorldInitialization.AddSystemsToRootLevelSystemGroups(w,
allSystems.Concat(new[] { typeof(ConstantDeltaTimeSystem) }));
}
static void Init()
{
DefaultWorldInitialization.AddSystemsToRootLevelSystemGroups(World.DefaultGameObjectInjectionWorld,
new List <Type>()
{
typeof(RLTKTutorialSystems)
});
}
protected virtual void Setup()
{
World = DefaultWorldInitialization.Initialize("Test World");
DefaultWorldInitialization.AddSystemsToRootLevelSystemGroups(World,
DefaultWorldInitialization.GetAllSystems(WorldSystemFilterFlags.Editor));
BlobStore = new BlobAssetStore();
}
void LoadScene(Switch sceneSwitch)
{
PlayType playModeType = RequestedPlayType;
if (sceneSwitch.switchClientorServer == "server")
{
playModeType = PlayType.ClientAndServer;
}
if (sceneSwitch.switchClientorServer == "client")
{
playModeType = PlayType.Client;
}
var systems = DefaultWorldInitialization.GetAllSystems(WorldSystemFilterFlags.Default);
GenerateSystemLists(systems);
var world = new World("Default World");
World.DefaultGameObjectInjectionWorld = world;
DefaultWorldInitialization.AddSystemsToRootLevelSystemGroups(world, ExplicitDefaultWorldSystems);
ScriptBehaviourUpdateOrder.UpdatePlayerLoop(world);
int numClientWorlds = RequestedNumClients;
int totalNumClients = numClientWorlds;
if (playModeType != PlayType.Server)
{
#if UNITY_EDITOR
int numThinClients = RequestedNumThinClients;
totalNumClients += numThinClients;
#endif
for (int i = 0; i < numClientWorlds; ++i)
{
CreateClientWorld(world, "ClientWorld" + i);
}
#if UNITY_EDITOR
for (int i = numClientWorlds; i < totalNumClients; ++i)
{
var clientWorld = CreateClientWorld(world, "ClientWorld" + i);
clientWorld.EntityManager.CreateEntity(typeof(ThinClientComponent));
}
#endif
}
if (playModeType != PlayType.Client)
{
CreateServerWorld(world, "ServerWorld");
}
var sceneName = sceneSwitch.switchName.ToString();
var async = SceneManager.LoadSceneAsync(sceneName, LoadSceneMode.Single);
async.allowSceneActivation = true;
}
protected virtual void SetUp()
{
World = new World("TestWorld");
EntityManager = World.EntityManager;
IReadOnlyList <Type> defaultSystems = DefaultWorldInitialization.GetAllSystems(WorldSystemFilterFlags.Default);
DefaultWorldInitialization.AddSystemsToRootLevelSystemGroups(World, defaultSystems);
DefaultWorldInitialization.AddSystemsToRootLevelSystemGroups(World, typeof(OverrideTimeSystem));
}
public static Unity.Entities.World CreateEditorWorld(List <Type> types, string worldName)
{
var space = new Unity.Entities.World(worldName);
//DefaultWorldInitialization.Initialize(worldName, false); // new Unity.Entities.World(worldName);
DefaultWorldInitialization.AddSystemsToRootLevelSystemGroups(space, GetTypes());
DefaultWorldInitialization.AddSystemsToRootLevelSystemGroups(space, GetUnityTypes());
//Unity.Entities.World.DefaultGameObjectInjectionWorld = space;
return(space);
}
public bool Initialize(string defaultWorldName)
{
World.DefaultGameObjectInjectionWorld = new World(defaultWorldName);
var systems = DefaultWorldInitialization.GetAllSystems(WorldSystemFilterFlags.Default);
DefaultWorldInitialization.AddSystemsToRootLevelSystemGroups(World.DefaultGameObjectInjectionWorld, systems);
ScriptBehaviourUpdateOrder.UpdatePlayerLoop(World.DefaultGameObjectInjectionWorld);
LoadWorld();
return(true);
}
protected void SetUpBase()
{
w = new World("Test World");
em = w.EntityManager;
emu = new EntityManagerUtility(w);
var allSystems =
DefaultWorldInitialization.GetAllSystems(WorldSystemFilterFlags.Default, requireExecuteAlways: false);
allSystems.Add(typeof(ConstantDeltaTimeSystem)); //this has disable auto creation on it.
DefaultWorldInitialization.AddSystemsToRootLevelSystemGroups(w, allSystems);
}
public void SetUp()
{
W = new World("Test World");
EM = W.EntityManager;
var allSystems = DefaultWorldInitialization.GetAllSystems(WorldSystemFilterFlags.Default)
.Where(s => s != typeof(GLFWWindowSystem));
DefaultWorldInitialization.AddSystemsToRootLevelSystemGroups(W, allSystems);
EM.AddComponent <DisplayInfo>(EM.CreateEntity());
}
public static World CreateDefaultWorld(string name)
{
var defaultWorld = new World(name);
World.DefaultGameObjectInjectionWorld = defaultWorld;
GenerateSystemLists(DefaultWorldInitialization.GetAllSystems(WorldSystemFilterFlags.Default));
DefaultWorldInitialization.AddSystemsToRootLevelSystemGroups(defaultWorld, ExplicitDefaultWorldSystems);
#if !UNITY_DOTSRUNTIME
ScriptBehaviourUpdateOrder.AddWorldToCurrentPlayerLoop(defaultWorld);
#endif
return(defaultWorld);
}
private void RegisterStreamingSystems(World world)
{
var systems = new List <Type>();
systems.AddRange(new[]
{
typeof(SceneSystemGroup),
typeof(SceneSystem),
typeof(ResolveSceneReferenceSystem),
typeof(SceneSectionStreamingSystem)
});
DefaultWorldInitialization.AddSystemsToRootLevelSystemGroups(world, systems);
}
/// <summary>
/// A bit messy, it's not from UnityECS 0.2.0 and I will need to study it better
/// </summary>
/// <param name="defaultWorldName"></param>
/// <returns></returns>
public bool Initialize(string defaultWorldName)
{
// Physics.autoSimulation = false;
_world = new World("Custom world");
World.DefaultGameObjectInjectionWorld = _world;
var systems = DefaultWorldInitialization.GetAllSystems(WorldSystemFilterFlags.Default);
DefaultWorldInitialization.AddSystemsToRootLevelSystemGroups(_world, systems);
ScriptBehaviourUpdateOrder.UpdatePlayerLoop(_world);
return(true);
}