public void SetFilter <SharedComponent1, SharedComponent2>(SharedComponent1 sharedComponent1,
SharedComponent2 sharedComponent2)
where SharedComponent1 : struct, ISharedComponentData
where SharedComponent2 : struct, ISharedComponentData
{
var sm = ArchetypeManager.GetSharedComponentDataManager();
var filter = new ComponentGroupFilter();
filter.Type = FilterType.SharedComponent;
filter.Shared.Count = 2;
filter.Shared.IndexInComponentGroup[0] = GetIndexInComponentGroup(TypeManager.GetTypeIndex <SharedComponent1>());
filter.Shared.SharedComponentIndex[0] = sm.InsertSharedComponent(sharedComponent1);
filter.Shared.IndexInComponentGroup[1] = GetIndexInComponentGroup(TypeManager.GetTypeIndex <SharedComponent2>());
filter.Shared.SharedComponentIndex[1] = sm.InsertSharedComponent(sharedComponent2);
SetFilter(ref filter);
}
internal void GetComponentDataArray <T>(ref ComponentChunkIterator iterator, int indexInComponentGroup,
int length, out ComponentDataArray <T> output) where T : struct, IComponentData
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
var typeIndex = TypeManager.GetTypeIndex <T>();
var componentType = ComponentType.FromTypeIndex(typeIndex);
if (componentType.IsZeroSized)
{
throw new ArgumentException($"GetComponentDataArray<{typeof(T)}> cannot be called on zero-sized IComponentData");
}
#endif
iterator.IndexInComponentGroup = indexInComponentGroup;
#if ENABLE_UNITY_COLLECTIONS_CHECKS
output = new ComponentDataArray <T>(iterator, length, GetSafetyHandle(indexInComponentGroup));
#else
output = new ComponentDataArray <T>(iterator, length);
#endif
}
/// <summary>
/// Sets the value of a component of an entity.
/// </summary>
/// <param name="entity">The entity.</param>
/// <param name="componentData">The data to set.</param>
/// <typeparam name="T">The component type.</typeparam>
/// <exception cref="ArgumentException">Thrown if the component type has no fields.</exception>
public void SetComponentData <T>(Entity entity, T componentData) where T : struct, IComponentData
{
var typeIndex = TypeManager.GetTypeIndex <T>();
EntityComponentStore->AssertEntityHasComponent(entity, typeIndex);
#if ENABLE_UNITY_COLLECTIONS_CHECKS
if (ComponentType.FromTypeIndex(typeIndex).IsZeroSized)
{
throw new System.ArgumentException(
$"SetComponentData<{typeof(T)}> can not be called with a zero sized component.");
}
#endif
ComponentJobSafetyManager->CompleteReadAndWriteDependency(typeIndex);
var ptr = EntityComponentStore->GetComponentDataWithTypeRW(entity, typeIndex, EntityComponentStore->GlobalSystemVersion);
UnsafeUtility.CopyStructureToPtr(ref componentData, ptr);
}
/// <summary>
/// Filters this EntityQuery based on the values of two separate shared components.
/// </summary>
/// <remarks>
/// The filter only selects entities for which both shared component values
/// specified by the `sharedComponent1` and `sharedComponent2` parameters match.
/// </remarks>
/// <param name="sharedComponent1">Shared component values on which to filter.</param>
/// <param name="sharedComponent2">Shared component values on which to filter.</param>
/// <typeparam name="SharedComponent1">The type of shared component. (The type must also be
/// one of the types used to create the EntityQuery.</typeparam>
/// <typeparam name="SharedComponent2">The type of shared component. (The type must also be
/// one of the types used to create the EntityQuery.</typeparam>
public void SetFilter <SharedComponent1, SharedComponent2>(SharedComponent1 sharedComponent1,
SharedComponent2 sharedComponent2)
where SharedComponent1 : struct, ISharedComponentData
where SharedComponent2 : struct, ISharedComponentData
{
var sm = ManagedComponentStore;
var filter = new EntityQueryFilter();
filter.Type = FilterType.SharedComponent;
filter.Shared.Count = 2;
filter.Shared.IndexInEntityQuery[0] = GetIndexInEntityQuery(TypeManager.GetTypeIndex <SharedComponent1>());
filter.Shared.SharedComponentIndex[0] = sm.InsertSharedComponent(sharedComponent1);
filter.Shared.IndexInEntityQuery[1] = GetIndexInEntityQuery(TypeManager.GetTypeIndex <SharedComponent2>());
filter.Shared.SharedComponentIndex[1] = sm.InsertSharedComponent(sharedComponent2);
SetFilter(ref filter);
}
private static unsafe void ApplyAddComponents(
EntityManager entityManager,
NativeArray <PackedComponent> addComponents,
NativeArray <EntityGuid> packedEntityGuids,
NativeMultiHashMap <int, Entity> packedEntities,
NativeArray <ComponentType> packedTypes)
{
var linkedEntityGroupTypeIndex = TypeManager.GetTypeIndex <LinkedEntityGroup>();
for (var i = 0; i < addComponents.Length; i++)
{
var packedComponent = addComponents[i];
if (!packedEntities.TryGetFirstValue(packedComponent.PackedEntityIndex, out var entity, out var iterator))
{
continue;
}
var component = packedTypes[packedComponent.PackedTypeIndex];
do
{
if (!entityManager.EntityComponentStore->HasComponent(entity, component))
{
entityManager.AddComponent(entity, component);
// magic is required to force the first entity in the LinkedEntityGroup to be the entity
// that owns the component. this magic doesn't seem to exist at a lower level, so let's
// shim it in here. we'll probably need to move the magic lower someday.
if (component.TypeIndex == linkedEntityGroupTypeIndex)
{
var buffer = entityManager.GetBuffer <LinkedEntityGroup>(entity);
buffer.Add(entity);
}
}
else
{
Debug.LogWarning($"AddComponent({packedEntityGuids[packedComponent.PackedEntityIndex]}, {component}) but the component already exists.");
}
}while (packedEntities.TryGetNextValue(out entity, ref iterator));
}
}
bool TestMatchingArchetypeAll(Archetype *archetype, ComponentType *allTypes, int allCount)
{
var componentTypes = archetype->Types;
var componentTypesCount = archetype->TypesCount;
var foundCount = 0;
var disabledTypeIndex = TypeManager.GetTypeIndex <Disabled>();
var prefabTypeIndex = TypeManager.GetTypeIndex <Prefab>();
var requestedDisabled = false;
var requestedPrefab = false;
for (var i = 0; i < componentTypesCount; i++)
{
var componentTypeIndex = componentTypes[i].TypeIndex;
for (var j = 0; j < allCount; j++)
{
var allTypeIndex = allTypes[j].TypeIndex;
if (allTypeIndex == disabledTypeIndex)
{
requestedDisabled = true;
}
if (allTypeIndex == prefabTypeIndex)
{
requestedPrefab = true;
}
if (componentTypeIndex == allTypeIndex)
{
foundCount++;
}
}
}
if (archetype->Disabled && (!requestedDisabled))
{
return(false);
}
if (archetype->Prefab && (!requestedPrefab))
{
return(false);
}
return(foundCount == allCount);
}
public ComponentDataArray <T> GetComponentDataArray <T>() where T : struct, IComponentData
{
var typeIndex = TypeManager.GetTypeIndex <T>();
#if ENABLE_UNITY_COLLECTIONS_CHECKS
var componentType = ComponentType.FromTypeIndex(typeIndex);
if (componentType.IsZeroSized)
{
throw new ArgumentException($"GetComponentDataArray<{typeof(T)}> cannot be called on zero-sized IComponentData");
}
#endif
int length = CalculateLength();
ComponentChunkIterator iterator = GetComponentChunkIterator();
var indexInComponentGroup = GetIndexInComponentGroup(typeIndex);
ComponentDataArray <T> res;
GetComponentDataArray(ref iterator, indexInComponentGroup, length, out res);
return(res);
}
public int InsertSharedComponent <T>(T newData) where T : struct
{
var typeIndex = TypeManager.GetTypeIndex <T>();
var index = FindSharedComponentIndex(TypeManager.GetTypeIndex <T>(), newData);
if (index == 0)
{
return(0);
}
if (index != -1)
{
m_SharedComponentRefCount[index]++;
return(index);
}
var hashcode = TypeManager.GetHashCode <T>(ref newData);
return(Add(typeIndex, hashcode, newData));
}
static SharedComponentDataManager()
{
TypeManager.Initialize();
var assemblies = AppDomain.CurrentDomain.GetAssemblies();
ISharedComponentDataType = typeof(ISharedComponentData);
for (int i = 0; i < assemblies.Length; ++i)
{
var types = assemblies[i].GetTypes();
for (int j = 0; j < types.Length; ++j)
{
if (!types[j].IsValueType || !ISharedComponentDataType.IsAssignableFrom(types[j]) || (types[j].IsGenericType && types[j].IsGenericTypeDefinition))
{
continue;
}
TypeManager.GetTypeIndex(types[j]);
}
}
for (int i = 1, length = TypeManager.GetTypeCount(); i < length; ++i)
{
var type = TypeManager.GetType(i);
if (!type.IsValueType || !ISharedComponentDataType.IsAssignableFrom(type) || (type.IsGenericType && type.IsGenericTypeDefinition))
{
continue;
}
#if REF_EQUATABLE
var EqualsMethodInfo = type.GetMethod("Equals", BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly, null, CallingConventions.Any, EqualsTypeArray, null);
if (EqualsMethodInfo == null || EqualsMethodInfo.DeclaringType != type)
{
throw new Exception(type.FullName);
}
var GetHashCodeMethodInfo = type.GetMethod("GetHashCode", BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly, null, CallingConventions.Any, Array.Empty <Type>(), null);
if (GetHashCodeMethodInfo == null || GetHashCodeMethodInfo.DeclaringType != type)
{
throw new Exception(type.FullName);
}
#endif
SharedComponentTypeStart = i;
break;
}
}
public int InsertSharedComponent <T>(T newData) where T : struct
{
int typeIndex = TypeManager.GetTypeIndex <T>();
int index = FindSharedComponentIndex(TypeManager.GetTypeIndex <T>(), newData);
if (index == 0)
{
return(0);
}
else if (index != -1)
{
m_SharedComponentRefCount[index]++;
return(index);
}
else
{
var fastLayout = TypeManager.GetComponentType(typeIndex).FastEqualityLayout;
var hashcode = FastEquality.GetHashCode(ref newData, fastLayout);
return(Add(typeIndex, hashcode, newData));
}
}
public T GetComponentData <T>(Entity entity) where T : struct, IComponentData
{
var typeIndex = TypeManager.GetTypeIndex <T>();
Entities->AssertEntityHasComponent(entity, typeIndex);
#if ENABLE_UNITY_COLLECTIONS_CHECKS
if (ComponentType.FromTypeIndex(typeIndex).IsZeroSized)
{
throw new System.ArgumentException($"GetComponentData<{typeof(T)}> can not be called with a zero sized component.");
}
#endif
ComponentJobSafetyManager.CompleteWriteDependency(typeIndex);
var ptr = Entities->GetComponentDataWithTypeRO(entity, typeIndex);
T value;
UnsafeUtility.CopyPtrToStructure(ptr, out value);
return(value);
}
public static T[] ToComponentArray <T>(this EntityQuery group) where T : Component
{
int entityCount = group.CalculateEntityCount();
var arr = new T[entityCount];
var iterator = group.GetArchetypeChunkIterator();
var indexInEntityQuery = group.GetIndexInEntityQuery(TypeManager.GetTypeIndex <T>());
var entityCounter = 0;
while (iterator.MoveNext())
{
var chunk = iterator.CurrentArchetypeChunk;
for (int entityIndex = 0; entityIndex < chunk.Count; ++entityIndex)
{
arr[entityCounter++] = (T)iterator.GetManagedObject(group.ManagedComponentStore, indexInEntityQuery, entityIndex);
}
}
return(arr);
}
public void SetComponentData <T>(Entity entity, T componentData) where T : struct, IComponentData
{
var typeIndex = TypeManager.GetTypeIndex <T>();
Entities->AssertEntityHasComponent(entity, typeIndex);
// If the user attempts to set a zero-sized type, we do nothing instead.
// This is to prevent requiring users from checking for zero-size before calling this API.
var componentType = ComponentType.FromTypeIndex(typeIndex);
if (componentType.IsZeroSized)
{
return;
}
ComponentJobSafetyManager.CompleteReadAndWriteDependency(typeIndex);
var ptr = Entities->GetComponentDataWithTypeRW(entity, typeIndex, Entities->GlobalSystemVersion);
UnsafeUtility.CopyStructureToPtr(ref componentData, ptr);
}
internal bool CompareComponents(ComponentType *componentTypes, int count)
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
for (var k = 0; k < count; ++k)
{
if (componentTypes[k].TypeIndex == TypeManager.GetTypeIndex <Entity>())
{
throw new ArgumentException(
"ComponentGroup.CompareComponents may not include typeof(Entity), it is implicit");
}
}
#endif
// ComponentGroups are constructed including the Entity ID
var requiredCount = m_GroupData->RequiredComponentsCount;
if (count != requiredCount - 1)
{
return(false);
}
for (var k = 0; k < count; ++k)
{
int i;
for (i = 1; i < requiredCount; ++i)
{
if (m_GroupData->RequiredComponents[i] == componentTypes[k])
{
break;
}
}
if (i == requiredCount)
{
return(false);
}
}
return(true);
}
internal unsafe void AddEntitySharedComponentCommand <T>(EntityCommandBufferChain *chain, int jobIndex, ECBCommand op, Entity e, int hashCode, object boxedObject) where T : struct
{
int size = Align(sizeof(EntitySharedComponentCommand), 8);
EntitySharedComponentCommand *commandPtr = (EntitySharedComponentCommand *)ref this.Reserve(chain, jobIndex, size);
commandPtr->Header.Header.CommandType = (int)op;
commandPtr->Header.Header.TotalSize = size;
commandPtr->Header.Header.SortIndex = chain.m_LastSortIndex;
commandPtr->Header.Entity = e;
commandPtr->ComponentTypeIndex = TypeManager.GetTypeIndex <T>();
commandPtr->HashCode = hashCode;
if (boxedObject == null)
{
commandPtr->BoxedObject = new GCHandle();
}
else
{
commandPtr->BoxedObject = GCHandle.Alloc(boxedObject);
commandPtr->Prev = chain.m_CleanupList;
chain.m_CleanupList = commandPtr;
}
}
private static unsafe void ApplyRemoveComponents(
EntityManager entityManager,
NativeArray <PackedComponent> removeComponents,
NativeArray <EntityGuid> packedEntityGuids,
NativeMultiHashMap <int, Entity> packedEntities,
NativeArray <ComponentType> packedTypes)
{
var entityGuidTypeIndex = TypeManager.GetTypeIndex <EntityGuid>();
for (var i = 0; i < removeComponents.Length; i++)
{
var packedComponent = removeComponents[i];
if (!packedEntities.TryGetFirstValue(packedComponent.PackedEntityIndex, out var entity, out var iterator))
{
continue;
}
var component = packedTypes[packedComponent.PackedTypeIndex];
do
{
if (component.TypeIndex == entityGuidTypeIndex)
{
// @TODO Add test cases around this.
// Should entityGuidToEntity be updated or should we throw and error.
}
if (entityManager.EntityComponentStore->HasComponent(entity, component))
{
entityManager.RemoveComponent(entity, component);
}
else
{
Debug.LogWarning($"RemoveComponent({packedEntityGuids[packedComponent.PackedEntityIndex]}, {component}) but the component already exists.");
}
}while (packedEntities.TryGetNextValue(out entity, ref iterator));
}
}
public DynamicBuffer <T> GetBuffer <T>(Entity entity) where T : struct, IBufferElementData
{
var typeIndex = TypeManager.GetTypeIndex <T>();
#if ENABLE_UNITY_COLLECTIONS_CHECKS
Entities->AssertEntityHasComponent(entity, typeIndex);
if (TypeManager.GetTypeInfo <T>().Category != TypeManager.TypeCategory.BufferData)
{
throw new ArgumentException(
$"GetBuffer<{typeof(T)}> may not be IComponentData or ISharedComponentData; currently {TypeManager.GetTypeInfo<T>().Category}");
}
#endif
ComponentJobSafetyManager.CompleteReadAndWriteDependency(typeIndex);
BufferHeader *header = (BufferHeader *)Entities->GetComponentDataWithTypeRW(entity, typeIndex, Entities->GlobalSystemVersion);
#if ENABLE_UNITY_COLLECTIONS_CHECKS
return(new DynamicBuffer <T>(header, ComponentJobSafetyManager.GetSafetyHandle(typeIndex, false), ComponentJobSafetyManager.GetBufferSafetyHandle(typeIndex), false));
#else
return(new DynamicBuffer <T>(header));
#endif
}
/// <summary>
/// Creates a NativeArray containing the components of type T for the selected entities.
/// </summary>
/// <param name="allocator">The type of memory to allocate.</param>
/// <typeparam name="T">The component type.</typeparam>
/// <returns>An array containing the specified component for all the entities selected
/// by the EntityQuery.</returns>
/// <exception cref="InvalidOperationException">Thrown if you ask for a component that is not part of
/// the group.</exception>
public NativeArray <T> ToComponentDataArray <T>(Allocator allocator)
where T : struct, IComponentData
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
var componentType = new ArchetypeChunkComponentType <T>(m_SafetyManager->GetSafetyHandle(TypeManager.GetTypeIndex <T>(), true), true, EntityComponentStore->GlobalSystemVersion);
#else
var componentType = new ArchetypeChunkComponentType <T>(true, EntityComponentStore->GlobalSystemVersion);
#endif
#if ENABLE_UNITY_COLLECTIONS_CHECKS
int typeIndex = TypeManager.GetTypeIndex <T>();
int indexInEntityQuery = GetIndexInEntityQuery(typeIndex);
if (indexInEntityQuery == -1)
{
throw new InvalidOperationException($"Trying ToComponentDataArray of {TypeManager.GetType(typeIndex)} but the required component type was not declared in the EntityGroup.");
}
#endif
JobHandle job;
var res = ComponentChunkIterator.CreateComponentDataArray(m_QueryData->MatchingArchetypes, allocator, componentType, this, ref m_Filter, out job, GetDependency());
job.Complete();
return(res);
}
public static void AssertArchetypeComponents(ComponentTypeInArchetype *types, int count)
{
if (count < 1)
{
throw new ArgumentException($"Invalid component count");
}
if (types[0].TypeIndex != TypeManager.GetTypeIndex <Entity>())
{
throw new ArgumentException($"The Entity ID must always be the first component");
}
for (var i = 1; i < count; i++)
{
if (!TypeManager.IsValidComponentTypeForArchetype(types[i].TypeIndex, types[i].IsFixedArray))
{
throw new ArgumentException($"{types[i]} is not a valid component type.");
}
if (types[i - 1].TypeIndex == types[i].TypeIndex)
{
throw new ArgumentException($"It is not allowed to have two components of the same type on the same entity. ({types[i-1]} and {types[i]})");
}
}
}
public ForEachComponentGroupFilter CreateForEachFilter <SharedComponent1>(
List <SharedComponent1> sharedComponent1)
where SharedComponent1 : struct, ISharedComponentData
{
var forEachFilter = new ForEachComponentGroupFilter();
forEachFilter.TypeManager = ArchetypeManager;
forEachFilter.ItemIterator =
new NativeArray <ComponentChunkIterator>(sharedComponent1.Count, Allocator.Temp);
forEachFilter.ItemLength = new NativeArray <int>(sharedComponent1.Count, Allocator.Temp);
forEachFilter.SharedComponentIndex = new NativeArray <int>(sharedComponent1.Count, Allocator.Temp);
forEachFilter.IndexInComponentGroup =
GetIndexInComponentGroup(TypeManager.GetTypeIndex <SharedComponent1>());
for (var i = 0; i < sharedComponent1.Count; ++i)
{
forEachFilter.SharedComponentIndex[i] = ArchetypeManager.GetSharedComponentDataManager()
.InsertSharedComponent(sharedComponent1[i]);
}
m_ComponentGroupData.GetComponentChunkIterators(forEachFilter);
return(forEachFilter);
}
public static T[] ToComponentArray <T>(this ComponentGroup group) where T : Component
{
int length = group.CalculateLength();
ComponentChunkIterator iterator = group.GetComponentChunkIterator();
var indexInComponentGroup = group.GetIndexInComponentGroup(TypeManager.GetTypeIndex <T>());
iterator.IndexInComponentGroup = indexInComponentGroup;
var arr = new T[length];
var cache = default(ComponentChunkCache);
for (int i = 0; i < length; ++i)
{
if (i < cache.CachedBeginIndex || i >= cache.CachedEndIndex)
{
iterator.MoveToEntityIndexAndUpdateCache(i, out cache, true);
}
arr[i] = (T)iterator.GetManagedObject(group.ArchetypeManager, cache.CachedBeginIndex, i);
}
return(arr);
}
public int InsertSharedComponent <T>(T newData) where T : struct
{
var typeIndex = TypeManager.GetTypeIndex <T>();
var index = FindSharedComponentIndex(TypeManager.GetTypeIndex <T>(), newData);
if (index == 0)
{
return(0);
}
if (index != -1)
{
SharedComponentInfoPtr[index].RefCount++;
return(index);
}
var hashcode = TypeManager.GetHashCode <T>(ref newData);
object newDataObj = newData;
(newDataObj as IRefCounted)?.Retain();
return(Add(typeIndex, hashcode, newDataObj));
}
public T GetComponentData <T>(Entity entity) where T : struct, IComponentData
{
var typeIndex = TypeManager.GetTypeIndex <T>();
Entities->AssertEntityHasComponent(entity, typeIndex);
// If the user attempts to get a zero-sized type, we return a default-initialized value instead.
// This is to prevent requiring users from checking for zero-size before calling this API.
var componentType = ComponentType.FromTypeIndex(typeIndex);
if (componentType.IsZeroSized)
{
return(default(T));
}
ComponentJobSafetyManager.CompleteWriteDependency(typeIndex);
var ptr = Entities->GetComponentDataWithTypeRO(entity, typeIndex);
T value;
UnsafeUtility.CopyPtrToStructure(ptr, out value);
return(value);
}
IPropertyBag GetPropertyBag(object obj)
{
if (null == obj)
{
throw new ArgumentNullException(nameof(obj));
}
var type = obj.GetType();
var typeInfo = TypeManager.GetTypeInfo(TypeManager.GetTypeIndex(type));
if (typeInfo.Category == TypeManager.TypeCategory.UnityEngineObject)
{
throw new ArgumentException("Cannot remap hybrid components", nameof(obj));
}
var properties = PropertyBagStore.GetPropertyBag(type);
if (null == properties)
{
throw new MissingPropertyBagException(type);
}
return(properties);
}
public DynamicBuffer <T> GetBuffer <T>(Entity entity) where T : struct, IBufferElementData
{
CheckAccess();
var typeIndex = TypeManager.GetTypeIndex <T>();
m_Entities->AssertEntityHasComponent(entity, typeIndex);
#if ENABLE_UNITY_COLLECTIONS_CHECKS
if (!TypeManager.IsBuffer(typeIndex))
{
throw new ArgumentException(
$"GetBuffer<{typeof(T)}> may not be IComponentData or ISharedComponentData; currently {TypeManager.GetTypeInfo<T>().Category}");
}
#endif
BufferHeader *header = (BufferHeader *)m_Entities->GetComponentDataWithTypeRW(entity, typeIndex, m_Entities->GlobalSystemVersion);
#if ENABLE_UNITY_COLLECTIONS_CHECKS
return(new DynamicBuffer <T>(header, m_Safety, m_Safety, false));
#else
return(new DynamicBuffer <T>(header));
#endif
}
public void SetSingleton <T>(T value)
where T : struct, IComponentData
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
if (GetIndexInComponentGroup(TypeManager.GetTypeIndex <T>()) != 1)
{
throw new System.InvalidOperationException($"GetSingleton<{typeof(T)}>() requires that {typeof(T)} is the only component type in its archetype.");
}
var groupLength = CalculateLength();
if (groupLength != 1)
{
throw new System.InvalidOperationException($"SetSingleton<{typeof(T)}>() requires that exactly one {typeof(T)} exists but there are {groupLength}.");
}
#endif
CompleteDependency();
var iterator = GetComponentChunkIterator();
iterator.MoveToChunkWithoutFiltering(0);
var array = iterator.GetCurrentChunkComponentDataPtr(true, 1);
UnsafeUtility.CopyStructureToPtr(ref value, array);
}
public int GetSharedComponentVersion <T>(T sharedData) where T : struct
{
var index = FindSharedComponentIndex(TypeManager.GetTypeIndex <T>(), sharedData);
return(index == -1 ? 0 : m_SharedComponentVersion[index]);
}
// ----------------------------------------------------------------------------------------------------------
// PUBLIC
// ----------------------------------------------------------------------------------------------------------
public static Archetype *GetOrCreateArchetype(ComponentTypeInArchetype *inTypesSorted, int count,
EntityComponentStore *entityComponentStore)
{
var srcArchetype = entityComponentStore->GetExistingArchetype(inTypesSorted, count);
if (srcArchetype != null)
{
return(srcArchetype);
}
srcArchetype = entityComponentStore->CreateArchetype(inTypesSorted, count);
var types = stackalloc ComponentTypeInArchetype[count + 1];
// Setup Instantiable archetype
{
UnsafeUtility.MemCpy(types, inTypesSorted, sizeof(ComponentTypeInArchetype) * count);
var hasCleanup = false;
var removedTypes = 0;
var prefabTypeIndex = TypeManager.GetTypeIndex <Prefab>();
var cleanupTypeIndex = TypeManager.GetTypeIndex <CleanupEntity>();
for (var t = 0; t < srcArchetype->TypesCount; ++t)
{
var type = srcArchetype->Types[t];
hasCleanup |= type.TypeIndex == cleanupTypeIndex;
var skip = type.IsSystemStateComponent || type.TypeIndex == prefabTypeIndex;
if (skip)
{
++removedTypes;
}
else
{
types[t - removedTypes] = srcArchetype->Types[t];
}
}
// Entity has already been destroyed, so it shouldn't be instantiated anymore
if (hasCleanup)
{
srcArchetype->InstantiableArchetype = null;
}
else if (removedTypes > 0)
{
var instantiableArchetype = GetOrCreateArchetype(types, count - removedTypes, entityComponentStore);
srcArchetype->InstantiableArchetype = instantiableArchetype;
Assert.IsTrue(instantiableArchetype->InstantiableArchetype == instantiableArchetype);
Assert.IsTrue(instantiableArchetype->SystemStateResidueArchetype == null);
}
else
{
srcArchetype->InstantiableArchetype = srcArchetype;
}
}
// Setup System state cleanup archetype
if (srcArchetype->SystemStateCleanupNeeded)
{
var cleanupEntityType = new ComponentTypeInArchetype(ComponentType.ReadWrite <CleanupEntity>());
bool cleanupAdded = false;
types[0] = inTypesSorted[0];
var newTypeCount = 1;
for (var t = 1; t < srcArchetype->TypesCount; ++t)
{
var type = srcArchetype->Types[t];
if (type.IsSystemStateComponent)
{
if (!cleanupAdded && (cleanupEntityType < srcArchetype->Types[t]))
{
types[newTypeCount++] = cleanupEntityType;
cleanupAdded = true;
}
types[newTypeCount++] = srcArchetype->Types[t];
}
}
if (!cleanupAdded)
{
types[newTypeCount++] = cleanupEntityType;
}
var systemStateResidueArchetype = GetOrCreateArchetype(types, newTypeCount, entityComponentStore);
srcArchetype->SystemStateResidueArchetype = systemStateResidueArchetype;
Assert.IsTrue(systemStateResidueArchetype->SystemStateResidueArchetype == systemStateResidueArchetype);
Assert.IsTrue(systemStateResidueArchetype->InstantiableArchetype == null);
}
// Setup meta chunk archetype
if (count > 1)
{
types[0] = new ComponentTypeInArchetype(typeof(Entity));
int metaArchetypeTypeCount = 1;
for (int i = 1; i < count; ++i)
{
var t = inTypesSorted[i];
ComponentType typeToInsert;
if (inTypesSorted[i].IsChunkComponent)
{
typeToInsert = new ComponentType
{
TypeIndex = TypeManager.ChunkComponentToNormalTypeIndex(t.TypeIndex)
};
SortingUtilities.InsertSorted(types, metaArchetypeTypeCount++, typeToInsert);
}
}
if (metaArchetypeTypeCount > 1)
{
SortingUtilities.InsertSorted(types, metaArchetypeTypeCount++, new ComponentType(typeof(ChunkHeader)));
srcArchetype->MetaChunkArchetype = GetOrCreateArchetype(types, metaArchetypeTypeCount, entityComponentStore);
}
}
return(srcArchetype);
}
internal BufferFromEntity <T> GetBufferFromEntity <T>(bool isReadOnly = false)
where T : struct, IBufferElementData
{
return(GetBufferFromEntity <T>(TypeManager.GetTypeIndex <T>(), isReadOnly));
}
public static ComponentType ChunkComponentReadOnly <T>()
{
var typeIndex = TypeManager.MakeChunkComponentTypeIndex(TypeManager.GetTypeIndex <T>());
return(ReadOnly(typeIndex));
}
