Пример #1
0
        public void Playback()
        {
            DebugHelper.AssertThrow <ThreadAccessException>(ECSWorld.CheckThreadIsMainThread());
            if (!IsEmpty())
            {
                Jobs.CompleteAllJobs();
                int i = 0;
                while (i < modList.Length)
                {
                    IModification?mod = modList[i++];
                    if (mod == null)
                    {
                        break;
                    }

                    try {
                        mod.Execute(this);
                    }
                    catch (InvalidEntityException _) { }
                    catch (ComponentNotFoundException _) { }
                }

                pool.Return(modList);
                modList         = Array.Empty <IModification?>();
                entityTarget    = default;
                hasEntityTarget = false;
                nextIndex       = 0;
            }
        }
 public EntityManager(ECSWorld world, ComponentManager cm)
 {
     this.world       = world;
     componentManager = cm;
     freeEntities     = new Stack <Entity>();
     nextIdx          = 1;
 }
        public sealed override void Update(float deltaTime, ECSWorld world)
        {
            if (!initialized)
            {
                afterUpdateCommands = new ConcurrentEntityCommandBuffer(world);
                query       = GetQuery();
                filter      = GetComponentFilter();
                initialized = true;
            }
            BeforeUpdate(deltaTime, world);

            afterUpdateCommands.PlaybackAfterUpdate();

            var blocks = world.ComponentManager.GetBlocksNoSync(query, filter);
            var group  = Jobs.StartNewGroup(query);

            foreach (BlockAccessor block in blocks)
            {
                ComponentProcessJob processJob = new ComponentProcessJob()
                {
                    block     = block,
                    deltaTime = deltaTime,
                    instance  = this
                };
                processJob.Schedule(group);
            }
        }
        public Entity[] CreateEntities(int numEntities, EntityArchetype archetype = null)
        {
            DebugHelper.AssertThrow <ThreadAccessException>(ECSWorld.CheckThreadIsMainThread());
            world.SyncPoint();
            if (archetype == null)
            {
                archetype = EntityArchetype.Empty;
            }
            Entity[] arr = new Entity[numEntities];

            for (int i = 0; i < arr.Length; i++)
            {
                if (freeEntities.TryPop(out Entity result))
                {
                    result = new Entity(result.id, result.version + 1);
                    componentManager.AddEntity(result, archetype);
                    arr[i] = result;
                    new EntityCreatedEvent(result).Fire(world);
                }
                else
                {
                    Entity e = new Entity(NextIndex(), 0);
                    componentManager.AddEntity(e, archetype);
                    arr[i] = e;
                    new EntityCreatedEvent(e).Fire(world);
                }
            }

            return(arr);
        }
 public SystemManager(ECSWorld world)
 {
     this.world          = world;
     world.EarlyUpdate  += EarlyUpdate;
     world.Update       += OnUpdate;
     world.LateUpdate   += OnLateUpdate;
     world.FixedUpdate  += OnFixedUpdate;
     world.BeforeRender += OnBeforeRender;
     world.Render       += OnRender;
     world.AfterRender  += OnAfterRender;
 }
Пример #6
0
 public void Playback()
 {
     DebugHelper.AssertThrow <ThreadAccessException>(ECSWorld.CheckThreadIsMainThread());
     if (threadBuffersCache == null)
     {
         threadBuffersCache = threadBuffers.Values as List <EntityCommandBuffer>;
     }
     world.SyncPoint();
     foreach (EntityCommandBuffer buffer in threadBuffersCache)
     {
         buffer.Playback();
     }
 }
 public bool TryGetComponentData <T>(out Span <T> data) where T : unmanaged, IComponent
 {
     DebugHelper.AssertThrow <ThreadAccessException>(ECSWorld.CheckThreadIsMainThread());
     Jobs.CompleteAllJobs();
     if (block.archetype.Has <T>())
     {
         block.IncrementComponentVersion(TypeHelper <T> .hashCode);
         data = block.GetComponentData <T>().Slice(0, block.Size);
         return(true);
     }
     else
     {
         data = Span <T> .Empty;
         return(false);
     }
 }
Пример #8
0
        public bool IsEmpty()
        {
            DebugHelper.AssertThrow <ThreadAccessException>(ECSWorld.CheckThreadIsMainThread());
            Jobs.CompleteAllJobs();
            if (threadBuffersCache == null)
            {
                threadBuffersCache = threadBuffers.Values as List <EntityCommandBuffer>;
            }
            foreach (EntityCommandBuffer buffer in threadBuffersCache)
            {
                if (!buffer.IsEmpty())
                {
                    return(false);
                }
            }

            return(true);
        }
        public sealed override void Update(float deltaTime, ECSWorld world)
        {
            if (!initialized)
            {
                afterUpdateCommands = new EntityCommandBuffer(world);
                query       = GetQuery();
                filter      = GetComponentFilter();
                initialized = true;
            }
            BeforeUpdate(deltaTime, world);

            var blocks = world.ComponentManager.GetBlocks(query, filter);

            foreach (BlockAccessor block in blocks)
            {
                ProcessBlock(deltaTime, block);
            }
            afterUpdateCommands.Playback();
            AfterUpdate(deltaTime, world);
        }
Пример #10
0
 internal void OnAfterRender(float deltaTime, ECSWorld world)
 {
     foreach (var system in afterRenderSystems)
     {
         if (system.system.Enabled)
         {
             Profiler.StartMethod(system.systemType.Name);
             try
             {
                 system.system.Update(deltaTime, world);
             }
             catch (Exception ex)
             {
                 Console.WriteLine(ex);
             }
             finally
             {
                 Profiler.EndMethod();
             }
         }
     }
 }
Пример #11
0
 public Entity CreateEntity(EntityArchetype archetype = null)
 {
     DebugHelper.AssertThrow <ThreadAccessException>(ECSWorld.CheckThreadIsMainThread());
     world.SyncPoint();
     if (archetype == null)
     {
         archetype = EntityArchetype.Empty;
     }
     if (freeEntities.TryPop(out Entity result))
     {
         result = new Entity(result.id, result.version + 1);
         componentManager.AddEntity(result, archetype);
         new EntityCreatedEvent(result).Fire(world);
         return(result);
     }
     else
     {
         Entity e = new Entity(NextIndex(), 0);
         componentManager.AddEntity(e, archetype);
         new EntityCreatedEvent(e).Fire(world);
         return(e);
     }
 }
 public virtual void AfterUpdate(float deltaTime, ECSWorld world)
 {
 }
Пример #13
0
 public EntityCommandBuffer(ECSWorld world)
 {
     this.world = world;
 }
Пример #14
0
        internal static ECSWorld CreateMain()
        {
            ECSWorld world = new ECSWorld(true);

            return(world);
        }
Пример #15
0
 public static bool IsValid(this Entity entity, ECSWorld world)
 {
     return(world.ComponentManager.IsEntityValid(entity));
 }
Пример #16
0
 public static void AddComponent <T>(this Entity entity, ECSWorld world, in T component) where T : unmanaged, IComponent
Пример #17
0
 public static void Destroy(this Entity entity, ECSWorld world)
 {
     world.EntityManager.DestroyEntity(entity);
 }
 public virtual void BeforeUpdate(float deltaTime, ECSWorld world)
 {
 }
Пример #19
0
 public ConcurrentEntityCommandBuffer(ECSWorld world)
 {
     this.world = world;
 }
 public abstract void Update(float deltaTime, ECSWorld world);
 public virtual void OnDestroySystem(ECSWorld world)
 {
 }
 public abstract void ProcessBlock(float deltaTime, BlockAccessor block, ECSWorld world);
 public virtual void OnCreateSystem(ECSWorld world)
 {
 }