Esempio n. 1
0
        public void ConstructChunk(Archetype *archetype, Chunk *chunk, int *sharedComponentDataIndices)
        {
            chunk->Archetype = archetype;

            chunk->Count         = 0;
            chunk->Capacity      = archetype->ChunkCapacity;
            chunk->ChunkListNode = new UnsafeLinkedListNode();
            chunk->ChunkListWithEmptySlotsNode = new UnsafeLinkedListNode();
            chunk->SharedComponentValueArray   = (int *)((byte *)(chunk) + Chunk.GetSharedComponentOffset(archetype->NumSharedComponents));

            archetype->ChunkList.Add(&chunk->ChunkListNode);
            archetype->ChunkListWithEmptySlots.Add(&chunk->ChunkListWithEmptySlotsNode);

            Assert.IsTrue(!archetype->ChunkList.IsEmpty);
            Assert.IsTrue(!archetype->ChunkListWithEmptySlots.IsEmpty);

            Assert.IsTrue(chunk == (Chunk *)(archetype->ChunkList.Back));
            Assert.IsTrue(chunk == GetChunkFromEmptySlotNode(archetype->ChunkListWithEmptySlots.Back));

            if (archetype->NumManagedArrays > 0)
            {
                chunk->ManagedArrayIndex = m_ManagedArrays.Count;
                var man = new ManagedArrayStorage();
                man.Chunk        = chunk;
                man.ManagedArray = new object[archetype->NumManagedArrays * chunk->Capacity];
                m_ManagedArrays.Add(man);
            }
            else
            {
                chunk->ManagedArrayIndex = -1;
            }


            if (archetype->NumSharedComponents <= 0)
            {
                return;
            }

            var sharedComponentValueArray = chunk->SharedComponentValueArray;

            CopySharedComponentDataIndexArray(sharedComponentValueArray, sharedComponentDataIndices, chunk->Archetype->NumSharedComponents);

            if (sharedComponentDataIndices == null)
            {
                return;
            }

            for (var i = 0; i < archetype->NumSharedComponents; ++i)
            {
                m_SharedComponentManager.AddReference(sharedComponentValueArray[i]);
            }
        }
        internal void AllocateManagedArrayStorage(int index, int length)
        {
            var managedArray        = new object[length];
            var managedArrayStorage = new ManagedArrayStorage {
                ManagedArray = managedArray
            };

            if (m_ManagedArrays.Length <= index)
            {
                Array.Resize(ref m_ManagedArrays, index + 1);
            }

            m_ManagedArrays[index] = managedArrayStorage;
        }
 internal void DeallocateManagedArrayStorage(int index)
 {
     Assert.IsTrue(m_ManagedArrays.Length > index);
     Assert.IsTrue(m_ManagedArrays[index].ManagedArray != null);
     m_ManagedArrays[index] = new ManagedArrayStorage();
 }