public static bool CompareQuery(EntityArchetypeQuery[] query, EntityGroupData *groupData)
{
if (groupData->RequiredComponents != null)
{
return(false);
}
if (groupData->ArchetypeQueryCount != query.Length)
{
return(false);
}
for (int i = 0; i != query.Length; i++)
{
if (!CompareQueryArray(query[i].All, groupData->ArchetypeQuery[i].All, groupData->ArchetypeQuery[i].AllCount))
{
return(false);
}
if (!CompareQueryArray(query[i].None, groupData->ArchetypeQuery[i].None, groupData->ArchetypeQuery[i].NoneCount))
{
return(false);
}
if (!CompareQueryArray(query[i].Any, groupData->ArchetypeQuery[i].Any, groupData->ArchetypeQuery[i].AnyCount))
{
return(false);
}
}
return(true);
}
private unsafe void AddArchetypeIfMatching(Archetype *archetype, EntityGroupData *group)
{
if (IsMatchingArchetype(archetype, group))
{
MatchingArchetypes *archetypesPtr = (MatchingArchetypes *)ref this.m_GroupDataChunkAllocator.Allocate(MatchingArchetypes.GetAllocationSize(group.RequiredComponentsCount), 8);
archetypesPtr->Archetype = archetype;
int *numPtr = &archetypesPtr->IndexInArchetype.FixedElementField;
if (group.LastMatchingArchetype == null)
{
group.LastMatchingArchetype = archetypesPtr;
}
archetypesPtr->Next = group.FirstMatchingArchetype;
group.FirstMatchingArchetype = archetypesPtr;
int index = 0;
while (true)
{
if (index >= group.RequiredComponentsCount)
{
break;
}
int actual = -1;
if (group.RequiredComponents[index].AccessModeType != ComponentType.AccessMode.Subtractive)
{
actual = ChunkDataUtility.GetIndexInTypeArray(archetype, group.RequiredComponents[index].TypeIndex);
Assert.AreNotEqual(-1, actual);
}
numPtr[index] = actual;
index++;
}
}
}
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 unsafe void AddArchetypeIfMatching(Archetype *type)
{
for (EntityGroupData *dataPtr = this.m_LastGroupData; dataPtr != null; dataPtr = dataPtr->PrevGroup)
{
this.AddArchetypeIfMatching(type, dataPtr);
}
}
void AddArchetypeIfMatching(Archetype *archetype, EntityGroupData *group)
{
if (!IsMatchingArchetype(archetype, group))
{
return;
}
var match = (MatchingArchetypes *)m_GroupDataChunkAllocator.Allocate(
MatchingArchetypes.GetAllocationSize(group->RequiredComponentsCount), 8);
match->Archetype = archetype;
var typeIndexInArchetypeArray = match->IndexInArchetype;
if (group->LastMatchingArchetype == null)
{
group->LastMatchingArchetype = match;
}
match->Next = group->FirstMatchingArchetype;
group->FirstMatchingArchetype = match;
for (var component = 0; component < group->RequiredComponentsCount; ++component)
{
var typeComponentIndex = -1;
if (group->RequiredComponents[component].AccessModeType != ComponentType.AccessMode.Subtractive)
{
typeComponentIndex = ChunkDataUtility.GetIndexInTypeArray(archetype, group->RequiredComponents[component].TypeIndex);
Assert.AreNotEqual(-1, typeComponentIndex);
}
typeIndexInArchetypeArray[component] = typeComponentIndex;
}
}
internal ComponentGroup(EntityGroupData *groupData, ComponentJobSafetyManager safetyManager, ArchetypeManager typeManager, EntityDataManager *entityDataManager)
{
m_ComponentGroupData = new ComponentGroupData(groupData, entityDataManager);
m_SafetyManager = safetyManager;
m_TypeManager = typeManager;
m_EntityDataManager = entityDataManager;
}
public static bool CompareComponents(ComponentType[] componentTypes, EntityGroupData *groupData)
{
if (groupData->RequiredComponents == null)
{
return(false);
}
#if ENABLE_UNITY_COLLECTIONS_CHECKS
for (var k = 0; k < componentTypes.Length; ++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 (componentTypes.Length + 1 != groupData->RequiredComponentsCount)
{
return(false);
}
for (var i = 0; i < componentTypes.Length; ++i)
{
if (groupData->RequiredComponents[i + 1] != componentTypes[i])
{
return(false);
}
}
return(true);
}
internal EntityQuery(EntityGroupData *groupData, ComponentJobSafetyManager *safetyManager, EntityComponentStore *entityComponentStore, ManagedComponentStore managedComponentStore)
{
m_GroupData = groupData;
m_Filter = default(EntityQueryFilter);
m_SafetyManager = safetyManager;
m_EntityComponentStore = entityComponentStore;
m_ManagedComponentStore = managedComponentStore;
}
internal ComponentGroup(EntityGroupData *groupData, ComponentJobSafetyManager safetyManager, ArchetypeManager typeManager, EntityDataManager *entityDataManager)
{
m_GroupData = groupData;
m_EntityDataManager = entityDataManager;
m_Filter = default(ComponentGroupFilter);
m_SafetyManager = safetyManager;
ArchetypeManager = typeManager;
EntityDataManager = entityDataManager;
}
//@TODO: All this could be much faster by having all ComponentType pre-sorted to perform a single search loop instead two nested for loops...
static bool IsMatchingArchetype(Archetype *archetype, EntityGroupData *group)
{
for (int i = 0; i != group->ArchetypeQueryCount; i++)
{
if (IsMatchingArchetype(archetype, group->ArchetypeQuery + i))
{
return(true);
}
}
return(false);
}
public ComponentGroup CreateEntityGroupIfCached(ArchetypeManager typeMan, EntityDataManager *entityDataManager, ComponentType *requiredTypes,
int requiredCount)
{
var hash = HashUtility.Fletcher32((ushort *)requiredTypes,
requiredCount * sizeof(ComponentType) / sizeof(short));
EntityGroupData *grp = GetCachedGroupData(hash, requiredTypes, requiredCount);
if (grp != null)
{
return(new ComponentGroup(grp, m_JobSafetyManager, typeMan, entityDataManager));
}
return(null);
}
public static unsafe bool CompareComponents(ComponentType[] componentTypes, EntityGroupData *groupData)
{
bool flag2;
if (groupData.RequiredComponents == null)
{
flag2 = false;
}
else
{
int index = 0;
while (true)
{
if (index >= componentTypes.Length)
{
if ((componentTypes.Length + 1) != groupData.RequiredComponentsCount)
{
flag2 = false;
}
else
{
int num2 = 0;
while (true)
{
if (num2 >= componentTypes.Length)
{
flag2 = true;
}
else
{
if (!(groupData.RequiredComponents[num2 + 1] != componentTypes[num2]))
{
num2++;
continue;
}
flag2 = false;
}
break;
}
}
break;
}
if (componentTypes[index].TypeIndex == TypeManager.GetTypeIndex <Entity>())
{
throw new ArgumentException("ComponentGroup.CompareComponents may not include typeof(Entity), it is implicit");
}
index++;
}
}
return(flag2);
}
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;
}
}
}
private unsafe void InitializeReaderWriter(EntityGroupData *grp, ComponentType *requiredTypes, int requiredCount)
{
grp.ReaderTypesCount = 0;
grp.WriterTypesCount = 0;
int index = 0;
while (true)
{
if (index == requiredCount)
{
grp.ReaderTypes = (int *)this.m_GroupDataChunkAllocator.Allocate(4 * grp.ReaderTypesCount, 4);
grp.WriterTypes = (int *)this.m_GroupDataChunkAllocator.Allocate(4 * grp.WriterTypesCount, 4);
int num = 0;
int num2 = 0;
for (int i = 0; i != requiredCount; i++)
{
if ((requiredTypes + i).RequiresJobDependency)
{
if (requiredTypes[i].AccessModeType != ComponentType.AccessMode.ReadOnly)
{
num2++;
grp.WriterTypes[num2] = requiredTypes[i].TypeIndex;
}
else
{
num++;
grp.ReaderTypes[num] = requiredTypes[i].TypeIndex;
}
}
}
return;
}
if ((requiredTypes + index).RequiresJobDependency)
{
if (requiredTypes[index].AccessModeType != ComponentType.AccessMode.ReadOnly)
{
int *numPtr1 = (int *)ref grp.WriterTypesCount;
numPtr1[0]++;
}
else
{
int *numPtr2 = (int *)ref grp.ReaderTypesCount;
numPtr2[0]++;
}
}
index++;
}
}
public static unsafe bool CompareQuery(EntityArchetypeQuery[] query, EntityGroupData *groupData)
{
bool flag2;
if (groupData.RequiredComponents != null)
{
flag2 = false;
}
else if (groupData.ArchetypeQueryCount != query.Length)
{
flag2 = false;
}
else
{
int index = 0;
while (true)
{
if (index == query.Length)
{
flag2 = true;
}
else if (!CompareQueryArray(query[index].All, groupData.ArchetypeQuery[index].All, groupData.ArchetypeQuery[index].AllCount))
{
flag2 = false;
}
else if (!CompareQueryArray(query[index].None, groupData.ArchetypeQuery[index].None, groupData.ArchetypeQuery[index].NoneCount))
{
flag2 = false;
}
else
{
if (CompareQueryArray(query[index].Any, groupData.ArchetypeQuery[index].Any, groupData.ArchetypeQuery[index].AnyCount))
{
index++;
continue;
}
flag2 = false;
}
break;
}
}
return(flag2);
}
public unsafe ComponentGroup CreateEntityGroup(ArchetypeManager typeMan, EntityDataManager *entityDataManager, ArchetypeQuery *archetypeQueries, int archetypeFiltersCount, ComponentType *requiredComponents, int requiredComponentsCount)
{
EntityGroupData *grp = (EntityGroupData *)ref this.m_GroupDataChunkAllocator.Allocate(sizeof(EntityGroupData), 8);
grp->PrevGroup = this.m_LastGroupData;
this.m_LastGroupData = grp;
grp->RequiredComponentsCount = requiredComponentsCount;
grp->RequiredComponents = requiredComponents;
this.InitializeReaderWriter(grp, requiredComponents, requiredComponentsCount);
grp->ArchetypeQuery = archetypeQueries;
grp->ArchetypeQueryCount = archetypeFiltersCount;
grp->FirstMatchingArchetype = null;
grp->LastMatchingArchetype = null;
for (Archetype *archetypePtr = typeMan.m_LastArchetype; archetypePtr != null; archetypePtr = archetypePtr->PrevArchetype)
{
this.AddArchetypeIfMatching(archetypePtr, grp);
}
return(new ComponentGroup(grp, this.m_JobSafetyManager, typeMan, entityDataManager));
}
private static unsafe bool IsMatchingArchetype(Archetype *archetype, EntityGroupData *group)
{
int num = 0;
while (true)
{
bool flag2;
if (num == group.ArchetypeQueryCount)
{
flag2 = false;
}
else
{
if (!IsMatchingArchetype(archetype, group.ArchetypeQuery + num))
{
num++;
continue;
}
flag2 = true;
}
return(flag2);
}
}
internal ComponentGroupData(EntityGroupData *groupData, EntityDataManager *entityDataManager)
{
m_GroupData = groupData;
m_EntityDataManager = entityDataManager;
m_Filter = default(ComponentGroupFilter);
}
private void AddArchetypeIfMatching(Archetype *archetype, EntityGroupData *group)
{
// If the group has more actually required types than the archetype it can never match, so early out as an optimization
if (group->RequiredComponentsCount - group->SubtractiveComponentsCount > archetype->TypesCount)
{
return;
}
var typeI = 0;
var prevTypeI = 0;
var disabledIndex = TypeManager.GetTypeIndex <Disabled>();
var requestedDisabled = false;
for (var i = 0; i < group->RequiredComponentsCount; ++i, ++typeI)
{
while (archetype->Types[typeI].TypeIndex < group->RequiredComponents[i].TypeIndex &&
typeI < archetype->TypesCount)
{
++typeI;
}
if (group->RequiredComponents[i].TypeIndex == disabledIndex)
{
requestedDisabled = true;
}
var hasComponent = !(typeI >= archetype->TypesCount);
// Type mismatch
if (hasComponent && archetype->Types[typeI].TypeIndex != group->RequiredComponents[i].TypeIndex)
{
hasComponent = false;
}
if (hasComponent && group->RequiredComponents[i].AccessModeType == ComponentType.AccessMode.Subtractive)
{
return;
}
if (!hasComponent &&
group->RequiredComponents[i].AccessModeType != ComponentType.AccessMode.Subtractive)
{
return;
}
if (hasComponent)
{
prevTypeI = typeI;
}
else
{
typeI = prevTypeI;
}
}
if (archetype->Disabled && (!requestedDisabled))
{
return;
}
var match = (MatchingArchetypes *)m_GroupDataChunkAllocator.Allocate(
MatchingArchetypes.GetAllocationSize(group->RequiredComponentsCount), 8);
match->Archetype = archetype;
var typeIndexInArchetypeArray = match->TypeIndexInArchetypeArray;
if (group->LastMatchingArchetype == null)
{
group->LastMatchingArchetype = match;
}
match->Next = group->FirstMatchingArchetype;
group->FirstMatchingArchetype = match;
for (var component = 0; component < group->RequiredComponentsCount; ++component)
{
var typeComponentIndex = -1;
if (group->RequiredComponents[component].AccessModeType != ComponentType.AccessMode.Subtractive)
{
typeComponentIndex =
ChunkDataUtility.GetIndexInTypeArray(archetype, group->RequiredComponents[component].TypeIndex);
Assert.AreNotEqual(-1, typeComponentIndex);
}
typeIndexInArchetypeArray[component] = typeComponentIndex;
}
}
public ComponentGroup CreateEntityGroup(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));
}
m_JobSafetyManager.CompleteAllJobsAndInvalidateArrays();
grp = (EntityGroupData *)m_GroupDataChunkAllocator.Allocate(sizeof(EntityGroupData), 8);
grp->PrevGroup = m_LastGroupData;
m_LastGroupData = grp;
grp->RequiredComponentsCount = requiredCount;
grp->RequiredComponents =
(ComponentType *)m_GroupDataChunkAllocator.Construct(sizeof(ComponentType) * requiredCount, 4,
requiredTypes);
grp->ReaderTypesCount = 0;
grp->WriterTypesCount = 0;
grp->SubtractiveComponentsCount = 0;
for (var i = 0; i != requiredCount; i++)
{
if (requiredTypes[i].AccessModeType == ComponentType.AccessMode.Subtractive)
{
grp->SubtractiveComponentsCount++;
}
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;
}
}
grp->RequiredComponents =
(ComponentType *)m_GroupDataChunkAllocator.Construct(sizeof(ComponentType) * requiredCount, 4,
requiredTypes);
grp->FirstMatchingArchetype = null;
grp->LastMatchingArchetype = null;
for (var type = typeMan.m_LastArchetype; type != null; type = type->PrevArchetype)
{
AddArchetypeIfMatching(type, grp);
}
m_GroupLookup.Add(hash, (IntPtr)grp);
return(new ComponentGroup(grp, m_JobSafetyManager, typeMan, entityDataManager));
}
internal ComponentGroupData(ComponentGroupData parentGroupData, int *filteredSharedComponents)
{
m_GroupData = parentGroupData.m_GroupData;
m_EntityDataManager = parentGroupData.m_EntityDataManager;
m_FilteredSharedComponents = filteredSharedComponents;
}
internal ComponentGroupData(EntityGroupData *groupData, EntityDataManager *entityDataManager)
{
m_GroupData = groupData;
m_EntityDataManager = entityDataManager;
m_FilteredSharedComponents = null;
}
