コード例 #1
0
        public static void DestroyChunkForDiffing(Chunk *chunk,
                                                  EntityComponentStore *entityComponentStore,
                                                  ManagedComponentStore managedComponentStore)
        {
            chunk->Archetype->EntityCount -= chunk->Count;
            entityComponentStore->FreeEntities(chunk);

            EntityManagerCreateDestroyEntitiesUtility.SetChunkCount(chunk, 0,
                                                                    entityComponentStore, managedComponentStore);
        }
コード例 #2
0
        public static Chunk *CloneChunkForDiffing(Chunk *chunk,
                                                  ManagedComponentStore srcManagedManager,
                                                  EntityComponentStore *dstEntityComponentStore,
                                                  ManagedComponentStore dstManagedComponentStore,
                                                  EntityGroupManager dstEntityGroupManager)
        {
            int *sharedIndices = stackalloc int[chunk->Archetype->NumSharedComponents];

            chunk->SharedComponentValues.CopyTo(sharedIndices, 0, chunk->Archetype->NumSharedComponents);

            dstManagedComponentStore.CopySharedComponents(srcManagedManager, sharedIndices,
                                                          chunk->Archetype->NumSharedComponents);

            // Allocate a new chunk
            Archetype *arch = EntityManagerCreateArchetypeUtility.GetOrCreateArchetype(chunk->Archetype->Types,
                                                                                       chunk->Archetype->TypesCount, dstEntityComponentStore, dstEntityGroupManager);

            Chunk *targetChunk = EntityManagerCreateDestroyEntitiesUtility.GetCleanChunk(arch, sharedIndices,
                                                                                         dstEntityComponentStore, dstManagedComponentStore, dstEntityGroupManager);

            // GetCleanChunk & CopySharedComponents both acquire a ref, once chunk owns, release CopySharedComponents ref
            for (int i = 0; i < chunk->Archetype->NumSharedComponents; ++i)
            {
                dstManagedComponentStore.RemoveReference(sharedIndices[i]);
            }

            UnityEngine.Assertions.Assert.AreEqual(0, targetChunk->Count);
            UnityEngine.Assertions.Assert.IsTrue(targetChunk->Capacity >= chunk->Count);

            int copySize = Chunk.GetChunkBufferSize();

            UnsafeUtility.MemCpy(targetChunk->Buffer, chunk->Buffer, copySize);

            EntityManagerCreateDestroyEntitiesUtility.SetChunkCount(targetChunk, chunk->Count,
                                                                    dstEntityComponentStore, dstManagedComponentStore, dstEntityGroupManager);

            targetChunk->Archetype->EntityCount += chunk->Count;

            BufferHeader.PatchAfterCloningChunk(targetChunk);

            var tempEntities = new NativeArray <Entity>(targetChunk->Count, Allocator.Temp);

            dstEntityComponentStore->AllocateEntities(targetChunk->Archetype, targetChunk, 0, targetChunk->Count,
                                                      (Entity *)tempEntities.GetUnsafePtr());

            tempEntities.Dispose();

            return(targetChunk);
        }