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)); }
private unsafe ArchetypeQuery *CreateQuery(EntityArchetypeQuery[] query) { ArchetypeQuery *queryPtr = (ArchetypeQuery *)this.m_GroupDataChunkAllocator.Allocate(sizeof(ArchetypeQuery) * query.Length, UnsafeUtility.AlignOf <ArchetypeQuery>()); for (int i = 0; i != query.Length; i++) { this.ConstructTypeArray(query[i].None, out queryPtr[i].None, out queryPtr[i].NoneCount); this.ConstructTypeArray(query[i].All, out queryPtr[i].All, out queryPtr[i].AllCount); this.ConstructTypeArray(query[i].Any, out queryPtr[i].Any, out queryPtr[i].AnyCount); } return(queryPtr); }
static bool IsMatchingArchetype(Archetype *archetype, ArchetypeQuery *query) { if (!TestMatchingArchetypeAll(archetype, query->All, query->AllCount, query->Options)) { return(false); } if (!TestMatchingArchetypeNone(archetype, query->None, query->NoneCount)) { return(false); } if (!TestMatchingArchetypeAny(archetype, query->Any, query->AnyCount)) { return(false); } return(true); }
private unsafe ArchetypeQuery *CreateQuery(ComponentType[] requiredTypes) { ArchetypeQuery *queryPtr = (ArchetypeQuery *)ref this.m_GroupDataChunkAllocator.Allocate(sizeof(ArchetypeQuery), UnsafeUtility.AlignOf <ArchetypeQuery>()); int index = 0; int num2 = 0; int num3 = 0; while (true) { if (num3 == requiredTypes.Length) { queryPtr->All = (int *)this.m_GroupDataChunkAllocator.Allocate(4 * num2, UnsafeUtility.AlignOf <int>()); queryPtr->AllCount = num2; queryPtr->None = (int *)this.m_GroupDataChunkAllocator.Allocate(4 * index, UnsafeUtility.AlignOf <int>()); queryPtr->NoneCount = index; queryPtr->Any = null; queryPtr->AnyCount = 0; index = 0; num2 = 0; for (int i = 0; i != requiredTypes.Length; i++) { if (requiredTypes[i].AccessModeType == ComponentType.AccessMode.Subtractive) { index++; queryPtr->None[index] = requiredTypes[i].TypeIndex; } else { num2++; queryPtr->All[num2] = requiredTypes[i].TypeIndex; } } return(queryPtr); } if (requiredTypes[num3].AccessModeType == ComponentType.AccessMode.Subtractive) { index++; } else { num2++; } num3++; } }
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, ArchetypeQuery *query) { bool flag2; if (!TestMatchingArchetypeAll(archetype, query.All, query.AllCount)) { flag2 = false; } else if (!TestMatchingArchetypeNone(archetype, query.None, query.NoneCount)) { flag2 = false; } else if (!TestMatchingArchetypeAny(archetype, query.Any, query.AnyCount)) { flag2 = false; } else { flag2 = true; } return(flag2); }
bool Matches(EntityQueryData *grp, ArchetypeQuery *archetypeQueries, int archetypeFiltersCount, ComponentType *requiredComponents, int requiredComponentsCount) { if (requiredComponentsCount != grp->RequiredComponentsCount) { return(false); } if (archetypeFiltersCount != grp->ArchetypeQueryCount) { return(false); } if (requiredComponentsCount > 0 && UnsafeUtility.MemCmp(requiredComponents, grp->RequiredComponents, sizeof(ComponentType) * requiredComponentsCount) != 0) { return(false); } for (var i = 0; i < archetypeFiltersCount; ++i) { if (!archetypeQueries[i].Equals(grp->ArchetypeQuery[i])) { return(false); } } return(true); }
// Calculates the intersection of "All" queriesDesc private ComponentType *CalculateRequiredComponentsFromQuery(ref UnsafeScratchAllocator allocator, ArchetypeQuery *queries, int queryCount, out int outRequiredComponentsCount) { var maxIntersectionCount = 0; for (int queryIndex = 0; queryIndex < queryCount; ++queryIndex) { maxIntersectionCount = math.max(maxIntersectionCount, queries[queryIndex].AllCount); } var intersection = (int *)allocator.Allocate <int>(maxIntersectionCount); UnsafeUtility.MemCpy(intersection, queries[0].All, sizeof(int) * queries[0].AllCount); var intersectionCount = maxIntersectionCount; for (int i = 1; i < queryCount; ++i) { intersectionCount = IntersectSortedComponentIndexArrays(intersection, intersectionCount, queries[i].All, queries[i].AllCount, intersection); } var outRequiredComponents = (ComponentType *)allocator.Allocate <ComponentType>(intersectionCount + 1); outRequiredComponents[0] = ComponentType.ReadWrite <Entity>(); for (int i = 0; i < intersectionCount; ++i) { outRequiredComponents[i + 1] = ComponentType.FromTypeIndex(intersection[i]); } outRequiredComponentsCount = intersectionCount + 1; return(outRequiredComponents); }