internal static unsafe bool CompareArray(ComponentType *type1, int typeCount1, ComponentType *type2, int typeCount2)
{
bool flag2;
if (typeCount1 != typeCount2)
{
flag2 = false;
}
else
{
int index = 0;
while (true)
{
if (index >= typeCount1)
{
flag2 = true;
}
else
{
if (!(type1[index] != type2[index]))
{
index++;
continue;
}
flag2 = false;
}
break;
}
}
return(flag2);
}
public static bool CompareComponents(ComponentType *componentTypes, int componentTypesCount, EntityGroupData *groupData)
{
if (groupData->RequiredComponents == null)
{
return(false);
}
#if ENABLE_UNITY_COLLECTIONS_CHECKS
for (var k = 0; k < componentTypesCount; ++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
if (componentTypesCount + 1 != groupData->RequiredComponentsCount)
{
return(false);
}
for (var i = 0; i < componentTypesCount; ++i)
{
if (groupData->RequiredComponents[i + 1] != componentTypes[i])
{
return(false);
}
}
return(true);
}
bool TestMatchingArchetypeAny(Archetype *archetype, ComponentType *anyTypes, int anyCount)
{
if (anyCount == 0)
{
return(true);
}
var componentTypes = archetype->Types;
var componentTypesCount = archetype->TypesCount;
for (var i = 0; i < componentTypesCount; i++)
{
var componentTypeIndex = componentTypes[i].TypeIndex;
for (var j = 0; j < anyCount; j++)
{
var anyTypeIndex = anyTypes[j].TypeIndex;
if (componentTypeIndex == anyTypeIndex)
{
return(true);
}
}
}
return(false);
}
public static bool CompareComponents(ComponentType *componentTypes, int componentTypesCount, EntityQueryData *queryData)
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
for (var k = 0; k < componentTypesCount; ++k)
{
if (componentTypes[k].TypeIndex == TypeManager.GetTypeIndex <Entity>())
{
throw new ArgumentException(
"EntityQuery.CompareComponents may not include typeof(Entity), it is implicit");
}
}
#endif
var sortedTypes = stackalloc ComponentType[componentTypesCount];
for (var i = 0; i < componentTypesCount; ++i)
{
SortingUtilities.InsertSorted(sortedTypes, i, componentTypes[i]);
}
// EntityQueries are constructed including the Entity ID
if (componentTypesCount + 1 != queryData->RequiredComponentsCount)
{
return(false);
}
for (var i = 0; i < componentTypesCount; ++i)
{
if (queryData->RequiredComponents[i + 1] != sortedTypes[i])
{
return(false);
}
}
return(true);
}
// ----------------------------------------------------------------------------------------------------------
// INTERNAL
// ----------------------------------------------------------------------------------------------------------
internal EntityArchetype CreateArchetype(ComponentType *types, int count)
{
ComponentTypeInArchetype *typesInArchetype = stackalloc ComponentTypeInArchetype[count + 1];
var cachedComponentCount = FillSortedArchetypeArray(typesInArchetype, types, count);
// Lookup existing archetype (cheap)
EntityArchetype entityArchetype;
entityArchetype.Archetype =
EntityComponentStore->GetExistingArchetype(typesInArchetype, cachedComponentCount);
if (entityArchetype.Archetype != null)
{
return(entityArchetype);
}
// Creating an archetype invalidates all iterators / jobs etc
// because it affects the live iteration linked lists...
BeforeStructuralChange();
var archetypeChanges = EntityComponentStore->BeginArchetypeChangeTracking();
entityArchetype.Archetype = EntityComponentStore->GetOrCreateArchetype(typesInArchetype,
cachedComponentCount);
var changedArchetypes = EntityComponentStore->EndArchetypeChangeTracking(archetypeChanges);
EntityQueryManager.AddAdditionalArchetypes(changedArchetypes);
return(entityArchetype);
}
internal ComponentGroup GetComponentGroupInternal(ComponentType *componentTypes, int count)
{
for (var i = 0; i != m_ComponentGroups.Length; i++)
{
if (m_ComponentGroups[i].CompareComponents(componentTypes, count))
{
return(m_ComponentGroups[i]);
}
}
var group = EntityManager.CreateComponentGroup(componentTypes, count);
group.SetFilterChangedRequiredVersion(m_LastSystemVersion);
#if ENABLE_UNITY_COLLECTIONS_CHECKS
group.DisallowDisposing = "ComponentGroup.Dispose() may not be called on a ComponentGroup created with ComponentSystem.GetComponentGroup. The ComponentGroup will automatically be disposed by the ComponentSystem.";
#endif
ArrayUtilityAdd(ref m_ComponentGroups, group);
for (int i = 0; i != count; i++)
{
AddReaderWriter(componentTypes[i]);
}
//@TODO: Shouldn't this sync fence on the newly depent types?
return(group);
}
protected override void OnDestroyManager()
{
EndExclusiveEntityTransaction();
ComponentJobSafetyManager.PreDisposeCheck();
// Clean up all entities. This is needed to free all internal buffer allocations so memory is not leaked.
using (var allEntities = GetAllEntities())
{
DestroyEntity(allEntities);
}
ComponentJobSafetyManager.Dispose();
ComponentJobSafetyManager = null;
Entities->OnDestroy();
UnsafeUtility.Free(Entities, Allocator.Persistent);
Entities = null;
ArchetypeManager.Dispose();
ArchetypeManager = null;
m_GroupManager.Dispose();
m_GroupManager = null;
m_ExclusiveEntityTransaction.OnDestroyManager();
m_SharedComponentManager.Dispose();
UnsafeUtility.Free(m_CachedComponentTypeArray, Allocator.Persistent);
m_CachedComponentTypeArray = null;
UnsafeUtility.Free(m_CachedComponentTypeInArchetypeArray, Allocator.Persistent);
m_CachedComponentTypeInArchetypeArray = null;
}
internal EntityArchetype CreateArchetype(ComponentType *types, int count)
{
ComponentTypeInArchetype *typesInArchetype = stackalloc ComponentTypeInArchetype[count + 1];
var cachedComponentCount = FillSortedArchetypeArray(typesInArchetype, types, count);
// Lookup existing archetype (cheap)
EntityArchetype entityArchetype;
#if ENABLE_UNITY_COLLECTIONS_CHECKS
entityArchetype._DebugComponentStore = EntityComponentStore;
#endif
entityArchetype.Archetype = EntityComponentStore->GetExistingArchetype(typesInArchetype, cachedComponentCount);
if (entityArchetype.Archetype != null)
{
return(entityArchetype);
}
// Creating an archetype invalidates all iterators / jobs etc
// because it affects the live iteration linked lists...
EntityComponentStore.ArchetypeChanges archetypeChanges = default;
if (m_IsMainThread)
{
BeforeStructuralChange();
}
archetypeChanges = EntityComponentStore->BeginArchetypeChangeTracking();
entityArchetype.Archetype = EntityComponentStore->GetOrCreateArchetype(typesInArchetype, cachedComponentCount);
EntityComponentStore->EndArchetypeChangeTracking(archetypeChanges, EntityQueryManager);
return(entityArchetype);
}
unsafe public static Entity Instantiate(this EntityManager entityManager, GameObject srcGameObject)
{
if (entityManager.m_CachedComponentList == null)
{
entityManager.m_CachedComponentList = new List <ComponentDataWrapperBase>();
}
var components = (List <ComponentDataWrapperBase>)entityManager.m_CachedComponentList;
srcGameObject.GetComponents(components);
var count = components.Count;
ComponentType *componentTypes = stackalloc ComponentType[count];
for (var t = 0; t != count; ++t)
{
componentTypes[t] = components[t].GetComponentType();
}
var srcEntity = entityManager.CreateEntity(entityManager.CreateArchetype(componentTypes, count));
for (var t = 0; t != count; ++t)
{
components[t].UpdateComponentData(entityManager, srcEntity);
}
return(srcEntity);
}
public ComponentGroup CreateEntityGroup(ArchetypeManager typeMan, EntityDataManager *entityDataManager,
ArchetypeQuery *archetypeQueries, int archetypeFiltersCount, ComponentType *requiredComponents, int requiredComponentsCount)
{
//@TODO: Validate that required types is subset of archetype filters all...
var grp = (EntityGroupData *)m_GroupDataChunkAllocator.Allocate(sizeof(EntityGroupData), 8);
grp->PrevGroup = m_LastGroupData;
m_LastGroupData = grp;
grp->RequiredComponentsCount = requiredComponentsCount;
grp->RequiredComponents = requiredComponents;
InitializeReaderWriter(grp, requiredComponents, requiredComponentsCount);
grp->ArchetypeQuery = archetypeQueries;
grp->ArchetypeQueryCount = archetypeFiltersCount;
grp->FirstMatchingArchetype = null;
grp->LastMatchingArchetype = null;
for (var i = typeMan.m_Archetypes.Count - 1; i >= 0; --i)
{
var archetype = typeMan.m_Archetypes.p[i];
AddArchetypeIfMatching(archetype, grp);
}
return(new ComponentGroup(grp, m_JobSafetyManager, typeMan, entityDataManager));
}
public EntityQuery CreateEntityQuery(EntityComponentStore *entityComponentStore, ManagedComponentStore managedComponentStore,
ArchetypeQuery *query, int queryCount, ComponentType *component, int componentCount)
{
//@TODO: Validate that required types is subset of archetype filters all...
int hash = (int)math.hash(component, componentCount * sizeof(ComponentType));
for (var i = 0; i < queryCount; ++i)
{
hash = hash * 397 ^ query[i].GetHashCode();
}
EntityQueryData *cachedQuery = null;
if (m_EntityGroupDataCache.TryGetFirstValue(hash, out var entityGroupDataIndex, out var iterator))
{
do
{
var possibleMatch = m_EntityGroupDatas.Ptr[entityGroupDataIndex];
if (Matches(possibleMatch, query, queryCount, component, componentCount))
{
cachedQuery = possibleMatch;
break;
}
} while (m_EntityGroupDataCache.TryGetNextValue(out entityGroupDataIndex, ref iterator));
}
if (cachedQuery == null)
{
cachedQuery = (EntityQueryData *)ChunkAllocate <EntityQueryData>();
cachedQuery->RequiredComponentsCount = componentCount;
cachedQuery->RequiredComponents = (ComponentType *)ChunkAllocate <ComponentType>(componentCount, component);
InitializeReaderWriter(cachedQuery, component, componentCount);
cachedQuery->ArchetypeQueryCount = queryCount;
cachedQuery->ArchetypeQuery = (ArchetypeQuery *)ChunkAllocate <ArchetypeQuery>(queryCount, query);
for (var i = 0; i < queryCount; ++i)
{
cachedQuery->ArchetypeQuery[i].All = (int *)ChunkAllocate <int>(cachedQuery->ArchetypeQuery[i].AllCount, query[i].All);
cachedQuery->ArchetypeQuery[i].Any = (int *)ChunkAllocate <int>(cachedQuery->ArchetypeQuery[i].AnyCount, query[i].Any);
cachedQuery->ArchetypeQuery[i].None = (int *)ChunkAllocate <int>(cachedQuery->ArchetypeQuery[i].NoneCount, query[i].None);
cachedQuery->ArchetypeQuery[i].AllAccessMode = (byte *)ChunkAllocate <byte>(cachedQuery->ArchetypeQuery[i].AllCount, query[i].AllAccessMode);
cachedQuery->ArchetypeQuery[i].AnyAccessMode = (byte *)ChunkAllocate <byte>(cachedQuery->ArchetypeQuery[i].AnyCount, query[i].AnyAccessMode);
cachedQuery->ArchetypeQuery[i].NoneAccessMode = (byte *)ChunkAllocate <byte>(cachedQuery->ArchetypeQuery[i].NoneCount, query[i].NoneAccessMode);
}
cachedQuery->MatchingArchetypes = new UnsafeMatchingArchetypePtrList(entityComponentStore);
cachedQuery->EntityQueryMask = new EntityQueryMask();
for (var i = 0; i < entityComponentStore->m_Archetypes.Length; ++i)
{
var archetype = entityComponentStore->m_Archetypes.Ptr[i];
AddArchetypeIfMatching(archetype, cachedQuery);
}
m_EntityGroupDataCache.Add(hash, m_EntityGroupDatas.Length);
m_EntityGroupDatas.Add(cachedQuery);
}
return(new EntityQuery(cachedQuery, m_JobSafetyManager, entityComponentStore, managedComponentStore));
}
public static void Burst_Unity__Entities__EntityDataAccess_FillSortedArchetypeArray(IntPtr p)
{
ComponentTypeInArchetype *v0 = (ComponentTypeInArchetype *)((byte *)p + 0);
ComponentType * v1 = (ComponentType *)((byte *)p + 1024);
var v2 = default(int);
EntityDataAccess.FillSortedArchetypeArray(v0, v1, v2);
}
public static void Burst_Unity__Entities__EntityDataAccess_CreateArchetype(IntPtr p)
{
ComponentType *v0 = (ComponentType *)((byte *)p + 0);
var v1 = default(int);
var instance = (EntityDataAccess *)p;
instance->CreateArchetype(v0, v1);
}
public static unsafe void InsertSorted(ComponentType *data, int length, ComponentType newValue)
{
while (length > 0 && newValue < data[length - 1])
{
data[length] = data[length - 1];
--length;
}
data[length] = newValue;
}
private int PopulatedCachedTypeInArchetypeArray(ComponentType *requiredComponents, int count)
{
m_CachedComponentTypeInArchetypeArray[0] = new ComponentTypeInArchetype(ComponentType.Create <Entity>());
for (var i = 0; i < count; ++i)
{
SortingUtilities.InsertSorted(m_CachedComponentTypeInArchetypeArray, i + 1, requiredComponents[i]);
}
return(count + 1);
}
private unsafe bool TestMatchingArchetypeAll(Archetype *archetype, ComponentType *allTypes, int allCount)
{
ComponentTypeInArchetype *types = archetype.Types;
int typesCount = archetype.TypesCount;
int num2 = 0;
int typeIndex = TypeManager.GetTypeIndex <Disabled>();
int num4 = TypeManager.GetTypeIndex <Prefab>();
bool flag = false;
bool flag2 = false;
int index = 0;
while (true)
{
if (index >= typesCount)
{
bool flag9;
if (archetype.Disabled && !flag)
{
flag9 = false;
}
else if (archetype.Prefab && !flag2)
{
flag9 = false;
}
else
{
flag9 = num2 == allCount;
}
return(flag9);
}
int num6 = types[index].TypeIndex;
int num7 = 0;
while (true)
{
if (num7 >= allCount)
{
index++;
break;
}
int num8 = allTypes[num7].TypeIndex;
if (num8 == typeIndex)
{
flag = true;
}
if (num8 == num4)
{
flag2 = true;
}
if (num6 == num8)
{
num2++;
}
num7++;
}
}
}
public static bool CompareComponents(ComponentType *componentTypes, int componentTypesCount, EntityQueryData *queryData)
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
for (var k = 0; k < componentTypesCount; ++k)
{
if (componentTypes[k].TypeIndex == TypeManager.GetTypeIndex <Entity>())
{
throw new ArgumentException(
"EntityQuery.CompareComponents may not include typeof(Entity), it is implicit");
}
}
#endif
if ((queryData->ArchetypeQueryCount != 1) || // This code path only matches one archetypequery
(queryData->ArchetypeQuery[0].Options != EntityQueryOptions.Default)) // This code path does not allow query options
{
return(false);
}
var sortedTypes = stackalloc ComponentType[componentTypesCount];
for (var i = 0; i < componentTypesCount; ++i)
{
SortingUtilities.InsertSorted(sortedTypes, i, componentTypes[i]);
}
ConvertComponentListToSortedIntListsNoAlloc(sortedTypes, componentTypesCount, out var componentCompareQuery);
var includeCount = componentCompareQuery.includeTypeIndices.Length;
var excludeCount = componentCompareQuery.excludeTypeIndices.Length;
var archetypeQuery = queryData->ArchetypeQuery[0];
if ((includeCount != archetypeQuery.AllCount) ||
(excludeCount != archetypeQuery.NoneCount))
{
return(false);
}
for (int i = 0; i < includeCount; ++i)
{
if (componentCompareQuery.includeTypeIndices[i] != archetypeQuery.All[i] ||
componentCompareQuery.includeAccessModes[i] != archetypeQuery.AllAccessMode[i])
{
return(false);
}
}
for (int i = 0; i < excludeCount; ++i)
{
if (componentCompareQuery.excludeTypeIndices[i] != archetypeQuery.None[i] ||
componentCompareQuery.excludeAccessModes[i] != archetypeQuery.NoneAccessMode[i])
{
return(false);
}
}
return(true);
}
internal unsafe EntityArchetype CreateArchetype(ComponentType *types, int count)
{
EntityArchetype archetype;
this.CheckAccess();
EntityGroupManager target = (EntityGroupManager)this.m_EntityGroupManager.Target;
archetype.Archetype = this.ArchetypeManager.GetOrCreateArchetype(this.m_CachedComponentTypeInArchetypeArray, this.PopulatedCachedTypeInArchetypeArray(types, count), target);
return(archetype);
}
/// <summary>
/// Releases unmanaged and - optionally - managed resources
/// </summary>
/// <param name="disposing"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>
protected override void Dispose(bool disposing)
{
if (disposing && Native != null)
{
Native.Destruct();
_ctype = null;
}
base.Dispose(disposing);
}
internal EntityArchetype CreateArchetypeRaw(int *typeIndices, int count)
{
// TODO fix this up
ComponentType *ct = stackalloc ComponentType[count];
for (int i = 0; i < count; ++i)
{
ct[i] = ComponentType.FromTypeIndex(typeIndices[i]);
}
return(CreateArchetype(ct, count));
}
void CreateRequiredComponents(ComponentType *requiredComponents, int requiredComponentsCount, out ComponentType *types, out int typesCount)
{
types = (ComponentType *)m_GroupDataChunkAllocator.Allocate(sizeof(ComponentType) * (requiredComponentsCount + 1), UnsafeUtility.AlignOf <ComponentType>());
types[0] = ComponentType.Create <Entity>();
for (int i = 0; i != requiredComponentsCount; i++)
{
types[i + 1] = requiredComponents[i];
}
typesCount = requiredComponentsCount + 1;
}
private unsafe bool TestMatchingArchetypeAny(Archetype *archetype, ComponentType *anyTypes, int anyCount)
{
ComponentTypeInArchetype *types;
int typesCount;
int num2;
if (anyCount != 0)
{
types = archetype.Types;
typesCount = archetype.TypesCount;
num2 = 0;
}
else
{
return(true);
}
while (true)
{
while (true)
{
bool flag2;
if (num2 < typesCount)
{
int typeIndex = types[num2].TypeIndex;
int index = 0;
while (true)
{
if (index < anyCount)
{
int num5 = anyTypes[index].TypeIndex;
if (typeIndex != num5)
{
index++;
continue;
}
flag2 = true;
}
else
{
num2++;
continue;
}
break;
}
}
else
{
flag2 = false;
}
return(flag2);
}
}
}
void InitializeReaderWriter(EntityQueryData *grp, ComponentType *requiredTypes, int requiredCount)
{
Assert.IsTrue(requiredCount > 0);
Assert.IsTrue(requiredTypes[0] == ComponentType.ReadWrite <Entity>());
grp->ReaderTypesCount = 0;
grp->WriterTypesCount = 0;
for (var i = 1; i != requiredCount; i++)
{
// After the first zero sized component the rest are zero sized
if (requiredTypes[i].IsZeroSized)
{
break;
}
switch (requiredTypes[i].AccessModeType)
{
case ComponentType.AccessMode.ReadOnly:
grp->ReaderTypesCount++;
break;
default:
grp->WriterTypesCount++;
break;
}
}
grp->ReaderTypes = (int *)m_GroupDataChunkAllocator.Allocate(sizeof(int) * grp->ReaderTypesCount, 4);
grp->WriterTypes = (int *)m_GroupDataChunkAllocator.Allocate(sizeof(int) * grp->WriterTypesCount, 4);
var curReader = 0;
var curWriter = 0;
for (var i = 1; i != requiredCount; i++)
{
if (requiredTypes[i].IsZeroSized)
{
break;
}
switch (requiredTypes[i].AccessModeType)
{
case ComponentType.AccessMode.ReadOnly:
grp->ReaderTypes[curReader++] = requiredTypes[i].TypeIndex;
break;
default:
grp->WriterTypes[curWriter++] = requiredTypes[i].TypeIndex;
break;
}
}
}
internal EntityArchetype CreateArchetype(ComponentType *types, int count)
{
CheckAccess();
var groupManager = (EntityGroupManager)m_EntityGroupManager.Target;
EntityArchetype type;
type.Archetype = ArchetypeManager.GetOrCreateArchetype(m_CachedComponentTypeInArchetypeArray,
PopulatedCachedTypeInArchetypeArray(types, count), groupManager);
return(type);
}
private unsafe int PopulatedCachedTypeInArchetypeArray(ComponentType *requiredComponents, int count)
{
if ((count + 1) > 0x400)
{
throw new ArgumentException($"Archetypes can't hold more than {0x400}");
}
this.m_CachedComponentTypeInArchetypeArray[0] = new ComponentTypeInArchetype(ComponentType.Create <Entity>());
for (int i = 0; i < count; i++)
{
SortingUtilities.InsertSorted(this.m_CachedComponentTypeInArchetypeArray, i + 1, requiredComponents[i]);
}
return(count + 1);
}
internal EntityArchetype CreateArchetype(ComponentType *types, int count)
{
CheckAccess();
ComponentTypeInArchetype *typesInArchetype = stackalloc ComponentTypeInArchetype[count + 1];
var componentCount = EntityManager.FillSortedArchetypeArray(typesInArchetype, types, count);
EntityArchetype type;
type.Archetype = EntityManagerCreateArchetypeUtility.GetOrCreateArchetype(typesInArchetype, componentCount, EntityComponentStore);
return(type);
}
public static unsafe void InsertSorted(ComponentType *data, int length, ComponentType newValue)
{
while (true)
{
if ((length <= 0) || (newValue >= data[length - 1]))
{
data[length] = newValue;
return;
}
data[length] = data[length - 1];
length--;
}
}
public static unsafe bool GetComponents(this GameObject @this, ComponentType *componentTypes, int maxComponentTypes, List <Component> componentsCache)
{
int outputIndex = 0;
@this.GetComponents(componentsCache);
if (maxComponentTypes < componentsCache.Count)
{
LogWarning($"Too many components on {@this.name}", @this);
return(false);
}
for (var i = 0; i != componentsCache.Count; i++)
{
var component = componentsCache[i];
if (component == null)
{
LogWarning($"The referenced script is missing on {@this.name}", @this);
}
else if (!component.IsComponentDisabled() && !(component is GameObjectEntity))
{
#pragma warning disable 618 // remove once ComponentDataProxyBase is removed
var componentType =
(component as ComponentDataProxyBase)?.GetComponentType() ?? component.GetType();
#pragma warning restore 618
var isUniqueType = true;
for (var j = 0; j < outputIndex; ++j)
{
if (componentTypes[j].Equals(componentType))
{
isUniqueType = false;
break;
}
}
if (!isUniqueType)
{
continue;
}
componentsCache[outputIndex] = component;
componentTypes[outputIndex] = componentType;
outputIndex++;
}
}
componentsCache.RemoveRange(outputIndex, componentsCache.Count - outputIndex);
return(true);
}
public ComponentGroup CreateComponentGroup(ComponentType *requiredComponents, int count)
{
var typeArrayCount = PopulatedCachedTypeArray(requiredComponents, count);
var grp = m_GroupManager.CreateEntityGroupIfCached(m_ArchetypeManager, m_Entities, m_CachedComponentTypeArray, typeArrayCount);
if (grp != null)
{
return(grp);
}
BeforeStructuralChange();
return(m_GroupManager.CreateEntityGroup(m_ArchetypeManager, m_Entities, m_CachedComponentTypeArray, typeArrayCount));
}
public ComponentGroup CreateEntityGroupIfCached(ArchetypeManager typeMan, EntityDataManager *entityDataManager,
ComponentType *requiredTypes,
int requiredCount)
{
var hash = HashUtility.Fletcher32((ushort *)requiredTypes,
requiredCount * sizeof(ComponentType) / sizeof(short));
var grp = GetCachedGroupData(hash, requiredTypes, requiredCount);
if (grp != null)
{
return(new ComponentGroup(grp, m_JobSafetyManager, typeMan, entityDataManager));
}
return(null);
}
void InitializeReaderWriter(EntityGroupData *grp, ComponentType *requiredTypes, int requiredCount)
{
grp->ReaderTypesCount = 0;
grp->WriterTypesCount = 0;
for (var i = 0; i != requiredCount; i++)
{
//@TODO: Investigate why Entity is not early out on this one...
if (!requiredTypes[i].RequiresJobDependency)
{
continue;
}
switch (requiredTypes[i].AccessModeType)
{
case ComponentType.AccessMode.ReadOnly:
grp->ReaderTypesCount++;
break;
default:
grp->WriterTypesCount++;
break;
}
}
grp->ReaderTypes = (int *)m_GroupDataChunkAllocator.Allocate(sizeof(int) * grp->ReaderTypesCount, 4);
grp->WriterTypes = (int *)m_GroupDataChunkAllocator.Allocate(sizeof(int) * grp->WriterTypesCount, 4);
var curReader = 0;
var curWriter = 0;
for (var i = 0; i != requiredCount; i++)
{
if (!requiredTypes[i].RequiresJobDependency)
{
continue;
}
switch (requiredTypes[i].AccessModeType)
{
case ComponentType.AccessMode.ReadOnly:
grp->ReaderTypes[curReader++] = requiredTypes[i].TypeIndex;
break;
default:
grp->WriterTypes[curWriter++] = requiredTypes[i].TypeIndex;
break;
}
}
}
/// <summary>
/// Initializes the specified descriptor.
/// </summary>
/// <param name="descriptor">The descriptor.</param>
protected void Initialize(ComponentDescriptor descriptor)
{
_ctype = descriptor.Ctype;
}
