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; }