public bool DidChange <T>(ArchetypeChunkSharedComponentType <T> chunkSharedComponentData, uint version) where T : struct, ISharedComponentData { return(ChangeVersionUtility.DidChange(GetComponentVersion(chunkSharedComponentData), version)); }
public void IncrementGlobalSystemVersion() { ChangeVersionUtility.IncrementGlobalSystemVersion(ref GlobalSystemVersion); }
/// <summary> /// Total number of entities contained in a given MatchingArchetype list. /// </summary> /// <param name="matchingArchetypes">List of matching archetypes.</param> /// <param name="filter">ComponentGroupFilter to use when calculating total number of entities.</param> /// <returns>Number of entities</returns> public static int CalculateLength(MatchingArchetypeList matchingArchetypes, ref ComponentGroupFilter filter) { var filterCopy = filter; // Necessary to avoid a nasty compiler error cause by fixed buffer types var length = 0; if (!filter.RequiresMatchesFilter) { for (var m = matchingArchetypes.Count - 1; m >= 0; --m) { var match = matchingArchetypes.p[m]; length += match->Archetype->EntityCount; } } else { for (var m = matchingArchetypes.Count - 1; m >= 0; --m) { var match = matchingArchetypes.p[m]; if (match->Archetype->EntityCount <= 0) { continue; } int filteredCount = 0; var archetype = match->Archetype; int chunkCount = archetype->Chunks.Count; var chunkEntityCountArray = archetype->Chunks.GetChunkEntityCountArray(); if (filter.Type == FilterType.SharedComponent) { var indexInComponentGroup0 = filterCopy.Shared.IndexInComponentGroup[0]; var sharedComponentIndex0 = filterCopy.Shared.SharedComponentIndex[0]; var componentIndexInChunk0 = match->IndexInArchetype[indexInComponentGroup0] - archetype->FirstSharedComponent; var sharedComponents0 = archetype->Chunks.GetSharedComponentValueArrayForType(componentIndexInChunk0); if (filter.Shared.Count == 1) { for (var i = 0; i < chunkCount; ++i) { if (sharedComponents0[i] == sharedComponentIndex0) { filteredCount += chunkEntityCountArray[i]; } } } else { var indexInComponentGroup1 = filterCopy.Shared.IndexInComponentGroup[1]; var sharedComponentIndex1 = filterCopy.Shared.SharedComponentIndex[1]; var componentIndexInChunk1 = match->IndexInArchetype[indexInComponentGroup1] - archetype->FirstSharedComponent; var sharedComponents1 = archetype->Chunks.GetSharedComponentValueArrayForType(componentIndexInChunk1); for (var i = 0; i < chunkCount; ++i) { if (sharedComponents0[i] == sharedComponentIndex0 && sharedComponents1[i] == sharedComponentIndex1) { filteredCount += chunkEntityCountArray[i]; } } } } else { var indexInComponentGroup0 = filterCopy.Changed.IndexInComponentGroup[0]; var componentIndexInChunk0 = match->IndexInArchetype[indexInComponentGroup0]; var changeVersions0 = archetype->Chunks.GetChangeVersionArrayForType(componentIndexInChunk0); var requiredVersion = filter.RequiredChangeVersion; if (filter.Changed.Count == 1) { for (var i = 0; i < chunkCount; ++i) { if (ChangeVersionUtility.DidChange(changeVersions0[i], requiredVersion)) { filteredCount += chunkEntityCountArray[i]; } } } else { var indexInComponentGroup1 = filterCopy.Changed.IndexInComponentGroup[1]; var componentIndexInChunk1 = match->IndexInArchetype[indexInComponentGroup1]; var changeVersions1 = archetype->Chunks.GetChangeVersionArrayForType(componentIndexInChunk1); for (var i = 0; i < chunkCount; ++i) { if (ChangeVersionUtility.DidChange(changeVersions0[i], requiredVersion) || ChangeVersionUtility.DidChange(changeVersions1[i], requiredVersion)) { filteredCount += chunkEntityCountArray[i]; } } } } length += filteredCount; } } return(length); }
/// <summary> /// Reports whether any of dynamic buffer components in the chunk, of the type identified by /// <paramref name="chunkBufferType"/>, could have changed. /// </summary> /// <remarks> /// Note that for efficiency, the change version applies to whole chunks not individual entities. The change /// version is incremented even when another job or system that has declared write access to a component does /// not actually change the component value.</remarks> /// <param name="chunkBufferType">An object containing type and job safety information. Create this /// object by calling <see cref="Unity.Entities.JobComponentSystem.GetArchetypeChunkBufferType{T}"/> immediately /// before scheduling a job. Pass the object to a job using a public field you define as part of the job struct.</param> /// <param name="version">The version to compare. In a system, this parameter should be set to the /// current <see cref="Unity.Entities.ComponentSystemBase.LastSystemVersion"/> at the time the job is run or /// scheduled.</param> /// <typeparam name="T">The data type of the elements in the dynamic buffer.</typeparam> /// <returns>True, if the version number stored in the chunk for this component is more recent than the version /// passed to the <paramref name="version"/> parameter.</returns> public bool DidChange <T>(ArchetypeChunkBufferType <T> chunkBufferType, uint version) where T : struct, IBufferElementData { return(ChangeVersionUtility.DidChange(GetComponentVersion(chunkBufferType), version)); }
public void Execute(int index) { var filter = Filter; int filteredCount = 0; var match = MatchingArchetypes[index]; var archetype = match->Archetype; int chunkCount = archetype->Chunks.Count; var writeIndex = Offsets[index]; var archetypeChunks = archetype->Chunks.p; if (filter.Type == FilterType.SharedComponent) { var indexInEntityQuery1 = filter.Shared.IndexInEntityQuery[0]; var sharedComponentIndex1 = filter.Shared.SharedComponentIndex[0]; var componentIndexInChunk1 = match->IndexInArchetype[indexInEntityQuery1] - archetype->FirstSharedComponent; var sharedComponents1 = archetype->Chunks.GetSharedComponentValueArrayForType(componentIndexInChunk1); if (filter.Shared.Count == 1) { for (var i = 0; i < chunkCount; ++i) { if (sharedComponents1[i] == sharedComponentIndex1) { SparseChunks[writeIndex + filteredCount++] = new ArchetypeChunk { m_Chunk = archetypeChunks[i] } } ; } } else { var indexInEntityQuery2 = filter.Shared.IndexInEntityQuery[1]; var sharedComponentIndex2 = filter.Shared.SharedComponentIndex[1]; var componentIndexInChunk2 = match->IndexInArchetype[indexInEntityQuery2] - archetype->FirstSharedComponent; var sharedComponents2 = archetype->Chunks.GetSharedComponentValueArrayForType(componentIndexInChunk2); for (var i = 0; i < chunkCount; ++i) { if (sharedComponents1[i] == sharedComponentIndex1 && sharedComponents2[i] == sharedComponentIndex2) { SparseChunks[writeIndex + filteredCount++] = new ArchetypeChunk { m_Chunk = archetypeChunks[i] } } ; } } } else { var indexInEntityQuery1 = filter.Changed.IndexInEntityQuery[0]; var componentIndexInChunk1 = match->IndexInArchetype[indexInEntityQuery1]; var changeVersions1 = archetype->Chunks.GetChangeVersionArrayForType(componentIndexInChunk1); var requiredVersion = filter.RequiredChangeVersion; if (filter.Changed.Count == 1) { for (var i = 0; i < chunkCount; ++i) { if (ChangeVersionUtility.DidChange(changeVersions1[i], requiredVersion)) { SparseChunks[writeIndex + filteredCount++] = new ArchetypeChunk { m_Chunk = archetypeChunks[i] } } ; } } else { var indexInEntityQuery2 = filter.Changed.IndexInEntityQuery[1]; var componentIndexInChunk2 = match->IndexInArchetype[indexInEntityQuery2]; var changeVersions2 = archetype->Chunks.GetChangeVersionArrayForType(componentIndexInChunk2); for (var i = 0; i < chunkCount; ++i) { if (ChangeVersionUtility.DidChange(changeVersions1[i], requiredVersion) || ChangeVersionUtility.DidChange(changeVersions2[i], requiredVersion)) { SparseChunks[writeIndex + filteredCount++] = new ArchetypeChunk { m_Chunk = archetypeChunks[i] } } ; } } } FilteredCounts[index] = filteredCount; } }
public void Execute() { var chunks = (ArchetypeChunk *)PrefilterData; var entityIndices = (int *)(chunks + UnfilteredChunkCount); var filter = Filter; var filteredChunkCount = 0; var filteredEntityOffset = 0; for (var m = Archetypes.Count - 1; m >= 0; --m) { var match = Archetypes.p[m]; if (match->Archetype->EntityCount <= 0) { continue; } var archetype = match->Archetype; int chunkCount = archetype->Chunks.Count; var chunkEntityCountArray = archetype->Chunks.GetChunkEntityCountArray(); if (filter.Type == FilterType.SharedComponent) { var indexInEntityQuery0 = filter.Shared.IndexInEntityQuery[0]; var sharedComponentIndex0 = filter.Shared.SharedComponentIndex[0]; var componentIndexInChunk0 = match->IndexInArchetype[indexInEntityQuery0] - archetype->FirstSharedComponent; var sharedComponents0 = archetype->Chunks.GetSharedComponentValueArrayForType(componentIndexInChunk0); if (filter.Shared.Count == 1) { for (var i = 0; i < chunkCount; ++i) { if (sharedComponents0[i] == sharedComponentIndex0) { chunks[filteredChunkCount] = new ArchetypeChunk { m_Chunk = archetype->Chunks.p[i] }; entityIndices[filteredChunkCount++] = filteredEntityOffset; filteredEntityOffset += chunkEntityCountArray[i]; } } } else { var indexInEntityQuery1 = filter.Shared.IndexInEntityQuery[1]; var sharedComponentIndex1 = filter.Shared.SharedComponentIndex[1]; var componentIndexInChunk1 = match->IndexInArchetype[indexInEntityQuery1] - archetype->FirstSharedComponent; var sharedComponents1 = archetype->Chunks.GetSharedComponentValueArrayForType(componentIndexInChunk1); for (var i = 0; i < chunkCount; ++i) { if (sharedComponents0[i] == sharedComponentIndex0 && sharedComponents1[i] == sharedComponentIndex1) { chunks[filteredChunkCount] = new ArchetypeChunk { m_Chunk = archetype->Chunks.p[i] }; entityIndices[filteredChunkCount++] = filteredEntityOffset; filteredEntityOffset += chunkEntityCountArray[i]; } } } } else { var indexInEntityQuery0 = filter.Changed.IndexInEntityQuery[0]; var componentIndexInChunk0 = match->IndexInArchetype[indexInEntityQuery0]; var changeVersions0 = archetype->Chunks.GetChangeVersionArrayForType(componentIndexInChunk0); var requiredVersion = filter.RequiredChangeVersion; if (filter.Changed.Count == 1) { for (var i = 0; i < chunkCount; ++i) { if (ChangeVersionUtility.DidChange(changeVersions0[i], requiredVersion)) { chunks[filteredChunkCount] = new ArchetypeChunk { m_Chunk = archetype->Chunks.p[i] }; entityIndices[filteredChunkCount++] = filteredEntityOffset; filteredEntityOffset += chunkEntityCountArray[i]; } } } else { var indexInEntityQuery1 = filter.Changed.IndexInEntityQuery[1]; var componentIndexInChunk1 = match->IndexInArchetype[indexInEntityQuery1]; var changeVersions1 = archetype->Chunks.GetChangeVersionArrayForType(componentIndexInChunk1); for (var i = 0; i < chunkCount; ++i) { if (ChangeVersionUtility.DidChange(changeVersions0[i], requiredVersion) || ChangeVersionUtility.DidChange(changeVersions1[i], requiredVersion)) { chunks[filteredChunkCount] = new ArchetypeChunk { m_Chunk = archetype->Chunks.p[i] }; entityIndices[filteredChunkCount++] = filteredEntityOffset; filteredEntityOffset += chunkEntityCountArray[i]; } } } } } UnsafeUtility.MemMove(chunks + filteredChunkCount, chunks + UnfilteredChunkCount, filteredChunkCount * sizeof(int)); var chunkCounter = entityIndices + UnfilteredChunkCount; *chunkCounter = filteredChunkCount; }
public bool DidChange <T>(ArchetypeChunkComponentType <T> chunkComponentType) where T : struct, IComponentData => ChangeVersionUtility.DidChange(this.GetComponentVersion <T>(chunkComponentType), chunkComponentType.GlobalSystemVersion);
public bool DidAddOrChange <T>(ArchetypeChunkComponentType <T> chunkComponentType, uint version) where T : struct, IComponentData => ChangeVersionUtility.DidAddOrChange(this.GetComponentVersion <T>(chunkComponentType), version);
/// <summary> /// Total number of chunks in a given MatchingArchetype list. /// </summary> /// <param name="matchingArchetypes">List of matching archetypes.</param> /// <returns>Number of chunks in a list of archetypes.</returns> internal static int CalculateChunkCount(UnsafeMatchingArchetypePtrList matchingArchetypes, ref EntityQueryFilter filter) { var totalChunkCount = 0; // If no filter, then fast path it if (!filter.RequiresMatchesFilter) { for (var m = matchingArchetypes.Length - 1; m >= 0; --m) { var match = matchingArchetypes.Ptr[m]; totalChunkCount += match->Archetype->Chunks.Count; } return(totalChunkCount); } // Otherwise do filtering for (var m = matchingArchetypes.Length - 1; m >= 0; --m) { var match = matchingArchetypes.Ptr[m]; var archetype = match->Archetype; int chunkCount = archetype->Chunks.Count; if (filter.Type == FilterType.SharedComponent) { var indexInEntityQuery1 = filter.Shared.IndexInEntityQuery[0]; var sharedComponentIndex1 = filter.Shared.SharedComponentIndex[0]; var componentIndexInChunk1 = match->IndexInArchetype[indexInEntityQuery1] - archetype->FirstSharedComponent; var sharedComponents1 = archetype->Chunks.GetSharedComponentValueArrayForType(componentIndexInChunk1); if (filter.Shared.Count == 1) { for (var i = 0; i < chunkCount; ++i) { if (sharedComponents1[i] == sharedComponentIndex1) { totalChunkCount++; } } } else { var indexInEntityQuery2 = filter.Shared.IndexInEntityQuery[1]; var sharedComponentIndex2 = filter.Shared.SharedComponentIndex[1]; var componentIndexInChunk2 = match->IndexInArchetype[indexInEntityQuery2] - archetype->FirstSharedComponent; var sharedComponents2 = archetype->Chunks.GetSharedComponentValueArrayForType(componentIndexInChunk2); for (var i = 0; i < chunkCount; ++i) { if (sharedComponents1[i] == sharedComponentIndex1 && sharedComponents2[i] == sharedComponentIndex2) { totalChunkCount++; } } } } else { var indexInEntityQuery1 = filter.Changed.IndexInEntityQuery[0]; var componentIndexInChunk1 = match->IndexInArchetype[indexInEntityQuery1]; var changeVersions1 = archetype->Chunks.GetChangeVersionArrayForType(componentIndexInChunk1); var requiredVersion = filter.RequiredChangeVersion; if (filter.Changed.Count == 1) { for (var i = 0; i < chunkCount; ++i) { if (ChangeVersionUtility.DidChange(changeVersions1[i], requiredVersion)) { totalChunkCount++; } } } else { var indexInEntityQuery2 = filter.Changed.IndexInEntityQuery[1]; var componentIndexInChunk2 = match->IndexInArchetype[indexInEntityQuery2]; var changeVersions2 = archetype->Chunks.GetChangeVersionArrayForType(componentIndexInChunk2); for (var i = 0; i < chunkCount; ++i) { if (ChangeVersionUtility.DidChange(changeVersions1[i], requiredVersion) || ChangeVersionUtility.DidChange(changeVersions2[i], requiredVersion)) { totalChunkCount++; } } } } } return(totalChunkCount); }