public override void Setup()
{
base.Setup();
CloseAllDebuggers();
m_Window = EditorWindow.GetWindow <EntityDebugger>();
m_System = World.Active.GetOrCreateManager <SingleGroupSystem>();
World.Active.GetOrCreateManager <SimulationSystemGroup>().AddSystemToUpdateList(m_System);
ScriptBehaviourUpdateOrder.UpdatePlayerLoop(World.Active);
World2 = new World(World2Name);
World2.GetOrCreateManager <EntityManager>();
var emptySys = World2.GetOrCreateManager <EmptySystem>();
World.Active.GetOrCreateManager <SimulationSystemGroup>().AddSystemToUpdateList(emptySys);
World.Active.GetOrCreateManager <SimulationSystemGroup>().SortSystemUpdateList();
m_ComponentGroup = m_System.ComponentGroups[0];
m_Entity = m_Manager.CreateEntity(typeof(EcsTestData));
}
public bool Initialize(string defaultWorldName)
{
Debug.Log("Tiny Hybrid Bootstrap executing");
var world = new World("Default World");
World.DefaultGameObjectInjectionWorld = world;
var systems = DefaultWorldInitialization.GetAllSystems(WorldSystemFilterFlags.Default);
// filter out the tiny systems
systems = systems.Where(s => {
var asmName = s.Assembly.FullName;
if (asmName.Contains("Unity.Tiny") && !asmName.Contains("Hybrid"))
{
return(false);
}
return(true);
}).ToList();
DefaultWorldInitialization.AddSystemsToRootLevelSystemGroups(world, systems);
ScriptBehaviourUpdateOrder.UpdatePlayerLoop(world);
return(true);
}
private void InitWorld()
{
_store = new BlobAssetStore();
_world = new World("Common");
World.DefaultGameObjectInjectionWorld = _world;
var entityManager = _world.EntityManager;
//_world.CreateSystem<Game>();
//_world.CreateSystem<GoInGameServerSystem>();
ScriptBehaviourUpdateOrder.UpdatePlayerLoop(_world);
// Create Archetype.
var archetype = entityManager.CreateArchetype(
ComponentType.ReadWrite <PlayerData>(),
ComponentType.ReadWrite <PhysicsCollider>(),
ComponentType.ReadWrite <Rotation>(),
ComponentType.ReadWrite <Translation>());
// Create Prefab Entities.
var prefabEntity = entityManager.CreateEntity(archetype);
//entityManager.SetSharedComponentData(prefabEntity, this._meshInstanceRenderer);
// Create Entities.
for (int i = 0; i < 10; ++i)
{
var entity = entityManager.Instantiate(prefabEntity);
entityManager.SetComponentData(entity, new Translation {
Value = UnityEngine.Random.Range(1.0f, 3.0f)
});
entityManager.SetComponentData(entity, new Rotation {
Value = UnityEngine.Random.rotation
});
}
}
void CreateGameSystems()
{
foreach (var ass in AppDomain.CurrentDomain.GetAssemblies())
{
var allTypes = ass.GetTypes();
// Create all ComponentSystem
var gameControllerComponentSystems = allTypes.Where(t => t.IsSubclassOf(typeof(GameControllerComponentSystem)) && !t.IsAbstract && !t.ContainsGenericParameters);
foreach (var type in gameControllerComponentSystems)
{
try
{
gameSystemlist.Add(World.Active.GetOrCreateManager(type));
}
catch (Exception e)
{
Debug.LogException(e);
}
}
var gameControllerJobComponentSystems = allTypes.Where(t => t.IsSubclassOf(typeof(GameControllerJobComponentSystem)) && !t.IsAbstract && !t.ContainsGenericParameters);
foreach (var type in gameControllerJobComponentSystems)
{
try
{
gameSystemlist.Add(World.Active.GetOrCreateManager(type));
}
catch (Exception e)
{
Debug.LogException(e);
}
}
ScriptBehaviourUpdateOrder.UpdatePlayerLoop(World.Active);
}
}
void Start()
{
mainCamera = GetComponent <Camera>();
var world = World.Active = new World("DrawMeshInstancedIncirect");
manager = world.CreateManager <EntityManager>();
world.CreateManager(typeof(MeshInstanceRendererInstancedIndirectSystem), mainCamera, renderers, shader);
world.CreateManager(typeof(MoveSystem));
ScriptBehaviourUpdateOrder.UpdatePlayerLoop(world);
archetype = manager.CreateArchetype(ComponentType.Create <Position>(), ComponentType.Create <Velocity>(), ComponentType.Create <MeshInstanceRendererInstancedIndirectSystem.MeshInstanceRendererIndex>());
var src = manager.CreateEntity(archetype);
manager.SetSharedComponentData(src, new MeshInstanceRendererInstancedIndirectSystem.MeshInstanceRendererIndex(1u));
Set(src);
using (var _ = new NativeArray <Entity>(11450, Allocator.Temp, NativeArrayOptions.UninitializedMemory))
{
manager.Instantiate(src, _);
for (int i = 0; i < _.Length; i++)
{
Set(_[i]);
}
}
}
static void Boot()
{
var world = new World("Example World");
world.GetOrCreateManager <NavAgentSystem>();
var query = world.GetOrCreateManager <NavMeshQuerySystem>();
world.GetOrCreateManager <AnimatedRendererSystem>();
world.GetOrCreateManager <NavAgentToPositionSyncSystem>();
world.GetOrCreateManager <RecycleDeadSystem>();
var targetSystem = world.GetOrCreateManager <SetTargetSystem>();
spawner = world.GetOrCreateManager <SpawnerSystem>();
world.GetOrCreateManager <UpdateMatrixSystem>();
manager = world.GetOrCreateManager <EntityManager>();
var allWorlds = new World[] { world };
ScriptBehaviourUpdateOrder.UpdatePlayerLoop(allWorlds);
World.Active = world;
Unit = manager.CreateArchetype(
typeof(SyncPositionFromNavAgent),
typeof(Position),
typeof(TransformMatrix),
typeof(Unit),
typeof(Animated),
typeof(AnimatedState),
typeof(NavAgent)
);
PlayerLoopManager.RegisterDomainUnload(DomainUnloadShutdown, 10000);
// setup navmesh query
query.UseCache = false;
// ArchetypeDeclarationStart - Do not remove
// ArchetypeDeclarationStop - Do not remove
}
#pragma warning restore 0649
#endregion // Private Fields(Editable)
// ----------------------------------------------------
#region // Unity Events
/// <summary>
/// MonoBehaviour.Start
/// </summary>
void Start()
{
// Worldの作成
World.Active = new World("Sample World");
EntityManager entityManager = World.Active.CreateManager <EntityManager>();
World.Active.CreateManager(typeof(EndFrameTransformSystem));
World.Active.CreateManager(typeof(RenderingSystemBootstrap));
World.Active.CreateManager(typeof(PlayerMove), Camera.main.transform, this.Range);
World.Active.CreateManager(typeof(ColliderUpdate));
if (this._isSplitSpace)
{
// 衝突判定(空間分割)
World.Active.CreateManager(typeof(SplitSpaceCollisionSystem));
}
else
{
// 衝突判定(総当たり)
World.Active.CreateManager(typeof(CollisionSystem));
}
var destroyBarrier = World.Active.CreateManager <DestroyBarrier>();
World.Active.CreateManager(typeof(DestroySystem), destroyBarrier);
ScriptBehaviourUpdateOrder.UpdatePlayerLoop(World.Active);
// create player entity.
var playerArchetype = entityManager.CreateArchetype(
ComponentType.Create <Position>(), ComponentType.Create <Rotation>(), ComponentType.Create <Scale>(),
ComponentType.Create <Player>(), ComponentType.Create <SphereCollider>(),
ComponentType.Create <MeshInstanceRenderer>());
var playerEntity = entityManager.CreateEntity(playerArchetype);
entityManager.SetSharedComponentData(playerEntity, this._playerLook);
entityManager.SetComponentData(playerEntity, new Position {
Value = new float3(0)
});
entityManager.SetComponentData(playerEntity, new Scale {
Value = new float3(PlayerScale)
});
entityManager.SetComponentData(playerEntity, new SphereCollider {
Radius = SphereColliderRadius * PlayerScale
});
// create check hit entities.
var checkHitArchetype = entityManager.CreateArchetype(
ComponentType.Create <Position>(), ComponentType.Create <Rotation>(),
ComponentType.Create <CheckHit>(), ComponentType.Create <SphereCollider>(),
ComponentType.Create <Destroyable>(),
ComponentType.Create <MeshInstanceRenderer>());
// Entityの生成(各種ComponentData/SharedComponentDataの初期化)
// やっている事としては以下のリンクを参照。
// - https://qiita.com/pCYSl5EDgo/items/18f1827a5b323a7712d7
var entities = new NativeArray <Entity>(MaxObjectNum, Allocator.Temp, NativeArrayOptions.UninitializedMemory);
try
{
entities[0] = entityManager.CreateEntity(checkHitArchetype);
// MeshInstanceRendererに対するデータの設定
entityManager.SetSharedComponentData(entities[0], this._checkHitLook);
unsafe
{
var ptr = (Entity *)NativeArrayUnsafeUtility.GetUnsafePtr(entities);
var rest = NativeArrayUnsafeUtility.ConvertExistingDataToNativeArray <Entity>(ptr + 1, entities.Length - 1, Allocator.None);
#if ENABLE_UNITY_COLLECTIONS_CHECKS
NativeArrayUnsafeUtility.SetAtomicSafetyHandle(ref rest, AtomicSafetyHandle.GetTempUnsafePtrSliceHandle());
#endif
entityManager.Instantiate(entities[0], rest);
}
// 各種ComponentDataの設定
for (int i = 0; i < MaxObjectNum; ++i)
{
#if ENABLE_DEBUG
// テスト用. 横一列に配置
entityManager.SetComponentData(entities[i], new Position {
Value = new float3(5 + (i * 10), 0, 0)
});
#else
// ランダムに配置
entityManager.SetComponentData(entities[i], new Position {
Value = this.GetRandomPosition()
});
#endif
entityManager.SetComponentData(entities[i], new SphereCollider {
Radius = SphereColliderRadius * CheckHitScale
});
}
}
finally
{
entities.Dispose();
}
}
// Use this for initialization
void Start()
{
return;
var code = @"
using Unity.Entities;
using UnityEngine;
using UnityEngine.Jobs;
using P4Main.Graphics;
namespace Teessst
{
[AlwaysUpdateSystem]
public class MyCoolSystem : ComponentSystem
{
struct Group
{
public ComponentDataArray<CatmullRomSplineWorld> components;
public TransformAccessArray transforms;
public int Length;
}
[Inject] Group m_Group;
protected override void OnCreateManager(int capacity)
{
Debug.Log(""Helo"");
}
protected override void OnUpdate()
{
for (int i = 0; i != m_Group.components.Length; i++)
{
var component = m_Group.components[i];
var transform = m_Group.transforms[i];
transform.position = new Vector3(Mathf.PingPong(Time.time, 2), Mathf.PingPong(Time.time, 2));
}
}
}
}
" ;
CSharpCodeProvider provider = new CSharpCodeProvider();
CompilerParameters parameters = new CompilerParameters(AppDomain.CurrentDomain.GetAssemblies()
.Where(a => !a.IsDynamic)
.Select(a => log(a.Location))
.ToArray());
parameters.GenerateInMemory = true;
parameters.GenerateExecutable = false;
CompilerResults results = provider.CompileAssemblyFromSource(parameters, code);
if (results.Errors.HasErrors)
{
StringBuilder sb = new StringBuilder();
foreach (CompilerError error in results.Errors)
{
sb.AppendLine(String.Format("Error ({0}): {1}", error.ErrorNumber, error.ErrorText));
}
throw new InvalidOperationException(sb.ToString());
}
var assembly = results.CompiledAssembly;
// Get systems
var systemTypes = assembly.GetTypes().Where(t =>
t.IsSubclassOf(typeof(ComponentSystemBase)) &&
!t.IsAbstract &&
!t.ContainsGenericParameters &&
t.GetCustomAttributes(typeof(DisableAutoCreationAttribute), true).Length == 0);
foreach (var system in systemTypes)
{
var world = World.Active;
world.CreateManager(system);
}
ScriptBehaviourUpdateOrder.UpdatePlayerLoop(World.Active);
}
static void DomainUnloadShutdown()
{
World.DisposeAllWorlds();
Shared.m_mapTipList.Dispose();
ScriptBehaviourUpdateOrder.UpdatePlayerLoop(World.Active);
}
/// <summary>
/// Asynchronously connects a worker to the SpatialOS runtime.
/// </summary>
/// <remarks>
/// Uses the global position of this GameObject as the worker origin.
/// Uses <see cref="ShouldUseLocator"/> to determine whether to connect via the Locator.
/// </remarks>
/// <param name="workerType">The type of the worker to connect as</param>
/// <param name="logger">The logger for the worker to use.</param>
/// <returns></returns>
public async Task Connect(string workerType, ILogDispatcher logger)
{
// Check that other workers have finished trying to connect before this one starts.
// This prevents races on the workers starting and races on when we start ticking systems.
await WorkerConnectionSemaphore.WaitAsync();
try
{
// A check is needed for the case that play mode is exited before the semaphore was released.
if (!Application.isPlaying)
{
return;
}
var origin = transform.position;
ConnectionDelegate connectionDelegate;
var chosenService = GetConnectionService();
var connectionParameters = GetConnectionParameters(workerType, chosenService);
switch (chosenService)
{
case ConnectionService.Receptionist:
connectionDelegate = async() =>
await Worker.CreateWorkerAsync(GetReceptionistConfig(workerType), connectionParameters, logger, origin)
.ConfigureAwait(false);
break;
case ConnectionService.Locator:
connectionDelegate = async() =>
await Worker
.CreateWorkerAsync(GetLocatorConfig(), connectionParameters, logger, origin)
.ConfigureAwait(false);
break;
case ConnectionService.AlphaLocator:
connectionDelegate = async() =>
await Worker.CreateWorkerAsync(GetAlphaLocatorConfig(workerType), connectionParameters, logger, origin)
.ConfigureAwait(false);
break;
default:
throw new Exception("No valid connection flow type selected");
}
Worker = await ConnectWithRetries(connectionDelegate, MaxConnectionAttempts, logger, workerType);
Worker.OnDisconnect += OnDisconnected;
HandleWorkerConnectionEstablished();
World.Active = World.Active ?? Worker.World;
ScriptBehaviourUpdateOrder.UpdatePlayerLoop(World.AllWorlds.ToArray());
}
catch (Exception e)
{
logger.HandleLog(LogType.Error, new LogEvent("Failed to create worker")
.WithException(e)
.WithField("WorkerType", workerType)
.WithField("Message", e.Message)
.WithField("Stacktrace", e.StackTrace));
#if UNITY_EDITOR
// Temporary warning to be replaced when we can reliably detect if a local runtime is running, or not.
logger.HandleLog(LogType.Warning,
new LogEvent(
"Is a local runtime running? If not, you can start one from 'SpatialOS -> Local launch' or by pressing Cmd/Ctrl-L")
.WithField("Reason", "A worker running in the Editor failed to connect"));
#endif
// A check is needed for the case that play mode is exited before the connection can complete.
if (Application.isPlaying)
{
HandleWorkerConnectionFailure(e.Message);
Dispose();
}
}
finally
{
WorkerConnectionSemaphore.Release();
}
foreach (var callback in workerConnectedCallbacks)
{
callback(Worker);
}
}
static void DestroyAll()
{
World.DisposeAllWorlds();
ScriptBehaviourUpdateOrder.UpdatePlayerLoop(System.Array.Empty <World>());
}
public void CleanUp()
{
_system.Clear();
World.DisposeAllWorlds();
ScriptBehaviourUpdateOrder.UpdatePlayerLoop(World.Active);
}
private static void OnDomainUnloadShutdown()
{
World.DisposeAllWorlds();
ScriptBehaviourUpdateOrder.UpdatePlayerLoop();
}
// Use this for initialization
void Start()
{
List <Vector3> vertices = new List <Vector3>(16);
List <Vector2> uvs = new List <Vector2>(16);
List <int> indices = new List <int>(96);
Sprite[] sprites = Resources.LoadAll <Sprite>("1300010303");
Mesh[] meshes = sprites.Select(_ =>
{
Mesh mesh;
_.FillSpriteMesh(out mesh);
return(mesh);
}).ToArray();
mat.mainTexture = sprites[0].texture;
///
SpriteMeshesData spriteMesh = new SpriteMeshesData()
{
Meshes = meshes
};
AnimationData AnimData = new AnimationData()
{
count = sprites.Length
};
AnimData.SetFPS(4);
///
TestECSWorld = new World("EntityCommandBuffer");
EntityManager entityManager = TestECSWorld.GetOrCreateManager <EntityManager>();
var archetype = entityManager.CreateArchetype(
typeof(SpriteMeshesData), typeof(AnimationData), typeof(AnimationSpriteData),
typeof(DestinationData), typeof(PositionData), typeof(DistanceFromCameraData));
TestECSWorld.CreateManager(typeof(AnimationSpriteSystem));
int shaderLv = SystemInfo.graphicsShaderLevel;
if (45 <= shaderLv)
{
(TestECSWorld.CreateManager(typeof(AnimationSpriteRenderSystem_45)) as AnimationSpriteRenderSystem_45).Initial(Camera.main, mat_45);
}
else if (35 <= shaderLv)
{
(TestECSWorld.CreateManager(typeof(AnimationSpriteRenderSystem_35)) as AnimationSpriteRenderSystem_35).Initial(Camera.main, mat_35);
}
else
{
(TestECSWorld.CreateManager(typeof(AnimationSpriteRenderSystem)) as AnimationSpriteRenderSystem).Initial(Camera.main, mat);
}
TestECSWorld.CreateManager(typeof(MovementSystem));
TestECSWorld.CreateManager(typeof(CheckArriveSystem));
(TestECSWorld.CreateManager(typeof(UpdateDistanceFromCameraSystem)) as UpdateDistanceFromCameraSystem).Initial(Camera.main.transform);
int count = 2048;
for (int Indx = 0; Indx < count; ++Indx)
{
var entity = entityManager.CreateEntity(archetype);
entityManager.SetComponentData(entity, new AnimationSpriteData()
{
spriteIndx = 3, time = 0f
});
entityManager.SetComponentData(entity, new PositionData()
{
Value = new Vector3(UnityEngine.Random.Range(-2f, 2f), 0f, UnityEngine.Random.Range(-2f, 2f))
});
entityManager.SetComponentData(entity, new DestinationData()
{
Value = new Vector3(UnityEngine.Random.Range(-2f, 2f), 0f, UnityEngine.Random.Range(-2f, 2f)), Velocity = 1f
});
entityManager.SetSharedComponentData(entity, spriteMesh);
entityManager.SetSharedComponentData(entity, AnimData);
}
ScriptBehaviourUpdateOrder.UpdatePlayerLoop(TestECSWorld);
}
public void InitConfiguration([NotNull] ITerrainSettings terrainSettings)
{
CleanUp();
SetUp(terrainSettings.Clone() as ITerrainSettings);
ScriptBehaviourUpdateOrder.UpdatePlayerLoop(_world);
}
protected sealed override void DefinePostRunSystems(IEcsSystemProxy system)
{
base.DefinePostRunSystems(system);
ScriptBehaviourUpdateOrder.UpdatePlayerLoop(World.Active);
}
// ----------------------------------------------------
#region // Public Methods
public ECSManager(LookSettings lookSettings, Collider2DSettings collider2DSettings, EnemySettings enemySettings, GameStatus gameStatus)
{
// 各種ScriptableObjectの参照を保持
this._lookSettings = lookSettings;
this._collider2DSettings = collider2DSettings;
this._enemySettings = enemySettings;
// ComponentSystem(JobComponentSystem)にパラメータを渡すために一部の設定データはポインタとして持つ
{
// 弾幕設定のポインタを取得
var barrageParamSize = UnsafeUtility.SizeOf <BarrageParam>();
this._barrageParamPtr = (BarrageParam *)UnsafeUtility.Malloc(barrageParamSize, UnsafeUtility.AlignOf <BarrageParam>(), Allocator.Persistent);
UnsafeUtility.MemClear(this._barrageParamPtr, barrageParamSize);
UnsafeUtility.CopyStructureToPtr <BarrageParam>(ref this._enemySettings.Barrage, this._barrageParamPtr);
// 敵情報をNativeArrayに格納
var enemyParamsSource = this._enemySettings.EnemyParams;
this._enemyParams = new NativeArray <EnemyParam>(enemyParamsSource.Length, Allocator.Persistent);
this._enemyParams.CopyFrom(enemyParamsSource);
}
#if SYNC_BARRAGE_PARAM
// シンボル有効時は毎フレーム構造体の値をポインタにコピーして常時反映されるようにする
this._debugEveryUpdate = Observable.EveryUpdate().Subscribe(_ =>
{
UnsafeUtility.CopyStructureToPtr <BarrageParam>(ref this._enemySettings.Barrage, this._barrageParamPtr);
this._enemyParams.CopyFrom(this._enemySettings.EnemyParams);
});
#endif
// World Settings
World.Active = new World(Constants.WorldName);
this._entityManager = World.Active.CreateManager <EntityManager>();
World.Active.CreateManager(typeof(TransformBarrierSystem));
World.Active.CreateManager(typeof(DestroyBarrier));
World.Active.CreateManager(typeof(DestroySystem));
// ※ポインタを直接object型にはキャスト出来ないので、遠回りでは有るが一つ構造体に挟んで渡す
var mainRoutineSystem = World.Active.CreateManager <MainRoutineSystem>(
new MainRoutineSystem.ConstructorParam {
BarrageParamPtr = this._barrageParamPtr, EnemyParams = this._enemyParams
});
World.Active.CreateManager(typeof(Transform2DSystem));
World.Active.CreateManager(typeof(Collider2DUpdate));
this._collision2DSystem = World.Active.CreateManager <Collision2DSystem>(gameStatus);
World.Active.CreateManager(typeof(RenderingSystemBootstrap));
#if ENABLE_DEBUG
World.Active.CreateManager(typeof(DebugUtility.DrawCollider2DSystem));
#endif
ScriptBehaviourUpdateOrder.UpdatePlayerLoop(World.Active);
// 敵の最大数
var maxEnemyNum = this._lookSettings.EnemyLooks.Length;
// MeshInstanceRendererの生成
// SpriteをMeshに変換する形で持たせる
this._enemyLooks = new MeshInstanceRenderer[maxEnemyNum];
for (int i = 0; i < this._enemyLooks.Length; i++)
{
this._enemyLooks[i] = SpriteUtility.CreateMeshInstanceRenderer(this._lookSettings.EnemyLooks[i]);
}
this._playerBulletLook = SpriteUtility.CreateMeshInstanceRenderer(this._lookSettings.PlayerBulletLook);
this._enemyBulletLook = SpriteUtility.CreateMeshInstanceRenderer(this._lookSettings.EnemyBulletLook);
// コリジョンとなる球体形状の半径と位置のオフセット
var radiusSettings = this._collider2DSettings.Radius;
var offsetSettings = this._collider2DSettings.Offset;
// Create Entity Prefabs
// ※Prefabベースでの生成を想定しているのでArchetypeは保存しない
{
// Player Bullet
var playerBulletArchetype = this._entityManager.CreateArchetype(
ComponentType.Create <BulletTag>(), ComponentType.Create <PlayerTag>(),
ComponentType.Create <BulletData>(),
// 衝突判定、破棄可能
ComponentType.Create <SphereCollider2D>(), ComponentType.Create <Destroyable>(),
// Transform
ComponentType.Create <Position2D>(),
// Built-in ComponentData
ComponentType.Create <Prefab>(), ComponentType.Create <LocalToWorld>(), ComponentType.Create <MeshInstanceRenderer>());
this._playerBulletPrefab = this._entityManager.CreateEntity(playerBulletArchetype);
this._entityManager.SetComponentData(
this._playerBulletPrefab,
new SphereCollider2D {
Radius = radiusSettings.PlayerBullet, OffsetPosition = offsetSettings.PlayerBullet
});
this._entityManager.SetSharedComponentData(this._playerBulletPrefab, this._playerBulletLook);
// Enemy Bullet
var enemyBulletArchetype = this._entityManager.CreateArchetype(
ComponentType.Create <BulletTag>(), ComponentType.Create <EnemyTag>(),
ComponentType.Create <BulletData>(),
// 衝突判定、破棄可能
ComponentType.Create <SphereCollider2D>(), ComponentType.Create <Destroyable>(),
// Transform
ComponentType.Create <Position2D>(),
// Built-in ComponentData
ComponentType.Create <Prefab>(), ComponentType.Create <LocalToWorld>(), ComponentType.Create <MeshInstanceRenderer>());
this._enemyBulletPrefab = this._entityManager.CreateEntity(enemyBulletArchetype);
this._entityManager.SetComponentData(
this._enemyBulletPrefab,
new SphereCollider2D {
Radius = radiusSettings.EnemyBullet, OffsetPosition = offsetSettings.EnemyBullet
});
this._entityManager.SetSharedComponentData(this._enemyBulletPrefab, this._enemyBulletLook);
}
this._enemyPrefabs = new Entity[maxEnemyNum];
{
// Enemy Prefab
var enemyArchetype = this._entityManager.CreateArchetype(
ComponentType.Create <EnemyTag>(),
ComponentType.Create <EnemyData>(),
// 衝突判定、破棄可能
ComponentType.Create <SphereCollider2D>(), ComponentType.Create <Destroyable>(),
// Transform
ComponentType.Create <Position2D>(),
// Built-in ComponentData
ComponentType.Create <Prefab>(), ComponentType.Create <LocalToWorld>(), ComponentType.Create <MeshInstanceRenderer>());
for (int i = 0; i < this._enemyLooks.Length; i++)
{
var prefab = this._entityManager.CreateEntity(enemyArchetype);
this._entityManager.SetComponentData(
prefab,
new SphereCollider2D {
Radius = radiusSettings.Enemy, OffsetPosition = offsetSettings.Enemy
});
this._entityManager.SetSharedComponentData(prefab, this._enemyLooks[i]);
this._enemyPrefabs[i] = prefab;
}
}
{
// Player prefab
var playerArchetype = this._entityManager.CreateArchetype(
ComponentType.Create <PlayerTag>(),
ComponentType.Create <PlayerStatus>(),
// 衝突判定、破棄可能
ComponentType.Create <SphereCollider2D>(), ComponentType.Create <Destroyable>(),
// Transform
ComponentType.Create <Position2D>(),
// Built-in ComponentData
ComponentType.Create <Prefab>());
this._playerPrefab = this._entityManager.CreateEntity(playerArchetype);
this._entityManager.SetComponentData(
this._playerPrefab,
new SphereCollider2D {
Radius = radiusSettings.Player, OffsetPosition = offsetSettings.Player
});
}
{
// Generate Events
// ※生成通知は生成したらその場で破棄するのでDestroyableは付けない
var playerBulletGenerateArchetype = this._entityManager.CreateArchetype(
ComponentType.Create <PlayerBulletGenerate>(),
ComponentType.Create <BulletData>(),
ComponentType.Create <Prefab>());
this._playerBulletGeneratePrefab = this._entityManager.CreateEntity(playerBulletGenerateArchetype);
var enemyGenerateArchetype = this._entityManager.CreateArchetype(
ComponentType.Create <EnemyGenerate>(),
ComponentType.Create <EnemyData>(),
ComponentType.Create <Prefab>());
this._enemyGeneratePrefab = this._entityManager.CreateEntity(enemyGenerateArchetype);
}
// ComponentSystem内でEntityの生成を行うSystemに対し、Prefabを渡す。
// HACK: 渡し方が若干力技感あるのでなんとかしたい..
mainRoutineSystem.SetPrefabEntities(new MainRoutineSystem.PrefabEntities
{
PlayerBulletPrefab = this._playerBulletPrefab,
EnemyBulletPrefab = this._enemyBulletPrefab,
EnemyPrefabs = this._enemyPrefabs,
});
}
public bool Initialize(string defaultWorldName)
{
var world = new World(defaultWorldName);
this.EntityManager = world.EntityManager;
var map = Map.NewMapRoomsAndCorridors(this.EntityManager);
var rooms = map.Rooms;
var roomCenters = new NativeArray <int2>(rooms.Length, Allocator.Temp, NativeArrayOptions.UninitializedMemory);
for (int i = 0; i < rooms.Length; i++)
{
var(x, y) = rooms[i].Center();
roomCenters[i] = int2(x, y);
}
this.CreatePlayer(roomCenters[0]);
var rng = RandomNumberGenerator.New();
for (int i = 1; i < roomCenters.Length; i++)
{
byte glyph;
string name;
var roll = rng.RollDice(1, 2);
switch (roll)
{
case 1:
glyph = (byte)'g';
name = "Goblin";
break;
default:
glyph = (byte)'o';
name = "Orc";
break;
}
var monster =
this.EntityManager.CreateEntity(
typeof(Position),
typeof(Renderable),
typeof(VisibleTilePosition),
typeof(ViewshedData),
typeof(Monster),
typeof(Name),
typeof(BlocksTile),
typeof(CombatStats));
var formattedName = $"{name} #{i}";
this.EntityManager.SetName(monster, formattedName);
this.EntityManager.SetComponentData(monster, new Position {
Value = roomCenters[i]
});
this.EntityManager.SetComponentData(
monster,
new Renderable {
Glyph = glyph, Foreground = Color.red, Background = Color.black
});
this.EntityManager.SetComponentData(monster, new ViewshedData {
Range = 8
});
this.EntityManager.SetComponentData(monster, new Name {
Value = formattedName
});
this.EntityManager.SetComponentData(monster, new CombatStats {
MaxHP = 16, HP = 16, Defense = 2, Power = 5
});
}
World.DefaultGameObjectInjectionWorld = world;
var systems = DefaultWorldInitialization.GetAllSystems(WorldSystemFilterFlags.Default);
DefaultWorldInitialization.AddSystemsToRootLevelSystemGroups(world, systems);
ScriptBehaviourUpdateOrder.UpdatePlayerLoop(world);
return(true);
}
/// <summary>
/// MonoBehaviour.Start
/// </summary>
protected override void Start()
{
base.Start();
_entityManager = World.Active.GetOrCreateManager <EntityManager>();
// Root Entityのアーキタイプ
var rootArchetype = _entityManager.CreateArchetype(
ComponentType.Create <Position>(),
ComponentType.Create <Rotation>(),
ComponentType.Create <EnableBillboard>());
// 親Entityのアーキタイプ
var parentArchetype = _entityManager.CreateArchetype(
ComponentType.Create <DokabenRotationData>(),
ComponentType.Create <Position>(),
ComponentType.Create <Rotation>());
// 子Entityのアーキタイプ
childArchetype = _entityManager.CreateArchetype(
ComponentType.Create <Position>(),
ComponentType.Create <Rotation>(),
ComponentType.Create <MeshInstanceRenderer>());
// カメラ情報参照用Entityの生成
var sharedCameraDataArchetype = _entityManager.CreateArchetype(
ComponentType.Create <SharedCameraData>(),
ComponentType.Create <CameraRotation>());
//// Attach
var attachmentArchetype = _entityManager.CreateArchetype(
ComponentType.Create <Attach>());
// ドカベンロゴの生成
base.CreateEntitiesFromRandomPosition((childEntity, randomPosition) =>
{
var rootEntity = _entityManager.CreateEntity(rootArchetype);
_entityManager.SetComponentData(rootEntity, new Position {
Value = randomPosition
});
_entityManager.SetComponentData(rootEntity, new Rotation {
Value = quaternion.identity
});
// 親Entityの生成
var parentEntity = _entityManager.CreateEntity(parentArchetype);
_entityManager.SetComponentData(parentEntity, new Position {
Value = new float3(0f, 0f, 0f)
});
_entityManager.SetComponentData(parentEntity, new Rotation {
Value = quaternion.identity
});
_entityManager.SetComponentData(parentEntity, new DokabenRotationData
{
CurrentAngle = Constants.ParentTest.Angle,
DeltaTimeCounter = 0f,
FrameCounter = 0,
CurrentRot = 0f,
});
// 子Entityの設定
_entityManager.SetComponentData(childEntity, new Position {
Value = this._childOffset
});
_entityManager.SetComponentData(childEntity, new Rotation {
Value = quaternion.identity
});
//// 親子関係の構築
var attach0 = _entityManager.CreateEntity(attachmentArchetype);
_entityManager.SetComponentData(attach0, new Attach
{
Parent = parentEntity,
Child = childEntity,
});
var attach1 = _entityManager.CreateEntity(attachmentArchetype);
_entityManager.SetComponentData(attach1, new Attach
{
Parent = rootEntity,
Child = parentEntity,
});
});
// カメラ情報参照用Entityの生成
var sharedCameraDataEntity = _entityManager.CreateEntity(sharedCameraDataArchetype);
_entityManager.SetComponentData(sharedCameraDataEntity, new SharedCameraData());
_entityManager.SetSharedComponentData(sharedCameraDataEntity, new CameraRotation {
Value = this._cameraTrs.rotation
});
this._sharedCameraDataEntity = sharedCameraDataEntity;
World.Active.CreateManager(typeof(EndFrameTransformSystem));
if (useJobSystem)
{
World.Active.CreateManager(typeof(MainContents.Billboard.ECS.ParentTestBillboardJobSystem));
}
else
{
World.Active.CreateManager(typeof(MainContents.Billboard.ECS.ParentTestBillboardSystem));
}
ScriptBehaviourUpdateOrder.UpdatePlayerLoop(World.Active);
}
//Update player loop for this world.
public void UpdatePlayerLoop()
{
ScriptBehaviourUpdateOrder.UpdatePlayerLoop(world);
}
public void Awake()
{
InitializeWorkerTypes();
// Taken from DefaultWorldInitalization.cs
SetupInjectionHooks(); // Register hybrid injection hooks
PlayerLoopManager.RegisterDomainUnload(DomainUnloadShutdown, 10000); // Clean up worlds and player loop
Application.targetFrameRate = TargetFrameRate;
if (Application.isEditor)
{
#if UNITY_EDITOR
var workerConfigurations =
AssetDatabase.LoadAssetAtPath <ScriptableWorkerConfiguration>(ScriptableWorkerConfiguration
.AssetPath);
foreach (var workerConfig in workerConfigurations.WorkerConfigurations)
{
if (!workerConfig.IsEnabled)
{
continue;
}
var worker = WorkerRegistry.CreateWorker(workerConfig.Type, $"{workerConfig.Type}-{Guid.NewGuid()}",
workerConfig.Origin);
Workers.Add(worker);
}
connectionConfig = new ReceptionistConfig();
connectionConfig.UseExternalIp = workerConfigurations.UseExternalIp;
#endif
}
else
{
var commandLineArguments = System.Environment.GetCommandLineArgs();
Debug.LogFormat("Command line {0}", string.Join(" ", commandLineArguments.ToArray()));
var commandLineArgs = CommandLineUtility.ParseCommandLineArgs(commandLineArguments);
var workerType =
CommandLineUtility.GetCommandLineValue(commandLineArgs, RuntimeConfigNames.WorkerType,
string.Empty);
var workerId =
CommandLineUtility.GetCommandLineValue(commandLineArgs, RuntimeConfigNames.WorkerId,
string.Empty);
// because the launcher does not pass in the worker type as an argument
var worker = workerType.Equals(string.Empty)
? WorkerRegistry.CreateWorker <UnityClient>(
workerId: null, // The worker id for the UnityClient will be auto-generated.
origin: new Vector3(0, 0, 0))
: WorkerRegistry.CreateWorker(workerType, workerId, new Vector3(0, 0, 0));
Workers.Add(worker);
connectionConfig = ConnectionUtility.CreateConnectionConfigFromCommandLine(commandLineArgs);
}
if (World.AllWorlds.Count <= 0)
{
throw new InvalidConfigurationException(
"No worlds have been created, due to invalid worker types being specified. Check the config in" +
"Improbable -> Configure editor workers.");
}
var worlds = World.AllWorlds.ToArray();
ScriptBehaviourUpdateOrder.UpdatePlayerLoop(worlds);
// Systems don't tick if World.Active isn't set
World.Active = worlds[0];
}
public void NullWorldsDontThrow()
{
Assert.DoesNotThrow(() => ScriptBehaviourUpdateOrder.UpdatePlayerLoop(null));
Assert.DoesNotThrow(() => ScriptBehaviourUpdateOrder.UpdatePlayerLoop(new World[] { World.Active, null }));
}
public static void Initialize(string worldName, bool editorWorld)
{
PlayerLoopManager.RegisterDomainUnload(DomainUnloadShutdown, 10000);
var world = new World(worldName);
World.Active = world;
var systems = GetAllSystems(WorldSystemFilterFlags.Default);
if (systems == null)
{
world.Dispose();
if (World.Active == world)
{
World.Active = null;
}
return;
}
// create presentation system and simulation system
InitializationSystemGroup initializationSystemGroup = world.GetOrCreateSystem <InitializationSystemGroup>();
SimulationSystemGroup simulationSystemGroup = world.GetOrCreateSystem <SimulationSystemGroup>();
PresentationSystemGroup presentationSystemGroup = world.GetOrCreateSystem <PresentationSystemGroup>();
// Add systems to their groups, based on the [UpdateInGroup] attribute.
foreach (var type in systems)
{
// Skip the built-in root-level systems
if (type == typeof(InitializationSystemGroup) ||
type == typeof(SimulationSystemGroup) ||
type == typeof(PresentationSystemGroup))
{
continue;
}
if (editorWorld)
{
if (Attribute.IsDefined(type, typeof(ExecuteInEditMode)))
{
Debug.LogError(
$"{type} is decorated with {typeof(ExecuteInEditMode)}. Support for this attribute will be deprecated. Please use {typeof(ExecuteAlways)} instead.");
}
if (!Attribute.IsDefined(type, typeof(ExecuteAlways)))
{
continue;
}
}
var groups = type.GetCustomAttributes(typeof(UpdateInGroupAttribute), true);
if (groups.Length == 0)
{
simulationSystemGroup.AddSystemToUpdateList(GetOrCreateManagerAndLogException(world, type) as ComponentSystemBase);
}
foreach (var g in groups)
{
var group = g as UpdateInGroupAttribute;
if (group == null)
{
continue;
}
if (!(typeof(ComponentSystemGroup)).IsAssignableFrom(group.GroupType))
{
Debug.LogError($"Invalid [UpdateInGroup] attribute for {type}: {group.GroupType} must be derived from ComponentSystemGroup.");
continue;
}
var groupMgr = GetOrCreateManagerAndLogException(world, group.GroupType);
if (groupMgr == null)
{
Debug.LogWarning(
$"Skipping creation of {type} due to errors creating the group {group.GroupType}. Fix these errors before continuing.");
continue;
}
var groupSys = groupMgr as ComponentSystemGroup;
if (groupSys != null)
{
groupSys.AddSystemToUpdateList(GetOrCreateManagerAndLogException(world, type) as ComponentSystemBase);
}
}
}
// Update player loop
initializationSystemGroup.SortSystemUpdateList();
simulationSystemGroup.SortSystemUpdateList();
presentationSystemGroup.SortSystemUpdateList();
ScriptBehaviourUpdateOrder.UpdatePlayerLoop(world);
}
/// <summary>
/// MonoBehaviour.Start
/// </summary>
protected override void Start()
{
base.Start();
var entityManager = World.Active.GetOrCreateManager <EntityManager>();
// 子Entityのアーキタイプ
archetype = entityManager.CreateArchetype(
ComponentType.Create <Position>(),
ComponentType.Create <Rotation>(),
ComponentType.Create <MeshInstanceRenderer>());
// 親Entityのアーキタイプ
var parentArchetype = entityManager.CreateArchetype(
ComponentType.Create <DokabenRotationData>(),
ComponentType.Create <Position>(),
ComponentType.Create <Rotation>());
// Root Entityのアーキタイプ
var childArchetype = entityManager.CreateArchetype(
ComponentType.Create <Position>(),
ComponentType.Create <Static>(),
ComponentType.Create <Rotation>());
//// Attachmentのアーキタイプ
var attachmentArchetype = entityManager.CreateArchetype(ComponentType.Create <Attach>());
// ドカベンロゴの生成
base.CreateEntitiesFromRandomPosition((childEntity, randomPosition) =>
{
// 子Entityの設定
entityManager.SetComponentData(childEntity, new Position {
Value = this._childOffset
});
entityManager.SetComponentData(childEntity, new Rotation {
Value = quaternion.identity
});
// ルートEntityの生成
var rootEntity = entityManager.CreateEntity(childArchetype);
entityManager.SetComponentData(rootEntity, new Position {
Value = randomPosition
});
entityManager.SetComponentData(rootEntity, new Rotation {
Value = quaternion.identity
});
// 親Entityの生成
var parentEntity = entityManager.CreateEntity(parentArchetype);
entityManager.SetComponentData(parentEntity, new Rotation {
Value = quaternion.identity
});
entityManager.SetComponentData(parentEntity, new DokabenRotationData {
CurrentAngle = Constants.ParentTest.Angle
});
//// 親子関係構築
var attach0 = entityManager.CreateEntity(attachmentArchetype);
entityManager.SetComponentData(attach0, new Attach
{
Parent = parentEntity,
Child = childEntity,
});
var attach1 = entityManager.CreateEntity(attachmentArchetype);
entityManager.SetComponentData(attach1, new Attach
{
Parent = rootEntity,
Child = parentEntity,
});
});
World.Active.CreateManager(typeof(EndFrameTransformSystem));
if (useBillboardSystem)
{
if (useJobSystem)
{
World.Active.CreateManager(typeof(ParentTestBillboardJobSystem));
}
else
{
World.Active.CreateManager(typeof(ParentTestBillboardSystem));
}
}
else
{
if (useJobSystem)
{
World.Active.CreateManager(typeof(ParentTestJobSystem));
}
else
{
World.Active.CreateManager(typeof(ParentTestSystem));
}
}
ScriptBehaviourUpdateOrder.UpdatePlayerLoop(World.Active);
}
// ----------------------------------------------------
#region // Unity Events
/// <summary>
/// MonoBehaviour.Start
/// </summary>
void Start()
{
// MaterialのIDを拾っておく
this._widthId = Shader.PropertyToID("_Width");
this._heightId = Shader.PropertyToID("_Height");
this._buffId = Shader.PropertyToID("_MaterialBuff");
// 最大セル数
this._maxCellsNum = this._resolution.Width * this._resolution.Height;
// マテリアル及びバッファの生成
this._materialInstance = new Material(this._material);
this._writeMaterialbuffs = new ComputeBuffer(this._maxCellsNum, Marshal.SizeOf(typeof(MaterialData)));
// ECS & JobSystem側で書き込むためのバッファを確保
this._writeMaterialData = new NativeArray <MaterialData>(this._maxCellsNum, Allocator.Persistent);
// ------------------------------
// ECS関連の初期化
// メモ:
// ・DefaultWorldは生成時の負荷が高い上に使わなくても生かしておく事で余計な副作用(GCなど)が出る可能性がある。
// こちらは「UNITY_DISABLE_AUTOMATIC_SYSTEM_BOOTSTRAP」を定義することで自動生成を止めることが可能。
// ・PureECSで実装するならDefaultWorldを消しても特に問題はないが、HybridECSで実装される方は以下のForumの内容に注意。
// https://forum.unity.com/threads/disabling-automaticworldbootstrap-but-keeping-hybrid-injection-hooks.529675/
// GOL専用のWorldを作成し必要なComponentSystemを登録していく
World.Active = new World("GOL World");
var entityManager = World.Active.CreateManager <EntityManager>();
// ComponentSystemはCreateManager経由でコンストラクタを呼び出すことが可能。(CreateManager → Activator.CreateInstanceと呼び出されている)
// その際に引数も渡すことが可能。
if (this._isConwayGameOfLife)
{
World.Active.CreateManager(typeof(ConwayGOLSystem), this._writeMaterialData, this._resolution);
}
else
{
World.Active.CreateManager(typeof(WaveGOLSystem), this._writeMaterialData, this._resolution);
}
ScriptBehaviourUpdateOrder.UpdatePlayerLoop(World.Active);
// セル(Entity)の生成
var cellArcheyype = this._isConwayGameOfLife
? entityManager.CreateArchetype(ComponentType.Create <ConwayCellData>())
: entityManager.CreateArchetype(ComponentType.Create <WaveCellData>());
for (int i = 0; i < this._maxCellsNum; ++i)
{
var x = i % this._resolution.Width;
var y = i / this._resolution.Width;
var entity = entityManager.CreateEntity(cellArcheyype);
if (this._isConwayGameOfLife)
{
// Conway's Game of Life
byte ret = (byte)Random.Range(0, 2);
entityManager.SetComponentData(entity, new ConwayCellData
{
NextState = ret,
State = ret,
Index = i,
});
}
else
{
// Wave Game of Life
int rand = Random.Range(0, 32);
float nextState = (((float)x / (float)this._resolution.Width) + ((float)y / (float)this._resolution.Height) * rand);
entityManager.SetComponentData(entity, new WaveCellData
{
NextState = nextState,
State = nextState,
LastState = 0f,
Index = i,
});
}
}
}
static void DestroyAll()
{
World.DisposeAllWorlds();
ScriptBehaviourUpdateOrder.UpdatePlayerLoop();
}
public bool Initialize(string defaultWorldName)
{
// Initialize the world normally
var systems = DefaultWorldInitialization.GetAllSystems(WorldSystemFilterFlags.Default);
var world = new World(defaultWorldName);
World.DefaultGameObjectInjectionWorld = world;
DefaultWorldInitialization.AddSystemsToRootLevelSystemGroups(world, systems);
ScriptBehaviourUpdateOrder.UpdatePlayerLoop(world);
// Moving SimulationSystemGroup to FixedUpdate is done in two parts.
// The PlayerLoopSystem of type SimulationSystemGroup has to be found,
// stored, and removed before adding it to the FixedUpdate PlayerLoopSystem.
PlayerLoopSystem playerLoop = PlayerLoop.GetCurrentPlayerLoop();
// simulationSystem has to be constructed or compiler will complain due to
// using non-assigned variables.
PlayerLoopSystem simulationSystem = new PlayerLoopSystem();
bool simSysFound = false;
// Find the location of the SimulationSystemGroup under the Update Loop
for (var i = 0; i < playerLoop.subSystemList.Length; ++i)
{
int subsystemListLength = playerLoop.subSystemList[i].subSystemList.Length;
// Find Update loop...
if (playerLoop.subSystemList[i].type != typeof(Update))
{
continue;
}
// Pop out SimulationSystemGroup and store it temporarily
var newSubsystemList = new PlayerLoopSystem[subsystemListLength - 1];
int k = 0;
for (var j = 0; j < subsystemListLength; ++j)
{
if (playerLoop.subSystemList[i].subSystemList[j].type == typeof(SimulationSystemGroup))
{
simulationSystem = playerLoop.subSystemList[i].subSystemList[j];
simSysFound = true;
}
else
{
newSubsystemList[k] = playerLoop.subSystemList[i].subSystemList[j];
k++;
}
}
playerLoop.subSystemList[i].subSystemList = newSubsystemList;
}
// This should never happen if SimulationSystemGroup was created like usual
// (or at least I think it might not happen :P )
if (!simSysFound)
{
throw new System.Exception("SimulationSystemGroup was not found!");
}
// Round 2: find FixedUpdate...
for (var i = 0; i < playerLoop.subSystemList.Length; ++i)
{
int subsystemListLength = playerLoop.subSystemList[i].subSystemList.Length;
// Found FixedUpdate
if (playerLoop.subSystemList[i].type != typeof(FixedUpdate))
{
continue;
}
// Allocate new space for stored SimulationSystemGroup
// PlayerLoopSystem, and place simulation group at index defined by
// temporary variable.
var newSubsystemList = new PlayerLoopSystem[subsystemListLength + 1];
int k = 0;
int indexToPlaceSimulationSystemGroupIn = subsystemListLength;
for (var j = 0; j < subsystemListLength + 1; ++j)
{
if (j == indexToPlaceSimulationSystemGroupIn)
{
newSubsystemList[j] = simulationSystem;
}
else
{
newSubsystemList[j] = playerLoop.subSystemList[i].subSystemList[k];
k++;
}
}
playerLoop.subSystemList[i].subSystemList = newSubsystemList;
}
// Set the beautiful, new player loop
PlayerLoop.SetPlayerLoop(playerLoop);
return(true);
}
public static void DomainUnloadShutdown()
{
World.DisposeAllWorlds();
ScriptBehaviourUpdateOrder.UpdatePlayerLoop(null);
}
public void RunWorld_2()
{
ScriptBehaviourUpdateOrder.UpdatePlayerLoop(TestECSWorlds[1]);
}
