mirror of
https://github.com/DCFApixels/DragonECS.git
synced 2025-09-18 01:44:35 +08:00
1308 lines
46 KiB
C#
1308 lines
46 KiB
C#
#if DISABLE_DEBUG
|
||
#undef DEBUG
|
||
#endif
|
||
using DCFApixels.DragonECS.Core;
|
||
using DCFApixels.DragonECS.Internal;
|
||
using DCFApixels.DragonECS.PoolsCore;
|
||
using System;
|
||
using System.Collections.Generic;
|
||
using System.Diagnostics;
|
||
using System.Runtime.CompilerServices;
|
||
using System.Runtime.InteropServices;
|
||
using System.Runtime.Serialization;
|
||
#if ENABLE_IL2CPP
|
||
using Unity.IL2CPP.CompilerServices;
|
||
#endif
|
||
|
||
namespace DCFApixels.DragonECS
|
||
{
|
||
#if ENABLE_IL2CPP
|
||
[Il2CppSetOption(Option.NullChecks, false)]
|
||
[Il2CppSetOption(Option.ArrayBoundsChecks, false)]
|
||
#endif
|
||
[Serializable]
|
||
[DataContract]
|
||
public class EcsWorldConfig
|
||
{
|
||
public static readonly EcsWorldConfig Default = new EcsWorldConfig();
|
||
[DataMember] public int EntitiesCapacity;
|
||
[DataMember] public int GroupCapacity;
|
||
[DataMember] public int PoolsCapacity;
|
||
[DataMember] public int PoolComponentsCapacity;
|
||
[DataMember] public int PoolRecycledComponentsCapacity;
|
||
public EcsWorldConfig() : this(512) { }
|
||
public EcsWorldConfig(int entitiesCapacity = 512, int groupCapacity = 512, int poolsCapacity = 512, int poolComponentsCapacity = 512, int poolRecycledComponentsCapacity = 512 / 2)
|
||
{
|
||
EntitiesCapacity = entitiesCapacity;
|
||
GroupCapacity = groupCapacity;
|
||
PoolsCapacity = poolsCapacity;
|
||
PoolComponentsCapacity = poolComponentsCapacity;
|
||
PoolRecycledComponentsCapacity = poolRecycledComponentsCapacity;
|
||
}
|
||
}
|
||
|
||
#if ENABLE_IL2CPP
|
||
[Il2CppSetOption(Option.NullChecks, false)]
|
||
[Il2CppSetOption(Option.ArrayBoundsChecks, false)]
|
||
#endif
|
||
[MetaColor(MetaColor.DragonRose)]
|
||
[MetaGroup(EcsConsts.PACK_GROUP, EcsConsts.WORLDS_GROUP)]
|
||
[MetaDescription(EcsConsts.AUTHOR, "Container for entities and components.")]
|
||
[MetaID("DragonECS_AEF3557C92019C976FC48F90E95A9DA6")]
|
||
[DebuggerTypeProxy(typeof(DebuggerProxy))]
|
||
public partial class EcsWorld : IEntityStorage, IEcsMember, INamedMember
|
||
{
|
||
public readonly short ID;
|
||
private readonly IConfigContainer _configs;
|
||
private readonly string _name;
|
||
|
||
private bool _isDestroyed = false;
|
||
|
||
private IdDispenser _entityDispenser;
|
||
private int _entitiesCount = 0;
|
||
private int _entitiesCapacity = 0;
|
||
private EntitySlot[] _entities = Array.Empty<EntitySlot>();
|
||
|
||
private int[] _delEntBuffer = Array.Empty<int>();
|
||
private int _delEntBufferCount = 0;
|
||
private bool _isEnableAutoReleaseDelEntBuffer = true;
|
||
|
||
internal int _entityComponentMaskLength;
|
||
internal int _entityComponentMaskLengthBitShift;
|
||
internal int[] _entityComponentMasks = Array.Empty<int>();
|
||
private const int COMPONENT_MASK_CHUNK_SIZE = 32;
|
||
|
||
//"лениво" обновляется только для NewEntity
|
||
private long _deleteLeakedEntitesLastVersion = 0;
|
||
//обновляется в NewEntity и в DelEntity
|
||
private long _version = 0;
|
||
|
||
private StructList<IEcsWorldEventListener> _listeners = new StructList<IEcsWorldEventListener>(2);
|
||
private StructList<IEcsEntityEventListener> _entityListeners = new StructList<IEcsEntityEventListener>(2);
|
||
|
||
#region Properties
|
||
EcsWorld IEntityStorage.World
|
||
{
|
||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||
get { return this; }
|
||
}
|
||
public IConfigContainer Configs
|
||
{
|
||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||
get { return _configs; }
|
||
}
|
||
public string Name
|
||
{
|
||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||
get { return _name; }
|
||
}
|
||
public long Version
|
||
{
|
||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||
get { return _version; }
|
||
}
|
||
public bool IsDestroyed
|
||
{
|
||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||
get { return _isDestroyed; }
|
||
}
|
||
public int Count
|
||
{
|
||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||
get { return _entitiesCount; }
|
||
}
|
||
public int Capacity
|
||
{
|
||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||
get { return _entitiesCapacity; }
|
||
}
|
||
public int DelEntBufferCount
|
||
{
|
||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||
get { return _delEntBufferCount; }
|
||
}
|
||
public bool IsEnableReleaseDelEntBuffer
|
||
{
|
||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||
get { return _isEnableAutoReleaseDelEntBuffer; }
|
||
}
|
||
|
||
public EcsSpan Entities
|
||
{
|
||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||
get
|
||
{
|
||
ReleaseDelEntityBufferAll();
|
||
return GetCurrentEntities_Internal();
|
||
}
|
||
}
|
||
public int PoolsCount
|
||
{
|
||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||
get { return _poolsCount; }
|
||
}
|
||
public ReadOnlySpan<IEcsPool> AllPools
|
||
{
|
||
// new ReadOnlySpan<IEcsPoolImplementation>(pools, 0, _poolsCount);
|
||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||
get { return _pools; }
|
||
}
|
||
#endregion
|
||
|
||
#region Constructors/Destroy
|
||
public EcsWorld() : this(ConfigContainer.Empty, null, -1) { }
|
||
public EcsWorld(EcsWorldConfig config = null, short worldID = -1) : this(config == null ? ConfigContainer.Empty : new ConfigContainer().Set(config), null, worldID) { }
|
||
public EcsWorld(IConfigContainer configs, short worldID = -1) : this(configs, null, worldID) { }
|
||
public EcsWorld(EcsWorldConfig config = null, string name = null, short worldID = -1) : this(config == null ? ConfigContainer.Empty : new ConfigContainer().Set(config), name, worldID) { }
|
||
public EcsWorld(IConfigContainer configs, string name = null, short worldID = -1)
|
||
{
|
||
lock (_worldLock)
|
||
{
|
||
if (configs == null) { configs = ConfigContainer.Empty; }
|
||
if (name == null) { name = string.Empty; }
|
||
_name = name;
|
||
bool nullWorld = this is NullWorld;
|
||
if (nullWorld == false && worldID == NULL_WORLD_ID)
|
||
{
|
||
EcsDebug.PrintWarning($"The world identifier cannot be {NULL_WORLD_ID}");
|
||
}
|
||
_configs = configs;
|
||
EcsWorldConfig config = configs.GetWorldConfigOrDefault();
|
||
|
||
// тут сложно однозначно посчитать, так как нужно еще место под аспекты и запросы
|
||
int controllersCount = config.PoolsCapacity * 4;
|
||
_worldComponentPools = new StructList<WorldComponentPoolAbstract>(controllersCount);
|
||
if (controllersCount < _allWorldComponentPools.Capacity)
|
||
{
|
||
_allWorldComponentPools.Capacity = controllersCount;
|
||
}
|
||
|
||
if (worldID < 0 || (worldID == NULL_WORLD_ID && nullWorld == false))
|
||
{
|
||
worldID = (short)_worldIdDispenser.UseFree();
|
||
}
|
||
else
|
||
{
|
||
if (worldID != _worldIdDispenser.NullID)
|
||
{
|
||
_worldIdDispenser.Use(worldID);
|
||
}
|
||
if (_worlds[worldID] != null)
|
||
{
|
||
_worldIdDispenser.Release(worldID);
|
||
Throw.Exception("The world with the specified ID has already been created\r\n");
|
||
}
|
||
}
|
||
ID = worldID;
|
||
_worlds[worldID] = this;
|
||
|
||
_poolsMediator = new PoolsMediator(this);
|
||
|
||
int poolsCapacity = ArrayUtility.NextPow2(config.PoolsCapacity);
|
||
_pools = new IEcsPoolImplementation[poolsCapacity];
|
||
_poolSlots = new PoolSlot[poolsCapacity];
|
||
ArrayUtility.Fill(_pools, _nullPool);
|
||
|
||
int entitiesCapacity = ArrayUtility.NextPow2(config.EntitiesCapacity);
|
||
_entityDispenser = new IdDispenser(entitiesCapacity, 0, OnEntityDispenserResized);
|
||
|
||
_executorCoures = new Dictionary<(Type, object), IQueryExecutorImplementation>(config.PoolComponentsCapacity);
|
||
|
||
GetComponentTypeID<NullComponent>();
|
||
}
|
||
}
|
||
public void Destroy()
|
||
{
|
||
lock (_worldLock)
|
||
{
|
||
if (_isDestroyed)
|
||
{
|
||
EcsDebug.PrintWarning("The world is already destroyed");
|
||
return;
|
||
}
|
||
if (ID == NULL_WORLD_ID)
|
||
{
|
||
#if DEBUG
|
||
Throw.World_WorldCantBeDestroyed();
|
||
#endif
|
||
return;
|
||
}
|
||
_listeners.InvokeOnWorldDestroy();
|
||
_entityDispenser = null;
|
||
_pools = null;
|
||
_nullPool = null;
|
||
_worlds[ID] = null;
|
||
ReleaseData(ID);
|
||
_worldIdDispenser.Release(ID);
|
||
_isDestroyed = true;
|
||
_poolTypeCode_2_CmpTypeIDs = null;
|
||
_cmpTypeCode_2_CmpTypeIDs = null;
|
||
|
||
foreach (var item in _executorCoures)
|
||
{
|
||
item.Value.Destroy();
|
||
}
|
||
//_entities - не обнуляется для работы entlong.IsAlive
|
||
}
|
||
}
|
||
//public void Clear() { }
|
||
#endregion
|
||
|
||
#region Getters
|
||
#if UNITY_2020_3_OR_NEWER
|
||
[UnityEngine.Scripting.Preserve]
|
||
#endif
|
||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||
public TAspect GetAspect<TAspect>() where TAspect : new()
|
||
{
|
||
return Get<AspectCache<TAspect>>().Instance;
|
||
}
|
||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||
public TAspect GetAspect<TAspect>(out EcsMask mask) where TAspect : new()
|
||
{
|
||
var result = Get<AspectCache<TAspect>>();
|
||
mask = result.Mask;
|
||
return result.Instance;
|
||
}
|
||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||
public void GetQueryCache<TExecutor, TAspect>(out TExecutor executor, out TAspect aspect)
|
||
where TExecutor : MaskQueryExecutor, new()
|
||
where TAspect : new()
|
||
{
|
||
ref var cmp = ref Get<WhereQueryCache<TExecutor, TAspect>>();
|
||
executor = cmp.Executor;
|
||
aspect = cmp.Aspcet;
|
||
}
|
||
|
||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||
public ref T Get<T>() where T : struct
|
||
{
|
||
return ref WorldComponentPool<T>.GetForWorld(ID);
|
||
}
|
||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||
public bool Has<T>() where T : struct
|
||
{
|
||
return WorldComponentPool<T>.Has(ID);
|
||
}
|
||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||
public ref T GetUnchecked<T>() where T : struct
|
||
{
|
||
return ref WorldComponentPool<T>.GetForWorldUnchecked(ID);
|
||
}
|
||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||
public static ref T Get<T>(short worldID) where T : struct
|
||
{
|
||
return ref WorldComponentPool<T>.GetForWorld(worldID);
|
||
}
|
||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||
public static bool Has<T>(short worldID) where T : struct
|
||
{
|
||
return WorldComponentPool<T>.Has(worldID);
|
||
}
|
||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||
public static ref T GetUnchecked<T>(short worldID) where T : struct
|
||
{
|
||
return ref WorldComponentPool<T>.GetForWorldUnchecked(worldID);
|
||
}
|
||
#endregion
|
||
|
||
#region Entity
|
||
|
||
#region New/Del
|
||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||
public entlong NewEntityLong()
|
||
{
|
||
int entityID = NewEntity();
|
||
return GetEntityLong(entityID);
|
||
}
|
||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||
public entlong NewEntityLong(int entityID)
|
||
{
|
||
NewEntity(entityID);
|
||
return GetEntityLong(entityID);
|
||
}
|
||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||
public int NewEntity()
|
||
{
|
||
int entityID = _entityDispenser.UseFree();
|
||
CreateConcreteEntity(entityID);
|
||
return entityID;
|
||
}
|
||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||
public int NewEntity(int entityID)
|
||
{
|
||
#if DEBUG
|
||
if (IsUsed(entityID)) { Throw.World_EntityIsAlreadyСontained(entityID); }
|
||
#elif DRAGONECS_STABILITY_MODE
|
||
if (IsUsed(entityID)) { return 0; }
|
||
#endif
|
||
_entityDispenser.Use(entityID);
|
||
CreateConcreteEntity(entityID);
|
||
return entityID;
|
||
}
|
||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||
private void CreateConcreteEntity(int entityID)
|
||
{
|
||
UpVersionLeaked();
|
||
_entitiesCount++;
|
||
ref var slot = ref _entities[entityID];
|
||
slot.isUsed = true;
|
||
if (slot.gen >= GEN_STATUS_SEPARATOR)
|
||
{
|
||
slot.gen |= GEN_SLEEP_MASK;
|
||
}
|
||
_entityListeners.InvokeOnNewEntity(entityID);
|
||
}
|
||
|
||
|
||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||
public bool TryDelEntity(entlong entity)
|
||
{
|
||
if (entity.TryGetID(out int entityID))
|
||
{
|
||
TryDelEntity(entityID);
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||
public bool TryDelEntity(int entityID)
|
||
{
|
||
if (IsUsed(entityID))
|
||
{
|
||
DelEntity(entityID);
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||
public void DelEntity(entlong entity)
|
||
{
|
||
DelEntity(entity.ID);
|
||
}
|
||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||
public void DelEntity(int entityID)
|
||
{
|
||
#if DEBUG
|
||
if (IsUsed(entityID) == false) { Throw.World_EntityIsAlreadyСontained(entityID); }
|
||
#elif DRAGONECS_STABILITY_MODE
|
||
if (IsUsed(entityID) == false) { return; }
|
||
#endif
|
||
UpVersion();
|
||
_delEntBuffer[_delEntBufferCount++] = entityID;
|
||
_entities[entityID].isUsed = false;
|
||
_entitiesCount--;
|
||
_entityListeners.InvokeOnDelEntity(entityID);
|
||
}
|
||
#endregion
|
||
|
||
#region Other
|
||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||
public EcsSpan ToSpan()
|
||
{
|
||
if (_isEnableAutoReleaseDelEntBuffer)
|
||
{
|
||
ReleaseDelEntityBufferAll();
|
||
}
|
||
return _entityDispenser.UsedToEcsSpan(ID);
|
||
}
|
||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||
public unsafe entlong GetEntityLong(int entityID)
|
||
{
|
||
long x = (long)ID << 48 | (long)GetGen(entityID) << 32 | (long)entityID;
|
||
return *(entlong*)&x;
|
||
}
|
||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||
public void InitEntitySlot(int entityID, short gen)
|
||
{
|
||
#if DEBUG
|
||
if (Count > 0) { Throw.World_MethodCalledAfterEntityCreation(nameof(InitEntitySlot)); }
|
||
#elif DRAGONECS_STABILITY_MODE
|
||
if (Count > 0) { return; }
|
||
#endif
|
||
_entityDispenser.Upsize(entityID);
|
||
_entities[entityID].gen = gen;
|
||
}
|
||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||
public EntitySlotInfo GetEntitySlotInfoDebug(int entityID)
|
||
{
|
||
return new EntitySlotInfo(entityID, _entities[entityID].gen, ID);
|
||
}
|
||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||
public bool IsAlive(int entityID, short gen)
|
||
{
|
||
ref var slot = ref _entities[entityID];
|
||
return slot.gen == gen && slot.isUsed;
|
||
}
|
||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||
public bool IsAlive(entlong entity)
|
||
{
|
||
#if DEBUG
|
||
if (entity.GetWorldIDUnchecked() != ID) { Throw.World_MaskDoesntBelongWorld(); }
|
||
#elif DRAGONECS_STABILITY_MODE
|
||
if (entity.GetWorldIDUnchecked() != ID) { return false; }
|
||
#endif
|
||
ref var slot = ref _entities[entity.GetIDUnchecked()];
|
||
return slot.gen == entity.GetIDUnchecked() && slot.isUsed;
|
||
}
|
||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||
public bool IsUsed(int entityID)
|
||
{
|
||
return _entities[entityID].isUsed;
|
||
}
|
||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||
public short GetGen(int entityID)
|
||
{
|
||
unchecked
|
||
{
|
||
ref var slotGen = ref _entities[entityID].gen;
|
||
if (slotGen < GEN_STATUS_SEPARATOR)
|
||
{ //если gen меньше 0 значит он спящий, спящие нужно инкремировать перед выдачей
|
||
slotGen++;
|
||
slotGen &= GEN_WAKEUP_MASK;
|
||
}
|
||
return slotGen;
|
||
}
|
||
}
|
||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||
public short GetComponentsCount(int entityID)
|
||
{
|
||
return _entities[entityID].componentsCount;
|
||
}
|
||
|
||
public bool IsMatchesMask(IComponentMask mask, int entityID)
|
||
{
|
||
return IsMatchesMask(mask.ToMask(this), entityID);
|
||
}
|
||
public bool IsMatchesMask(EcsMask mask, int entityID)
|
||
{
|
||
#if DEBUG
|
||
if (mask.WorldID != ID) { Throw.World_MaskDoesntBelongWorld(); }
|
||
#elif DRAGONECS_STABILITY_MODE
|
||
if (mask.WorldID != ID) { return false; }
|
||
#endif
|
||
|
||
|
||
#if DEBUG && DRAGONECS_DEEP_DEBUG
|
||
bool IsMatchesMaskDeepDebug(EcsMask mask_, int entityID_)
|
||
{
|
||
for (int i = 0, iMax = mask_._incs.Length; i < iMax; i++)
|
||
{
|
||
if (!_pools[mask_._incs[i]].Has(entityID_))
|
||
{
|
||
return false;
|
||
}
|
||
}
|
||
for (int i = 0, iMax = mask_._excs.Length; i < iMax; i++)
|
||
{
|
||
if (_pools[mask_._excs[i]].Has(entityID_))
|
||
{
|
||
return false;
|
||
}
|
||
}
|
||
return true;
|
||
}
|
||
bool deepDebug = IsMatchesMaskDeepDebug(mask, entityID);
|
||
#endif
|
||
|
||
var incChuncks = mask._incChunckMasks;
|
||
var excChuncks = mask._excChunckMasks;
|
||
var componentMaskStartIndex = entityID << _entityComponentMaskLengthBitShift;
|
||
|
||
for (int i = 0; i < incChuncks.Length; i++)
|
||
{
|
||
var bit = incChuncks[i];
|
||
if ((_entityComponentMasks[componentMaskStartIndex + bit.chunkIndex] & bit.mask) != bit.mask)
|
||
{
|
||
#if DEBUG && DRAGONECS_DEEP_DEBUG
|
||
if (false != deepDebug) { Throw.DeepDebugException(); }
|
||
#endif
|
||
return false;
|
||
}
|
||
}
|
||
for (int i = 0; i < excChuncks.Length; i++)
|
||
{
|
||
var bit = excChuncks[i];
|
||
if ((_entityComponentMasks[componentMaskStartIndex + bit.chunkIndex] & bit.mask) != 0)
|
||
{
|
||
#if DEBUG && DRAGONECS_DEEP_DEBUG
|
||
if (false != deepDebug) { Throw.DeepDebugException(); }
|
||
#endif
|
||
return false;
|
||
}
|
||
}
|
||
|
||
#if DEBUG && DRAGONECS_DEEP_DEBUG
|
||
if (true != deepDebug) { Throw.DeepDebugException(); }
|
||
#endif
|
||
return true;
|
||
}
|
||
#endregion
|
||
|
||
#region Leaked
|
||
public bool DeleteLeakedEntites()
|
||
{
|
||
if (_deleteLeakedEntitesLastVersion == _version)
|
||
{
|
||
return false;
|
||
}
|
||
int delCount = 0;
|
||
foreach (var e in Entities)
|
||
{
|
||
ref var ent = ref _entities[e];
|
||
if (ent.componentsCount <= 0 && ent.isUsed)
|
||
{
|
||
DelEntity(e);
|
||
delCount++;
|
||
}
|
||
}
|
||
if (delCount > 0)
|
||
{
|
||
EcsDebug.PrintWarning($"Detected and deleted {delCount} leaking entities.");
|
||
}
|
||
_deleteLeakedEntitesLastVersion = _version;
|
||
return delCount > 0;
|
||
}
|
||
public int CountLeakedEntitesDebug()
|
||
{
|
||
if (_deleteLeakedEntitesLastVersion == _version)
|
||
{
|
||
return 0;
|
||
}
|
||
int delCount = 0;
|
||
foreach (var e in Entities)
|
||
{
|
||
ref var ent = ref _entities[e];
|
||
if (ent.componentsCount <= 0 && ent.isUsed)
|
||
{
|
||
delCount++;
|
||
}
|
||
}
|
||
return delCount;
|
||
}
|
||
#endregion
|
||
|
||
//TODO протестить Copy Clone Move Remove
|
||
|
||
#region CopyEntity
|
||
public unsafe void CopyEntity(int fromEntityID, int toEntityID)
|
||
{
|
||
const int BUFFER_THRESHOLD = 100;
|
||
|
||
int count = GetComponentsCount(fromEntityID);
|
||
|
||
int* poolIdsPtr;
|
||
if (count < BUFFER_THRESHOLD)
|
||
{
|
||
int* ptr = stackalloc int[count];
|
||
poolIdsPtr = ptr;
|
||
}
|
||
else
|
||
{
|
||
poolIdsPtr = UnmanagedArrayUtility.New<int>(count);
|
||
}
|
||
|
||
UnsafeArray<int> ua = UnsafeArray<int>.Manual(poolIdsPtr, count);
|
||
|
||
GetComponentTypeIDsFor_Internal(fromEntityID, poolIdsPtr, count);
|
||
for (int i = 0; i < count; i++)
|
||
{
|
||
_pools[poolIdsPtr[i]].Copy(fromEntityID, toEntityID);
|
||
}
|
||
|
||
if (count >= BUFFER_THRESHOLD)
|
||
{
|
||
UnmanagedArrayUtility.Free(poolIdsPtr);
|
||
}
|
||
|
||
|
||
//foreach (var pool in _pools)
|
||
//{
|
||
// if (pool.Has(fromEntityID))
|
||
// {
|
||
// pool.Copy(fromEntityID, toEntityID);
|
||
// }
|
||
//}
|
||
}
|
||
public void CopyEntity(int fromEntityID, int toEntityID, ReadOnlySpan<int> componentTypeIDs)
|
||
{
|
||
foreach (var poolID in componentTypeIDs)
|
||
{
|
||
var pool = _pools[poolID];
|
||
if (pool.Has(fromEntityID))
|
||
{
|
||
pool.Copy(fromEntityID, toEntityID);
|
||
}
|
||
}
|
||
}
|
||
public unsafe void CopyEntity(int fromEntityID, EcsWorld toWorld, int toEntityID)
|
||
{
|
||
const int BUFFER_THRESHOLD = 100;
|
||
|
||
int count = GetComponentsCount(fromEntityID);
|
||
|
||
int* poolIdsPtr;
|
||
if (count < BUFFER_THRESHOLD)
|
||
{
|
||
int* ptr = stackalloc int[count];
|
||
poolIdsPtr = ptr;
|
||
}
|
||
else
|
||
{
|
||
poolIdsPtr = UnmanagedArrayUtility.New<int>(count);
|
||
}
|
||
|
||
GetComponentTypeIDsFor_Internal(fromEntityID, poolIdsPtr, count);
|
||
for (int i = 0; i < count; i++)
|
||
{
|
||
_pools[poolIdsPtr[i]].Copy(fromEntityID, toWorld, toEntityID);
|
||
}
|
||
|
||
if (count >= BUFFER_THRESHOLD)
|
||
{
|
||
UnmanagedArrayUtility.Free(poolIdsPtr);
|
||
}
|
||
|
||
//foreach (var pool in _pools)
|
||
//{
|
||
// if (pool.Has(fromEntityID))
|
||
// {
|
||
// pool.Copy(fromEntityID, toWorld, toEntityID);
|
||
// }
|
||
//}
|
||
}
|
||
public void CopyEntity(int fromEntityID, EcsWorld toWorld, int toEntityID, ReadOnlySpan<int> componentTypeIDs)
|
||
{
|
||
foreach (var poolID in componentTypeIDs)
|
||
{
|
||
var pool = _pools[poolID];
|
||
if (pool.Has(fromEntityID))
|
||
{
|
||
pool.Copy(fromEntityID, toWorld, toEntityID);
|
||
}
|
||
}
|
||
}
|
||
#endregion
|
||
|
||
#region CloneEntity
|
||
public int CloneEntity(int entityID)
|
||
{
|
||
int newEntity = NewEntity();
|
||
CopyEntity(entityID, newEntity);
|
||
return newEntity;
|
||
}
|
||
public int CloneEntity(int entityID, ReadOnlySpan<int> componentTypeIDs)
|
||
{
|
||
int newEntity = NewEntity();
|
||
CopyEntity(entityID, newEntity, componentTypeIDs);
|
||
return newEntity;
|
||
}
|
||
public int CloneEntity(int entityID, EcsWorld toWorld)
|
||
{
|
||
int newEntity = NewEntity();
|
||
CopyEntity(entityID, toWorld, newEntity);
|
||
return newEntity;
|
||
}
|
||
public int CloneEntity(int entityID, EcsWorld toWorld, ReadOnlySpan<int> componentTypeIDs)
|
||
{
|
||
int newEntity = NewEntity();
|
||
CopyEntity(entityID, toWorld, newEntity, componentTypeIDs);
|
||
return newEntity;
|
||
}
|
||
|
||
public void CloneEntity(int fromEntityID, int toEntityID)
|
||
{
|
||
CopyEntity(fromEntityID, toEntityID);
|
||
foreach (var pool in _pools)
|
||
{
|
||
if (!pool.Has(fromEntityID) && pool.Has(toEntityID))
|
||
{
|
||
pool.Del(toEntityID);
|
||
}
|
||
}
|
||
}
|
||
//public void CloneEntity(int fromEntityID, EcsWorld toWorld, int toEntityID)
|
||
#endregion
|
||
|
||
#region MoveComponents
|
||
public void MoveComponents(int fromEntityID, int toEntityID, ReadOnlySpan<int> componentTypeIDs)
|
||
{
|
||
foreach (var poolID in componentTypeIDs)
|
||
{
|
||
var pool = _pools[poolID];
|
||
if (pool.Has(fromEntityID))
|
||
{
|
||
pool.Copy(fromEntityID, toEntityID);
|
||
pool.Del(fromEntityID);
|
||
}
|
||
}
|
||
}
|
||
#endregion
|
||
|
||
#region RemoveComponents
|
||
public void RemoveComponents(int fromEntityID, ReadOnlySpan<int> componentTypeIDs)
|
||
{
|
||
foreach (var poolID in componentTypeIDs)
|
||
{
|
||
var pool = _pools[poolID];
|
||
if (pool.Has(fromEntityID))
|
||
{
|
||
pool.Del(fromEntityID);
|
||
}
|
||
}
|
||
}
|
||
#endregion
|
||
|
||
#endregion
|
||
|
||
#region DelEntBuffer
|
||
public IsEnableAutoReleaseDelEntBufferScope DisableAutoReleaseDelEntBuffer()
|
||
{
|
||
return new IsEnableAutoReleaseDelEntBufferScope(this, false);
|
||
}
|
||
public IsEnableAutoReleaseDelEntBufferScope EnableAutoReleaseDelEntBuffer()
|
||
{
|
||
return new IsEnableAutoReleaseDelEntBufferScope(this, true);
|
||
}
|
||
private void SetEnableAutoReleaseDelEntBuffer(bool value)
|
||
{
|
||
_isEnableAutoReleaseDelEntBuffer = value;
|
||
}
|
||
public readonly struct IsEnableAutoReleaseDelEntBufferScope : IDisposable
|
||
{
|
||
private readonly EcsWorld _source;
|
||
private readonly bool _lastValue;
|
||
public IsEnableAutoReleaseDelEntBufferScope(EcsWorld source, bool value)
|
||
{
|
||
_lastValue = source._isEnableAutoReleaseDelEntBuffer;
|
||
source.SetEnableAutoReleaseDelEntBuffer(value);
|
||
_source = source;
|
||
}
|
||
public void End()
|
||
{
|
||
_source.SetEnableAutoReleaseDelEntBuffer(_lastValue);
|
||
}
|
||
void IDisposable.Dispose()
|
||
{
|
||
End();
|
||
}
|
||
}
|
||
public void ReleaseDelEntityBufferAll()
|
||
{
|
||
ReleaseDelEntityBuffer(_delEntBufferCount);
|
||
}
|
||
public unsafe void ReleaseDelEntityBuffer(int count)
|
||
{
|
||
if (_delEntBufferCount <= 0) { return; }
|
||
unchecked { _version++; }
|
||
|
||
count = Math.Max(0, Math.Min(count, _delEntBufferCount));
|
||
_delEntBufferCount -= count;
|
||
int slisedCount = count;
|
||
|
||
for (int i = 0; i < slisedCount; i++)
|
||
{
|
||
int e = _delEntBuffer[i];
|
||
if (_entities[e].componentsCount <= 0)
|
||
{
|
||
int tmp = _delEntBuffer[i];
|
||
_delEntBuffer[i] = _delEntBuffer[--slisedCount];
|
||
_delEntBuffer[slisedCount] = tmp;
|
||
i--;
|
||
}
|
||
}
|
||
|
||
//если фулл очистка то _delEntBufferCount будет 0
|
||
|
||
ReadOnlySpan<int> fullBuffer = new ReadOnlySpan<int>(_delEntBuffer, _delEntBufferCount, count);
|
||
if (slisedCount > 0)
|
||
{
|
||
ReadOnlySpan<int> bufferSlised = new ReadOnlySpan<int>(_delEntBuffer, _delEntBufferCount, slisedCount);
|
||
for (int i = 0; i < _poolsCount; i++)
|
||
{
|
||
_pools[i].OnReleaseDelEntityBuffer(bufferSlised);
|
||
}
|
||
}
|
||
for (int i = 0; i < _groups.Count; i++)
|
||
{
|
||
if (_groups[i].TryGetTarget(out EcsGroup group))
|
||
{
|
||
if (group.IsReleased)
|
||
{
|
||
group.OnReleaseDelEntityBuffer_Internal(fullBuffer);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
RemoveGroupAt(i--);
|
||
}
|
||
}
|
||
|
||
_listeners.InvokeOnReleaseDelEntityBuffer(fullBuffer);
|
||
for (int i = 0; i < fullBuffer.Length; i++)
|
||
{
|
||
int e = fullBuffer[i];
|
||
_entityDispenser.Release(e);
|
||
_entities[e].gen |= GEN_SLEEP_MASK;
|
||
}
|
||
Densify();
|
||
}
|
||
private void Densify() //уплотнение свободных айдишников
|
||
{
|
||
_entityDispenser.Sort();
|
||
}
|
||
#endregion
|
||
|
||
#region Upsize
|
||
public void Upsize(int minSize)
|
||
{
|
||
_entityDispenser.Upsize(minSize);
|
||
}
|
||
[MethodImpl(MethodImplOptions.NoInlining)]
|
||
private int CalcEntityComponentMaskLength()
|
||
{
|
||
int result = _pools.Length / COMPONENT_MASK_CHUNK_SIZE;
|
||
return (result < 2 ? 2 : result);
|
||
}
|
||
private void SetEntityComponentMaskLength(int value)
|
||
{
|
||
_entityComponentMaskLength = value;
|
||
_entityComponentMaskLengthBitShift = BitsUtility.GetHighBitNumber(value);
|
||
}
|
||
[MethodImpl(MethodImplOptions.NoInlining)]
|
||
private void OnEntityDispenserResized(int newSize)
|
||
{
|
||
SetEntityComponentMaskLength(CalcEntityComponentMaskLength()); //_pools.Length / COMPONENT_MASK_CHUNK_SIZE + 1;
|
||
Array.Resize(ref _entities, newSize);
|
||
Array.Resize(ref _delEntBuffer, newSize);
|
||
Array.Resize(ref _entityComponentMasks, newSize * _entityComponentMaskLength);
|
||
|
||
ArrayUtility.Fill(_entities, EntitySlot.Empty, _entitiesCapacity);
|
||
|
||
_entitiesCapacity = newSize;
|
||
|
||
for (int i = 0; i < _groups.Count; i++)
|
||
{
|
||
if (_groups[i].TryGetTarget(out EcsGroup group))
|
||
{
|
||
group.OnWorldResize_Internal(newSize);
|
||
}
|
||
else
|
||
{
|
||
RemoveGroupAt(i--);
|
||
}
|
||
}
|
||
foreach (var item in _pools)
|
||
{
|
||
item.OnWorldResize(newSize);
|
||
}
|
||
_listeners.InvokeOnWorldResize(newSize);
|
||
}
|
||
#endregion
|
||
|
||
#region Listeners
|
||
public void AddListener(IEcsWorldEventListener worldEventListener)
|
||
{
|
||
_listeners.Add(worldEventListener);
|
||
}
|
||
public void RemoveListener(IEcsWorldEventListener worldEventListener)
|
||
{
|
||
_listeners.Remove(worldEventListener);
|
||
}
|
||
public void AddListener(IEcsEntityEventListener entityEventListener)
|
||
{
|
||
_entityListeners.Add(entityEventListener);
|
||
}
|
||
public void RemoveListener(IEcsEntityEventListener entityEventListener)
|
||
{
|
||
_entityListeners.Remove(entityEventListener);
|
||
}
|
||
#endregion
|
||
|
||
#region Other
|
||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||
public void AggressiveUpVersion() { UpVersion(); }
|
||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||
private void UpVersion()
|
||
{
|
||
unchecked
|
||
{
|
||
_version++;
|
||
_deleteLeakedEntitesLastVersion++;
|
||
}
|
||
}
|
||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||
private void UpVersionLeaked()
|
||
{
|
||
unchecked
|
||
{
|
||
_version++;
|
||
}
|
||
}
|
||
#endregion
|
||
|
||
#region Debug Components
|
||
[ThreadStatic]
|
||
private static int[] _componentIDsBuffer;
|
||
[ThreadStatic]
|
||
private static object[] _componentsBuffer;
|
||
public ReadOnlySpan<int> GetComponentTypeIDsFor(int entityID)
|
||
{
|
||
int count = GetComponentTypeIDsFor_Internal(entityID, ref _componentIDsBuffer);
|
||
return new ReadOnlySpan<int>(_componentIDsBuffer, 0, count);
|
||
}
|
||
public unsafe void GetComponentPoolsFor(int entityID, List<IEcsPool> list)
|
||
{
|
||
const int BUFFER_THRESHOLD = 100;
|
||
|
||
var count = GetComponentsCount(entityID);
|
||
|
||
if (count <= 0)
|
||
{
|
||
list.Clear();
|
||
return;
|
||
}
|
||
|
||
int* poolIdsPtr;
|
||
if (count < BUFFER_THRESHOLD)
|
||
{
|
||
int* ptr = stackalloc int[count];
|
||
poolIdsPtr = ptr;
|
||
}
|
||
else
|
||
{
|
||
poolIdsPtr = UnmanagedArrayUtility.New<int>(count);
|
||
}
|
||
|
||
GetComponentTypeIDsFor_Internal(entityID, poolIdsPtr, count);
|
||
|
||
if (list.Count == count)
|
||
{
|
||
for (int i = 0; i < count; i++)
|
||
{
|
||
list[i] = _pools[poolIdsPtr[i]];
|
||
}
|
||
}
|
||
else
|
||
{
|
||
list.Clear();
|
||
for (int i = 0; i < count; i++)
|
||
{
|
||
list.Add(_pools[poolIdsPtr[i]]);
|
||
}
|
||
}
|
||
}
|
||
public ReadOnlySpan<object> GetComponentsFor(int entityID)
|
||
{
|
||
int count = GetComponentTypeIDsFor_Internal(entityID, ref _componentIDsBuffer);
|
||
ArrayUtility.UpsizeWithoutCopy(ref _componentIDsBuffer, count);
|
||
|
||
for (int i = 0; i < count; i++)
|
||
{
|
||
_componentsBuffer[i] = _pools[_componentIDsBuffer[i]].GetRaw(entityID);
|
||
}
|
||
return new ReadOnlySpan<object>(_componentsBuffer, 0, count);
|
||
}
|
||
public void GetComponentsFor(int entityID, List<object> list)
|
||
{
|
||
list.Clear();
|
||
int count = GetComponentTypeIDsFor_Internal(entityID, ref _componentIDsBuffer);
|
||
for (int i = 0; i < count; i++)
|
||
{
|
||
list.Add(_pools[_componentIDsBuffer[i]].GetRaw(entityID));
|
||
}
|
||
}
|
||
public void GetComponentTypesFor(int entityID, HashSet<Type> typeSet)
|
||
{
|
||
typeSet.Clear();
|
||
int count = GetComponentTypeIDsFor_Internal(entityID, ref _componentIDsBuffer);
|
||
for (int i = 0; i < count; i++)
|
||
{
|
||
typeSet.Add(_pools[_componentIDsBuffer[i]].ComponentType);
|
||
}
|
||
}
|
||
private unsafe int GetComponentTypeIDsFor_Internal(int entityID, ref int[] componentIDs)
|
||
{
|
||
var itemsCount = GetComponentsCount(entityID);
|
||
ArrayUtility.UpsizeWithoutCopy(ref componentIDs, itemsCount);
|
||
|
||
if (itemsCount <= 0) { return 0; }
|
||
|
||
const int LO_CHANK_HALF = 65535;
|
||
const int HI_CHANK_HALF = -65536;
|
||
const int COMPONENT_MASK_CHUNK_SIZE_HALF = COMPONENT_MASK_CHUNK_SIZE / 2;
|
||
// проверка на itemsCount <= 0 не обяательна, алгоритм не ломается,
|
||
// только впустую отрабатыват по всем чанкам,
|
||
// но как правильно для пустых сущностей этот алгоритм не применим.
|
||
int poolIndex = 0;
|
||
int bit;
|
||
int arrayIndex = 0;
|
||
for (int chunkIndex = entityID << _entityComponentMaskLengthBitShift,
|
||
chunkIndexMax = chunkIndex + _entityComponentMaskLength;
|
||
chunkIndex < chunkIndexMax;
|
||
chunkIndex++)
|
||
{
|
||
int chunk = _entityComponentMasks[chunkIndex];
|
||
if (chunk == 0)
|
||
{
|
||
poolIndex += COMPONENT_MASK_CHUNK_SIZE;
|
||
}
|
||
else
|
||
{
|
||
if ((chunk & LO_CHANK_HALF) != 0)
|
||
{
|
||
bit = 0x0000_0001;
|
||
while (bit < 0x0001_0000)
|
||
{
|
||
if ((chunk & bit) != 0)
|
||
{
|
||
componentIDs[arrayIndex++] = poolIndex;
|
||
|
||
itemsCount--;
|
||
if (itemsCount <= 0) { return arrayIndex; }
|
||
}
|
||
poolIndex++;
|
||
bit <<= 1;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
poolIndex += COMPONENT_MASK_CHUNK_SIZE_HALF;
|
||
}
|
||
if ((chunk & HI_CHANK_HALF) != 0)
|
||
{
|
||
bit = 0x0001_0000;
|
||
while (bit != 0x0000_0000)
|
||
{
|
||
if ((chunk & bit) != 0)
|
||
{
|
||
componentIDs[arrayIndex++] = poolIndex;
|
||
|
||
itemsCount--;
|
||
if (itemsCount <= 0) { return arrayIndex; }
|
||
}
|
||
poolIndex++;
|
||
bit <<= 1;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
poolIndex += COMPONENT_MASK_CHUNK_SIZE_HALF;
|
||
}
|
||
}
|
||
}
|
||
|
||
return itemsCount;
|
||
}
|
||
private unsafe void GetComponentTypeIDsFor_Internal(int entityID, int* componentIDs, int itemsCount)
|
||
{
|
||
const int LO_CHANK_HALF = 65535;
|
||
const int HI_CHANK_HALF = -65536;
|
||
const int COMPONENT_MASK_CHUNK_SIZE_HALF = COMPONENT_MASK_CHUNK_SIZE / 2;
|
||
// проверка на itemsCount <= 0 не обяательна, алгоритм не ломается,
|
||
// только впустую отрабатыват по всем чанкам,
|
||
// но как правильно для пустых сущностей этот алгоритм не применим.
|
||
int poolIndex = 0;
|
||
int bit;
|
||
for (int chunkIndex = entityID << _entityComponentMaskLengthBitShift,
|
||
chunkIndexMax = chunkIndex + _entityComponentMaskLength;
|
||
chunkIndex < chunkIndexMax;
|
||
chunkIndex++)
|
||
{
|
||
int chunk = _entityComponentMasks[chunkIndex];
|
||
if (chunk == 0)
|
||
{
|
||
poolIndex += COMPONENT_MASK_CHUNK_SIZE;
|
||
}
|
||
else
|
||
{
|
||
if ((chunk & LO_CHANK_HALF) != 0)
|
||
{
|
||
bit = 0x0000_0001;
|
||
while (bit < 0x0001_0000)
|
||
{
|
||
if ((chunk & bit) != 0)
|
||
{
|
||
*componentIDs = poolIndex;
|
||
componentIDs++;
|
||
|
||
itemsCount--;
|
||
if (itemsCount <= 0) { return; }
|
||
}
|
||
poolIndex++;
|
||
bit <<= 1;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
poolIndex += COMPONENT_MASK_CHUNK_SIZE_HALF;
|
||
}
|
||
if ((chunk & HI_CHANK_HALF) != 0)
|
||
{
|
||
bit = 0x0001_0000;
|
||
while (bit != 0x0000_0000)
|
||
{
|
||
if ((chunk & bit) != 0)
|
||
{
|
||
*componentIDs = poolIndex;
|
||
componentIDs++;
|
||
|
||
itemsCount--;
|
||
if (itemsCount <= 0) { return; }
|
||
}
|
||
poolIndex++;
|
||
bit <<= 1;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
poolIndex += COMPONENT_MASK_CHUNK_SIZE_HALF;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
#endregion
|
||
|
||
#region EntitySlot
|
||
[StructLayout(LayoutKind.Sequential)]
|
||
private struct EntitySlot
|
||
{
|
||
public static readonly EntitySlot Empty = new EntitySlot(GEN_SLEEP_MASK, 0, false);
|
||
public short gen;
|
||
public short componentsCount;
|
||
public bool isUsed;
|
||
public EntitySlot(short gen, short componentsCount, bool isUsed)
|
||
{
|
||
this.gen = gen;
|
||
this.componentsCount = componentsCount;
|
||
this.isUsed = isUsed;
|
||
}
|
||
}
|
||
#endregion
|
||
|
||
#region DebuggerProxy
|
||
protected partial class DebuggerProxy
|
||
{
|
||
private EcsWorld _world;
|
||
private List<MaskQueryExecutor> _queries;
|
||
public EntitySlotInfo[] Entities
|
||
{
|
||
get
|
||
{
|
||
EntitySlotInfo[] result = new EntitySlotInfo[_world.Count];
|
||
int i = 0;
|
||
foreach (var e in _world.ToSpan())
|
||
{
|
||
result[i++] = _world.GetEntitySlotInfoDebug(e);
|
||
}
|
||
return result;
|
||
}
|
||
}
|
||
public long Version { get { return _world.Version; } }
|
||
public IEcsPool[] Pools { get { return _world._pools; } }
|
||
public short ID { get { return _world.ID; } }
|
||
public bool IsDestroyed { get { return _world._isDestroyed; } }
|
||
public List<MaskQueryExecutor> MaskQueries { get { return _queries; } }
|
||
public DebuggerProxy(EcsWorld world)
|
||
{
|
||
_world = world;
|
||
int v = 0;
|
||
_queries = new List<MaskQueryExecutor>();
|
||
world.GetMaskQueryExecutors(_queries, ref v);
|
||
}
|
||
}
|
||
#endregion
|
||
|
||
#region Internal
|
||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||
internal EcsSpan GetCurrentEntities_Internal()
|
||
{
|
||
return _entityDispenser.UsedToEcsSpan(ID);
|
||
}
|
||
#endregion
|
||
}
|
||
|
||
#region Callbacks Interface
|
||
public interface IEcsWorldEventListener
|
||
{
|
||
void OnWorldResize(int newSize);
|
||
void OnReleaseDelEntityBuffer(ReadOnlySpan<int> buffer);
|
||
void OnWorldDestroy();
|
||
}
|
||
public interface IEcsEntityEventListener
|
||
{
|
||
void OnNewEntity(int entityID);
|
||
void OnDelEntity(int entityID);
|
||
}
|
||
internal static class WorldEventListExtensions
|
||
{
|
||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||
public static void InvokeOnWorldResize(this ref StructList<IEcsWorldEventListener> self, int newSize)
|
||
{
|
||
for (int i = 0, iMax = self.Count; i < iMax; i++)
|
||
{
|
||
self[i].OnWorldResize(newSize);
|
||
}
|
||
}
|
||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||
public static void InvokeOnReleaseDelEntityBuffer(this ref StructList<IEcsWorldEventListener> self, ReadOnlySpan<int> buffer)
|
||
{
|
||
for (int i = 0, iMax = self.Count; i < iMax; i++)
|
||
{
|
||
self[i].OnReleaseDelEntityBuffer(buffer);
|
||
}
|
||
}
|
||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||
public static void InvokeOnWorldDestroy(this ref StructList<IEcsWorldEventListener> self)
|
||
{
|
||
for (int i = 0, iMax = self.Count; i < iMax; i++)
|
||
{
|
||
self[i].OnWorldDestroy();
|
||
}
|
||
}
|
||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||
public static void InvokeOnNewEntity(this ref StructList<IEcsEntityEventListener> self, int entityID)
|
||
{
|
||
for (int i = 0, iMax = self.Count; i < iMax; i++)
|
||
{
|
||
self[i].OnNewEntity(entityID);
|
||
}
|
||
}
|
||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||
public static void InvokeOnDelEntity(this ref StructList<IEcsEntityEventListener> self, int entityID)
|
||
{
|
||
for (int i = 0, iMax = self.Count; i < iMax; i++)
|
||
{
|
||
self[i].OnDelEntity(entityID);
|
||
}
|
||
}
|
||
}
|
||
#endregion
|
||
|
||
#region Extensions
|
||
public static class EcsWorldExtenssions
|
||
{
|
||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||
public static bool IsNullOrDetroyed(this EcsWorld self)
|
||
{
|
||
return self == null || self.IsDestroyed;
|
||
}
|
||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||
public static void ReleaseDelEntityBufferAllAuto(this EcsWorld self)
|
||
{
|
||
if (self.IsEnableReleaseDelEntBuffer)
|
||
{
|
||
self.ReleaseDelEntityBufferAll();
|
||
}
|
||
}
|
||
}
|
||
public static class IntExtensions
|
||
{
|
||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||
public static entlong ToEntityLong(this int self, EcsWorld world)
|
||
{
|
||
return world.GetEntityLong(self);
|
||
}
|
||
}
|
||
#endregion
|
||
} |