internal object GetManagedObject(ManagedComponentStore managedComponentStore, int typeIndexInQuery, int entityInChunkIndex) { var indexInArchetype = CurrentMatchingArchetype->IndexInArchetype[typeIndexInQuery]; var managedComponentArray = (int *)ChunkDataUtility.GetComponentDataRW(CurrentChunk, 0, indexInArchetype, CurrentArchetype->EntityComponentStore->GlobalSystemVersion); return(managedComponentStore.GetManagedComponent(managedComponentArray[entityInChunkIndex])); }
/// <summary> /// This method will handle the cloning of Hybrid Components (if any) during the batched instantiation of an Entity /// </summary> /// <param name="srcArray">Array of source managed component indices. One per <paramref name="componentCount"/></param> /// <param name="componentCount">Number of component being instantiated</param> /// <param name="dstEntities">Array of destination entities. One per <paramref name="instanceCount"/></param> /// <param name="dstCompanionLinkIndices">Array of destination CompanionLink indices, can be null if the hybrid components are not owned</param> /// <param name="dstArray">Array of destination managed component indices. One per <paramref name="componentCount"/>*<paramref name="instanceCount"/>. All indices for the first component stored first etc.</param> /// <param name="instanceCount">Number of instances being created</param> /// <param name="managedComponentStore">Managed Store that owns the instances we create</param> static void InstantiateHybridComponentDelegate(int *srcArray, int componentCount, Entity *dstEntities, int *dstCompanionLinkIndices, int *dstArray, int instanceCount, ManagedComponentStore managedComponentStore) { if (dstCompanionLinkIndices != null) { var dstCompanionGameObjects = new GameObject[instanceCount]; for (int i = 0; i < instanceCount; ++i) { var companionLink = (CompanionLink)managedComponentStore.GetManagedComponent(dstCompanionLinkIndices[i]); dstCompanionGameObjects[i] = companionLink.Companion; CompanionLink.SetCompanionName(dstEntities[i], dstCompanionGameObjects[i]); } for (int src = 0; src < componentCount; ++src) { var componentType = managedComponentStore.GetManagedComponent(srcArray[src]).GetType(); for (int i = 0; i < instanceCount; i++) { var componentInInstance = dstCompanionGameObjects[i].GetComponent(componentType); var dstIndex = src * instanceCount + i; managedComponentStore.SetManagedComponentValue(dstArray[dstIndex], componentInInstance); } } } else { for (int src = 0; src < componentCount; ++src) { var component = managedComponentStore.GetManagedComponent(srcArray[src]); for (int i = 0; i < instanceCount; i++) { var dstIndex = src * instanceCount + i; managedComponentStore.SetManagedComponentValue(dstArray[dstIndex], component); } } } }
/// <summary> /// This method will handle the cloning of Hybrid Components (if any) during the batched instantiation of an Entity /// </summary> /// <param name="srcArray">Array of source managed component indices. One per <paramref name="componentCount"/></param> /// <param name="componentCount">Number of component being instantiated</param> /// <param name="dstEntities">Array of destination entities. One per <paramref name="instanceCount"/></param> /// <param name="dstArray">Array of destination managed component indices. One per <paramref name="componentCount"/>*<paramref name="instanceCount"/>. All indices for the first component stored first etc.</param> /// <param name="instanceCount">Number of instances being created</param> /// <param name="managedComponentStore">Managed Store that owns the instances we create</param> static void InstantiateHybridComponentDelegate(int *srcArray, int componentCount, Entity *dstEntities, int *dstArray, int instanceCount, ManagedComponentStore managedComponentStore) { object[] gameObjectInstances = null; for (int src = 0; src < componentCount; ++src) { object sourceComponent = managedComponentStore.GetManagedComponent(srcArray[src]); if ((sourceComponent as UnityEngine.Component)?.gameObject.GetComponent <CompanionLink>() == null) { for (int i = 0; i < instanceCount; ++i) { managedComponentStore.SetManagedComponentValue(dstArray[i], sourceComponent); } } else { var unityComponent = (UnityEngine.Component)sourceComponent; if (gameObjectInstances == null) { gameObjectInstances = new object[instanceCount]; for (int i = 0; i < instanceCount; ++i) { var instance = GameObject.Instantiate(unityComponent.gameObject); instance.name = CompanionLink.GenerateCompanionName(dstEntities[i]); gameObjectInstances[i] = instance; instance.hideFlags |= HideFlags.HideInHierarchy; } } for (int i = 0; i < instanceCount; i++) { var componentInInstance = ((GameObject)gameObjectInstances[i]).GetComponent(unityComponent.GetType()); managedComponentStore.SetManagedComponentValue(dstArray[i], componentInInstance); } } dstArray += instanceCount; } }
internal static BlobAssetsWithDistinctHash GetBlobAssetsWithDistinctHash( ManagedComponentStore managedComponentStore, NativeArray <ArchetypeChunk> chunks, Allocator allocator) { s_GetBlobAssetsWithDistinctHash.Begin(); var blobAssetsWithDistinctHash = new BlobAssetsWithDistinctHash(allocator); var typeInfoPtr = TypeManager.GetTypeInfoPointer(); var blobAssetRefOffsetPtr = TypeManager.GetBlobAssetRefOffsetsPointer(); var managedObjectBlobs = new ManagedObjectBlobs(); var managedObjectBlobAssets = new NativeList <BlobAssetPtr>(16, Allocator.Temp); var managedObjectBlobAssetsMap = new NativeHashMap <BlobAssetPtr, int>(16, Allocator.Temp); for (var chunkIndex = 0; chunkIndex < chunks.Length; chunkIndex++) { var chunk = chunks[chunkIndex].m_Chunk; var archetype = chunk->Archetype; // skip this chunk only if we are _certain_ there are no blob asset refs. if (!archetype->HasBlobAssetRefs) { continue; } var typesCount = archetype->TypesCount; var entityCount = chunks[chunkIndex].Count; for (var unorderedTypeIndexInArchetype = 0; unorderedTypeIndexInArchetype < typesCount; unorderedTypeIndexInArchetype++) { var typeIndexInArchetype = archetype->TypeMemoryOrder[unorderedTypeIndexInArchetype]; var componentTypeInArchetype = archetype->Types[typeIndexInArchetype]; if (componentTypeInArchetype.IsZeroSized) { continue; } ref var typeInfo = ref typeInfoPtr[componentTypeInArchetype.TypeIndex & TypeManager.ClearFlagsMask]; if (!typeInfo.HasBlobAssetRefs) { continue; } var chunkBuffer = chunk->Buffer; var subArrayOffset = archetype->Offsets[typeIndexInArchetype]; var componentArrayStart = chunkBuffer + subArrayOffset; if (componentTypeInArchetype.IsManagedComponent) { var componentSize = archetype->SizeOfs[typeIndexInArchetype]; var end = componentArrayStart + componentSize * entityCount; for (var componentData = componentArrayStart; componentData < end; componentData += componentSize) { var managedComponentIndex = *(int *)componentData; var managedComponentValue = managedComponentStore.GetManagedComponent(managedComponentIndex); if (null != managedComponentValue) { managedObjectBlobs.GatherBlobAssetReferences(managedComponentValue, managedObjectBlobAssets, managedObjectBlobAssetsMap); } } } else { var blobAssetRefCount = typeInfo.BlobAssetRefOffsetCount; var blobAssetRefOffsets = blobAssetRefOffsetPtr + typeInfo.BlobAssetRefOffsetStartIndex; if (componentTypeInArchetype.IsBuffer) { var header = (BufferHeader *)componentArrayStart; var strideSize = archetype->SizeOfs[typeIndexInArchetype]; var elementSize = typeInfo.ElementSize; for (var entityIndex = 0; entityIndex < entityCount; entityIndex++) { var bufferStart = BufferHeader.GetElementPointer(header); var bufferEnd = bufferStart + header->Length * elementSize; for (var componentData = bufferStart; componentData < bufferEnd; componentData += elementSize) { AddBlobAssetsWithDistinctHash(componentData, blobAssetRefOffsets, blobAssetRefCount, blobAssetsWithDistinctHash); } header = (BufferHeader *)(((byte *)header) + strideSize); } } else { var componentSize = archetype->SizeOfs[typeIndexInArchetype]; var end = componentArrayStart + componentSize * entityCount; for (var componentData = componentArrayStart; componentData < end; componentData += componentSize) { AddBlobAssetsWithDistinctHash(componentData, blobAssetRefOffsets, blobAssetRefCount, blobAssetsWithDistinctHash); } } } } }
internal static BlobAssetsWithDistinctHash GetBlobAssetsWithDistinctHash( ManagedComponentStore managedComponentStore, NativeArray <ArchetypeChunk> chunks, Allocator allocator) { var blobAssetsWithDistinctHash = new BlobAssetsWithDistinctHash(allocator); var typeInfoPtr = TypeManager.GetTypeInfoPointer(); var blobAssetRefOffsetPtr = TypeManager.GetBlobAssetRefOffsetsPointer(); var managedObjectBlobs = new ManagedObjectBlobs(); var managedObjectBlobAssets = new NativeList <BlobAssetPtr>(16, Allocator.Temp); var managedObjectBlobAssetsMap = new NativeHashMap <BlobAssetPtr, int>(16, Allocator.Temp); for (var chunkIndex = 0; chunkIndex < chunks.Length; chunkIndex++) { var chunk = chunks[chunkIndex].m_Chunk; var archetype = chunk->Archetype; // skip this chunk only if we are _certain_ there are no blob asset refs. if (archetype->NumManagedComponents == 0 && archetype->NumSharedComponents == 0 && !archetype->ContainsBlobAssetRefs) { continue; } var typesCount = archetype->TypesCount; var entityCount = chunks[chunkIndex].Count; for (var unorderedTypeIndexInArchetype = 0; unorderedTypeIndexInArchetype < typesCount; unorderedTypeIndexInArchetype++) { var typeIndexInArchetype = archetype->TypeMemoryOrder[unorderedTypeIndexInArchetype]; var componentTypeInArchetype = archetype->Types[typeIndexInArchetype]; if (componentTypeInArchetype.IsZeroSized) { continue; } var chunkBuffer = chunk->Buffer; var subArrayOffset = archetype->Offsets[typeIndexInArchetype]; var componentArrayStart = chunkBuffer + subArrayOffset; if (componentTypeInArchetype.IsManagedComponent) { var componentSize = archetype->SizeOfs[typeIndexInArchetype]; var end = componentArrayStart + componentSize * entityCount; for (var componentData = componentArrayStart; componentData < end; componentData += componentSize) { var managedComponentIndex = *(int *)componentData; var managedComponentValue = managedComponentStore.GetManagedComponent(managedComponentIndex); if (null != managedComponentValue) { managedObjectBlobs.GatherBlobAssetReferences(managedComponentValue, managedObjectBlobAssets, managedObjectBlobAssetsMap); } } } else { var typeInfo = typeInfoPtr[componentTypeInArchetype.TypeIndex & TypeManager.ClearFlagsMask]; var blobAssetRefCount = typeInfo.BlobAssetRefOffsetCount; if (blobAssetRefCount == 0) { continue; } var blobAssetRefOffsets = blobAssetRefOffsetPtr + typeInfo.BlobAssetRefOffsetStartIndex; if (componentTypeInArchetype.IsBuffer) { var header = (BufferHeader *)componentArrayStart; var strideSize = archetype->SizeOfs[typeIndexInArchetype]; var elementSize = typeInfo.ElementSize; for (var entityIndex = 0; entityIndex < entityCount; entityIndex++) { var bufferStart = BufferHeader.GetElementPointer(header); var bufferEnd = bufferStart + header->Length * elementSize; for (var componentData = bufferStart; componentData < bufferEnd; componentData += elementSize) { AddBlobAssetsWithDistinctHash(componentData, blobAssetRefOffsets, blobAssetRefCount, blobAssetsWithDistinctHash); } header = (BufferHeader *)(((byte *)header) + strideSize); } } else { var componentSize = archetype->SizeOfs[typeIndexInArchetype]; var end = componentArrayStart + componentSize * entityCount; for (var componentData = componentArrayStart; componentData < end; componentData += componentSize) { AddBlobAssetsWithDistinctHash(componentData, blobAssetRefOffsets, blobAssetRefCount, blobAssetsWithDistinctHash); } } } } } for (var chunkIndex = 0; chunkIndex < chunks.Length; chunkIndex++) { var chunk = chunks[chunkIndex].m_Chunk; var archetype = chunk->Archetype; var sharedComponentValues = chunk->SharedComponentValues; for (var i = 0; i < archetype->NumSharedComponents; i++) { var sharedComponentIndex = sharedComponentValues[i]; if (sharedComponentIndex == 0) { continue; } var sharedComponentValue = managedComponentStore.GetSharedComponentDataNonDefaultBoxed(sharedComponentIndex); managedObjectBlobs.GatherBlobAssetReferences(sharedComponentValue, managedObjectBlobAssets, managedObjectBlobAssetsMap); } } for (var i = 0; i < managedObjectBlobAssets.Length; i++) { var blobAssetPtr = managedObjectBlobAssets[i]; void *validationPtr = null; try { // Try to read ValidationPtr, this might throw if the memory has been unmapped validationPtr = blobAssetPtr.Header->ValidationPtr; } catch (Exception) { // Ignored } if (validationPtr != blobAssetPtr.Data) { continue; } blobAssetsWithDistinctHash.TryAdd(blobAssetPtr); } managedObjectBlobAssets.Dispose(); managedObjectBlobAssetsMap.Dispose(); new SortBlobAssetPtr { Array = blobAssetsWithDistinctHash.BlobAssets.AsDeferredJobArray() }.Run(); return(blobAssetsWithDistinctHash); }