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