private void MoveToNextMatchingChunk()
{
var m = m_CurrentMatchingArchetypeIndex;
var c = m_CurrentChunk;
var e = m_MatchingArchetypeList.p[m]->Archetype->Chunks.p + m_MatchingArchetypeList.p[m]->Archetype->Chunks.Count;
do
{
c = c + 1;
while (c == e)
{
m_CurrentArchetypeEntityIndex += m_CurrentChunkEntityIndex;
m_CurrentChunkEntityIndex = 0;
m = m - 1;
if (m < 0)
{
m_CurrentMatchingArchetypeIndex = m;
m_CurrentChunk = null;
return;
}
c = m_MatchingArchetypeList.p[m]->Archetype->Chunks.p;
e = m_MatchingArchetypeList.p[m]->Archetype->Chunks.p + m_MatchingArchetypeList.p[m]->Archetype->Chunks.Count;
}
} while (!((*c)->MatchesFilter(m_MatchingArchetypeList.p[m], ref m_Filter) && (*c)->Capacity > 0));
m_CurrentMatchingArchetypeIndex = m;
m_CurrentChunk = c;
}
public void MoveToEntityIndex(int index)
{
if (!m_Filter.RequiresMatchesFilter)
{
if (index < m_CurrentArchetypeEntityIndex)
{
m_CurrentMatchingArchetypeIndex = m_FirstMatchingArchetypeIndex;
m_CurrentArchetypeEntityIndex = 0;
m_CurrentChunk = m_CurrentMatchingArchetype->Archetype->Chunks.p;
// m_CurrentChunk might point to an invalid chunk if the first matching archetype has no chunks
// the while loop below will move to the first archetype that has any entities
m_CurrentChunkEntityIndex = 0;
}
while (index >= m_CurrentArchetypeEntityIndex + m_CurrentMatchingArchetype->Archetype->EntityCount)
{
m_CurrentArchetypeEntityIndex += m_CurrentMatchingArchetype->Archetype->EntityCount;
m_CurrentMatchingArchetypeIndex = m_CurrentMatchingArchetypeIndexNext;
m_CurrentChunk = m_CurrentMatchingArchetype->Archetype->Chunks.p;
m_CurrentChunkEntityIndex = 0;
}
index -= m_CurrentArchetypeEntityIndex;
if (index < m_CurrentChunkEntityIndex)
{
m_CurrentChunk = m_CurrentMatchingArchetype->Archetype->Chunks.p;
m_CurrentChunkEntityIndex = 0;
}
while (index >= m_CurrentChunkEntityIndex + (*m_CurrentChunk)->Count)
{
m_CurrentChunkEntityIndex += (*m_CurrentChunk)->Count;
m_CurrentChunk = m_CurrentChunk + 1;
}
}
else
{
if (index < m_CurrentArchetypeEntityIndex + m_CurrentChunkEntityIndex)
{
if (index < m_CurrentArchetypeEntityIndex)
{
m_CurrentMatchingArchetypeIndex = m_FirstMatchingArchetypeIndex;
m_CurrentArchetypeEntityIndex = 0;
}
m_CurrentChunk = m_CurrentMatchingArchetype->Archetype->Chunks.p - 1;
// m_CurrentChunk now points to an invalid chunk but since the chunk list is circular
// it effectively points to the chunk before the first
// MoveToNextMatchingChunk will move it to a valid chunk if any exists
m_CurrentChunkEntityIndex = 0;
MoveToNextMatchingChunk();
}
while (index >= m_CurrentArchetypeEntityIndex + m_CurrentChunkEntityIndex + (*m_CurrentChunk)->Count)
{
m_CurrentChunkEntityIndex += (*m_CurrentChunk)->Count;
MoveToNextMatchingChunk();
}
}
}
public ChunkIterator(int capacity)
{
this.capacity = capacity;
this.count = 0;
this.index = 0;
this.chunks = MemoryUtility.MallocPtrArray <Chunk>(this.capacity);
}
public void Dispose()
{
UnsafeUtility.Free(p, Allocator.Persistent);
p = null;
Capacity = 0;
Count = 0;
}
public void EnsureCapacity()
{
if (this.count == this.capacity)
{
this.capacity = this.capacity * 2;
this.chunks = MemoryUtility.ReallocPtrArray(this.chunks, this.capacity);
}
}
public ArchetypeChunkData(int componentCount, int sharedComponentCount)
{
p = null;
Capacity = 0;
Count = 0;
SharedComponentCount = sharedComponentCount;
ComponentCount = componentCount;
}
private static void EnsureCapacity()
{
if (count == capacity)
{
capacity = capacity * 2;
chunks = MemoryUtility.ReallocPtrArray(chunks, capacity);
}
}
static ChunkPool()
{
nextSequenceNumber = 0;
rentedCount = 0;
count = 0;
capacity = 16;
chunks = MemoryUtility.MallocPtrArray <Chunk>(capacity);
}
public ArchetypeChunkData(int componentTypeCount, int sharedComponentCount)
{
data = null;
p = null;
Capacity = 0;
Count = 0;
SharedComponentCount = sharedComponentCount;
EntityCountIndex = componentTypeCount + sharedComponentCount;
Channels = componentTypeCount + sharedComponentCount + 1; // +1 for entity count per-chunk
}
private void EnsureCapacity(int count)
{
int requiredCapacity = this.count + count;
if (requiredCapacity > this.capacity)
{
this.capacity = MemoryUtility.RoundToPowerOfTwo(requiredCapacity);
this.chunks = MemoryUtility.ReallocPtrArray <Chunk>(this.chunks, this.capacity);
}
}
public ComponentChunkIterator(MatchingArchetypes *match, uint globalSystemVersion,
ref ComponentGroupFilter filter)
{
m_FirstMatchingArchetype = match;
m_CurrentMatchingArchetype = match;
IndexInComponentGroup = -1;
m_CurrentChunk = null;
m_CurrentArchetypeIndex = m_CurrentArchetypeEntityIndex = int.MaxValue; // This will trigger UpdateCacheResolvedIndex to update the cache on first access
m_CurrentChunkIndex = m_CurrentChunkEntityIndex = 0;
m_GlobalSystemVersion = globalSystemVersion;
m_Filter = filter;
}
public static int WriteEntitiesToBuffer(Chunk **chunks, int count, Span <Entity> buffer)
{
int position = 0;
for (int i = 0; i < count; ++i)
{
var entities = GetEntities(chunks[i]);
entities.CopyTo(buffer.Slice(position));
position += entities.Length;
}
return(position);
}
public unsafe void Execute(int index)
{
EntityArchetype archetype = this.Archetypes[index];
int chunkCount = archetype.Archetype.ChunkCount;
Chunk * begin = (Chunk *)archetype.Archetype.ChunkList.Begin;
int num2 = this.Offsets[index];
Chunk ** unsafePtr = (Chunk **)this.Chunks.GetUnsafePtr <ArchetypeChunk>();
for (int i = 0; i < chunkCount; i++)
{
*((IntPtr *)(unsafePtr + (num2 + i))) = begin;
begin = (Chunk *)begin->ChunkListNode.Next;
}
}
public ComponentChunkIterator(UnsafeMatchingArchetypePtrList match, uint globalSystemVersion,
ref EntityQueryFilter filter)
{
m_MatchingArchetypeList = match;
m_CurrentMatchingArchetypeIndex = match.Length - 1;
IndexInEntityQuery = -1;
m_CurrentChunk = null;
m_CurrentArchetypeIndex =
m_CurrentArchetypeEntityIndex =
int.MaxValue; // This will trigger UpdateCacheResolvedIndex to update the cache on first access
m_CurrentChunkIndex = m_CurrentChunkEntityIndex = 0;
m_GlobalSystemVersion = globalSystemVersion;
m_Filter = filter;
}
public void Grow(int nextCapacity)
{
Assert.IsTrue(nextCapacity > Capacity);
ulong nextChunkPtrSize = (ulong)(sizeof(Chunk *) * nextCapacity);
ulong nextChangeVersionSize = (ulong)(sizeof(uint) * ComponentCount * nextCapacity);
ulong nextEntityCountSize = (ulong)(sizeof(int) * nextCapacity);
ulong nextSharedComponentValuesSize = (ulong)(sizeof(int) * SharedComponentCount * nextCapacity);
ulong nextBufferSize = nextChunkPtrSize + nextChangeVersionSize + nextEntityCountSize + nextSharedComponentValuesSize;
ulong nextBufferPtr = (ulong)Memory.Unmanaged.Allocate((long)nextBufferSize, 16, Allocator.Persistent);
Chunk **nextChunkData = (Chunk **)nextBufferPtr;
nextBufferPtr += nextChunkPtrSize;
uint *nextChangeVersions = (uint *)nextBufferPtr;
nextBufferPtr += nextChangeVersionSize;
int *nextEntityCount = (int *)nextBufferPtr;
nextBufferPtr += nextEntityCountSize;
int *nextSharedComponentValues = (int *)nextBufferPtr;
nextBufferPtr += nextSharedComponentValuesSize;
int prevCount = Count;
int prevCapacity = Capacity;
Chunk **prevChunkData = p;
uint * prevChangeVersions = ChangeVersions;
int * prevEntityCount = EntityCount;
int * prevSharedComponentValues = SharedComponentValues;
UnsafeUtility.MemCpy(nextChunkData, prevChunkData, (sizeof(Chunk *) * prevCount));
for (int i = 0; i < ComponentCount; i++)
{
UnsafeUtility.MemCpy(nextChangeVersions + (i * nextCapacity), prevChangeVersions + (i * prevCapacity), sizeof(uint) * Count);
}
for (int i = 0; i < SharedComponentCount; i++)
{
UnsafeUtility.MemCpy(nextSharedComponentValues + (i * nextCapacity), prevSharedComponentValues + (i * prevCapacity), sizeof(uint) * Count);
}
UnsafeUtility.MemCpy(nextEntityCount, prevEntityCount, sizeof(int) * Count);
Memory.Unmanaged.Free(p, Allocator.Persistent);
p = nextChunkData;
Capacity = nextCapacity;
}
internal int Allocate(Chunk **chunk, int entityIndex)
{
if (_usedCountInChunk < 0 || _usedCountInChunk >= _countInChunk)
{
_data.Allocate(_dataSize * _countInChunk, sizeof(ulong));
_usedCountInChunk = 0;
_countInTotal = _data.Count * _countInChunk;
}
int r = _usedCountInChunk++;
*chunk = _data.CurrentChunk;
SetEntityIndex(*chunk, r, entityIndex);
_usedCountInTotal++;
return(r);
}
public void Grow(int newCapacity)
{
Assert.IsTrue(newCapacity > Capacity);
Chunk **newChunkData = (Chunk **)UnsafeUtility.Malloc(newCapacity * (Channels * sizeof(int) + sizeof(Chunk *)), 16, Allocator.Persistent);
var newData = (int *)(newChunkData + newCapacity);
UnsafeUtility.MemCpy(newChunkData, p, sizeof(Chunk *) * Count);
for (int i = 0; i < Channels; ++i)
{
UnsafeUtility.MemCpy(newData + i * newCapacity, data + i * Capacity, sizeof(int) * Count);
}
UnsafeUtility.Free(p, Allocator.Persistent);
data = newData;
p = newChunkData;
Capacity = newCapacity;
}
internal void Free(Chunk *chunk, int indexInChunk, Chunk **newChunk, int *newIndexInChunk)
{
// @bug
#if false
Assert.IsTrue(_usedCountInTotal > 0);
int lastIndexInTotal = --_usedCountInTotal;
_usedCountInChunk--;
if (_usedCountInChunk < 0)
{
_usedCountInChunk = _countInChunk;
}
var lastChunk = _data.GetChunk(lastIndexInTotal / _countInChunk);
var lastIndexInChunk = lastIndexInTotal % _countInChunk;
int lastEntityIndex = GetEntityIndex(lastChunk, lastIndexInChunk);
var entityData = _entityDataManager.Get(lastEntityIndex);
CopyInternal(chunk, indexInChunk, entityData->Chunk, entityData->IndexInChunk);
entityData->Chunk = chunk;
entityData->IndexInChunk = indexInChunk;
#endif
}
public void MoveToChunkWithoutFiltering(int index)
{
if (index < m_CurrentArchetypeIndex)
{
m_CurrentMatchingArchetypeIndex = m_FirstMatchingArchetypeIndex;
m_CurrentChunk = m_CurrentMatchingArchetype->Archetype->Chunks.p;
m_CurrentArchetypeIndex = m_CurrentArchetypeEntityIndex = 0;
m_CurrentChunkIndex = m_CurrentChunkEntityIndex = 0;
}
while (index >= m_CurrentArchetypeIndex + m_CurrentMatchingArchetype->Archetype->Chunks.Count)
{
m_CurrentArchetypeEntityIndex += m_CurrentMatchingArchetype->Archetype->EntityCount;
m_CurrentArchetypeIndex += m_CurrentMatchingArchetype->Archetype->Chunks.Count;
m_CurrentMatchingArchetypeIndex = m_CurrentMatchingArchetypeIndexNext;
m_CurrentChunk = m_CurrentMatchingArchetype->Archetype->Chunks.p;
m_CurrentChunkIndex = m_CurrentChunkEntityIndex = 0;
}
index -= m_CurrentArchetypeIndex;
if (index < m_CurrentChunkIndex)
{
m_CurrentChunk = m_CurrentMatchingArchetype->Archetype->Chunks.p;
m_CurrentChunkIndex = m_CurrentChunkEntityIndex = 0;
}
while (index >= m_CurrentChunkIndex + 1)
{
m_CurrentChunkEntityIndex += (*m_CurrentChunk)->Count;
m_CurrentChunkIndex += 1;
m_CurrentChunk = m_CurrentChunk + 1;
}
}
public void Add(Chunk **chunks, int count)
{
EnsureCapacity(count);
Unsafe.CopyBlock((void *)&this.chunks[this.count], (void *)chunks, (uint)(sizeof(Chunk *) * count));
}
public static unsafe int TestRegressionInvalidGetElementPtrStructLayoutInternal(int index, int limit, Chunk **currentChunk)
{
int rValue = 0;
while (index >= limit + 1)
{
rValue += (*currentChunk)->Count;
index += 1;
}
return(rValue);
}
internal int Allocate(ArcheType *archeType, Chunk **chunk, int entityIndex)
{
var block = GetOrCreateBlock(archeType);
return(block.Allocate(chunk, entityIndex));
}
public ParallelReader(Chunk **ptr, int length)
{
Ptr = ptr; Length = length;
}
public unsafe UnsafeChunkPtrList(int initialCapacity, Allocator allocator, NativeArrayOptions options = NativeArrayOptions.UninitializedMemory)
{
Ptr = null; Length = 0; Capacity = 0; Allocator = Allocator.Invalid; this.ListData() = new UnsafePtrList(initialCapacity, allocator, options);
}
public unsafe UnsafeChunkPtrList(Chunk **ptr, int length)
{
Ptr = null; Length = 0; Capacity = 0; Allocator = Allocator.Invalid; this.ListData() = new UnsafePtrList((void **)ptr, length);
}
