internal static unsafe JobHandle ScheduleInternal <T>(ref T jobData, ComponentGroup group, JobHandle dependsOn, ScheduleMode mode)
where T : struct, IJobChunk
{
ComponentChunkIterator iterator = group.GetComponentChunkIterator();
JobDataLiveFilter <T> fullData = new JobDataLiveFilter <T>
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
// All IJobChunk jobs have a safety handle for the Entity type to ensure that BeforeStructuralChange throws an error if
// jobs without any other safety handles are still running (haven't been synced).
safety = new EntitySafetyHandle {
m_Safety = group.SafetyManager.GetSafetyHandle(TypeManager.GetTypeIndex <Entity>(), true)
},
#endif
data = jobData,
iterator = iterator,
};
var totalChunks = group.CalculateNumberOfChunksWithoutFiltering();
var scheduleParams = new JobsUtility.JobScheduleParameters(
UnsafeUtility.AddressOf(ref fullData),
JobChunkLiveFilter_Process <T> .Initialize(),
dependsOn,
mode);
return(JobsUtility.ScheduleParallelFor(ref scheduleParams, totalChunks, 1));
}
internal void GetComponentChunkIterators(ForEachComponentGroupFilter forEachFilter)
{
var numFilters = forEachFilter.SharedComponentIndex.Length;
var firstArchetype = new NativeArray <IntPtr>(numFilters, Allocator.Temp);
var firstNonEmptyChunk = new NativeArray <IntPtr>(numFilters, Allocator.Temp);
ComponentChunkIterator.CalculateInitialChunkIterators(m_GroupData->FirstMatchingArchetype,
forEachFilter.IndexInComponentGroup, forEachFilter.SharedComponentIndex,
firstArchetype, firstNonEmptyChunk, forEachFilter.ItemLength);
for (var i = 0; i < numFilters; ++i)
{
var filter = new ComponentGroupFilter();
filter.Type = FilterType.SharedComponent;
filter.Shared.Count = 1;
filter.Shared.IndexInComponentGroup[0] = forEachFilter.IndexInComponentGroup;
filter.Shared.SharedComponentIndex[0] = forEachFilter.SharedComponentIndex[i];
forEachFilter.ItemIterator[i] = new ComponentChunkIterator((MatchingArchetypes *)firstArchetype[i],
m_EntityDataManager->GlobalSystemVersion, ref filter);
}
firstArchetype.Dispose();
firstNonEmptyChunk.Dispose();
}
internal void DestroyEntity(MatchingArchetypeList archetypeList, EntityQueryFilter filter)
{
Profiler.BeginSample("DestroyEntity(EntityQuery entityQueryFilter)");
Profiler.BeginSample("GetAllMatchingChunks");
var jobHandle = new JobHandle();
using (var chunks = ComponentChunkIterator.CreateArchetypeChunkArray(archetypeList, Allocator.TempJob, out jobHandle, ref filter))
{
jobHandle.Complete();
Profiler.EndSample();
if (chunks.Length != 0)
{
BeforeStructuralChange();
Profiler.BeginSample("EditorOnlyChecks");
EntityComponentStore->AssertCanDestroy(chunks);
EntityComponentStore->AssertWillDestroyAllInLinkedEntityGroup(chunks, GetArchetypeChunkBufferType <LinkedEntityGroup>(false));
Profiler.EndSample();
Profiler.BeginSample("DeleteChunks");
EntityManagerCreateDestroyEntitiesUtility.DestroyEntities(chunks, EntityComponentStore, ManagedComponentStore);
Profiler.EndSample();
}
}
Profiler.EndSample();
}
internal void RemoveComponent(MatchingArchetypeList archetypeList, EntityQueryFilter filter,
ComponentType componentType)
{
var jobHandle = new JobHandle();
using (var chunks = ComponentChunkIterator.CreateArchetypeChunkArray(archetypeList, Allocator.TempJob, out jobHandle, ref filter))
{
jobHandle.Complete();
if (chunks.Length == 0)
{
return;
}
BeforeStructuralChange();
var archetypeChanges = EntityComponentStore->BeginArchetypeChangeTracking();
EntityComponentStore->AssertCanRemoveComponent(chunks, componentType);
EntityManagerChangeArchetypeUtility.RemoveComponent(chunks, componentType,
EntityComponentStore,
ManagedComponentStore);
var changedArchetypes = EntityComponentStore->EndArchetypeChangeTracking(archetypeChanges);
EntityGroupManager.AddAdditionalArchetypes(changedArchetypes);
}
}
internal void AddComponent(UnsafeMatchingArchetypePtrList archetypeList, EntityQueryFilter filter, ComponentType componentType)
{
var jobHandle = new JobHandle();
//@TODO: Missing EntityQuery.SyncFilter
using (var chunks = ComponentChunkIterator.CreateArchetypeChunkArray(archetypeList, Allocator.TempJob, out jobHandle, ref filter))
{
jobHandle.Complete();
if (chunks.Length == 0)
{
return;
}
BeforeStructuralChange();
var archetypeChanges = EntityComponentStore->BeginArchetypeChangeTracking();
EntityComponentStore->AssertCanAddComponent(chunks, componentType);
using (var entityBatchList = m_EntityComponentStore->CreateEntityBatchList(chunks))
{
EntityComponentStore->AddComponentFromMainThread(entityBatchList, componentType, 0);
}
var changedArchetypes = EntityComponentStore->EndArchetypeChangeTracking(archetypeChanges);
EntityQueryManager.AddAdditionalArchetypes(changedArchetypes);
ManagedComponentStore.Playback(ref EntityComponentStore->ManagedChangesTracker);
}
}
internal void AddComponent(MatchingArchetypeList archetypeList, EntityQueryFilter filter,
ComponentType componentType)
{
var jobHandle = new JobHandle();
using (var chunks = ComponentChunkIterator.CreateArchetypeChunkArray(archetypeList, Allocator.TempJob, out jobHandle, ref filter))
{
jobHandle.Complete();
if (chunks.Length == 0)
{
return;
}
BeforeStructuralChange();
EntityComponentStore->AssertCanAddComponent(chunks, componentType);
using (var entityBatchList = m_EntityComponentStore->CreateEntityBatchList(chunks))
{
EntityManagerChangeArchetypeUtility.AddComponent(entityBatchList, componentType, 0,
EntityComponentStore,
ManagedComponentStore,
EntityGroupManager);
}
}
}
public EntityArraySt GetEntityArraySt()
{
var iterator = new ComponentChunkIterator(m_GroupData->MatchingArchetypes, m_EntityComponentStore->GlobalSystemVersion, ref m_Filter);
iterator.IndexInEntityQuery = 0;
return(new EntityArraySt(iterator, CalculateLength()));
}
internal EntityArray(ComponentChunkIterator iterator, int length, AtomicSafetyHandle safety)
{
this.m_Length = length;
this.m_Iterator = iterator;
this.m_Cache = new ComponentChunkCache();
this.m_Safety = safety;
}
internal ComponentArray(ComponentChunkIterator iterator, int length, ArchetypeManager typeMan)
{
m_Length = length;
m_Cache = default(ComponentChunkCache);
m_Iterator = iterator;
m_ArchetypeManager = typeMan;
}
/// <summary>
/// Calculates the number of chunks that match this EntityQuery, ignoring any set filters.
/// </summary>
/// <remarks>
/// The EntityQuery must run the queryDesc to calculate the chunk count.
/// </remarks>
/// <returns>The number of entities based on the current EntityQuery properties.</returns>
public int CalculateChunkCountWithoutFiltering()
{
SyncFilterTypes();
var dummyFilter = default(EntityQueryFilter);
return(ComponentChunkIterator.CalculateChunkCount(m_QueryData->MatchingArchetypes, ref dummyFilter));
}
public static GameObjectArray GetGameObjectArray(this ComponentGroup group)
{
int length = group.CalculateLength();
ComponentChunkIterator iterator = group.GetComponentChunkIterator();
iterator.IndexInComponentGroup = group.GetIndexInComponentGroup(TypeManager.GetTypeIndex <Transform>());
return(new GameObjectArray(iterator, length, group.ArchetypeManager));
}
/// <summary>
/// Creates an array with all the chunks in this ComponentGroup.
/// Waits for the GatherChunks job to complete here.
/// </summary>
/// <param name="allocator">Allocator to use for the array.</param>
/// <returns>NativeArray of all the chunks in this ComponentChunkIterator.</returns>
public NativeArray <ArchetypeChunk> CreateArchetypeChunkArray(Allocator allocator)
{
JobHandle job;
var res = ComponentChunkIterator.CreateArchetypeChunkArray(m_GroupData->MatchingArchetypes, allocator, out job);
job.Complete();
return(res);
}
internal void GetComponentDataArray <T>(ref ComponentChunkIterator iterator, int indexInComponentGroup, int length, out ComponentDataArray <T> output) where T : struct, IComponentData
{
iterator.IndexInComponentGroup = indexInComponentGroup;
#if ENABLE_UNITY_COLLECTIONS_CHECKS
output = new ComponentDataArray <T>(iterator, length, GetSafetyHandle(indexInComponentGroup));
#else
output = new ComponentDataArray <T>(iterator, length);
#endif
}
public static ComponentArray <T> GetComponentArray <T>(this ComponentGroup group) where T : Component
{
int length = group.CalculateLength();
ComponentChunkIterator iterator = group.GetComponentChunkIterator();
var indexInComponentGroup = group.GetIndexInComponentGroup(TypeManager.GetTypeIndex <T>());
iterator.IndexInComponentGroup = indexInComponentGroup;
return(new ComponentArray <T>(iterator, length, group.ArchetypeManager));
}
internal void GetEntityArray(ref ComponentChunkIterator iterator, int length, out EntityArray output)
{
iterator.IndexInComponentGroup = 0;
#if ENABLE_UNITY_COLLECTIONS_CHECKS
output = new EntityArray(iterator, length, m_SafetyManager.GetSafetyHandle(TypeManager.GetTypeIndex <Entity>(), true));
#else
output = new EntityArray(iterator, length);
#endif
}
internal ComponentDataArray(ComponentChunkIterator iterator, int length, AtomicSafetyHandle safety)
{
this.m_Iterator = iterator;
this.m_Cache = new ComponentChunkCache();
this.m_Length = length;
this.m_MinIndex = 0;
this.m_MaxIndex = length - 1;
this.m_Safety = safety;
}
/// <summary>
/// Creates an array with all the chunks in this EntityQuery.
/// Waits for the GatherChunks job to complete here.
/// </summary>
/// <param name="allocator">Allocator to use for the array.</param>
/// <returns>NativeArray of all the chunks in this ComponentChunkIterator.</returns>
public NativeArray <ArchetypeChunk> CreateArchetypeChunkArray(Allocator allocator)
{
SyncFilterTypes();
JobHandle job;
var res = ComponentChunkIterator.CreateArchetypeChunkArray(m_QueryData->MatchingArchetypes, allocator, out job, ref m_Filter);
job.Complete();
return(res);
}
internal void GetSharedComponentDataArray <T>(ref ComponentChunkIterator iterator, int indexInComponentGroup, int length, out SharedComponentDataArray <T> output) where T : struct, ISharedComponentData
{
iterator.IndexInComponentGroup = indexInComponentGroup;
#if ENABLE_UNITY_COLLECTIONS_CHECKS
var typeIndex = m_ComponentGroupData.ComponentTypeIndex(indexInComponentGroup);
output = new SharedComponentDataArray <T>(m_TypeManager.GetSharedComponentDataManager(), indexInComponentGroup, iterator, length, m_SafetyManager.GetSafetyHandle(typeIndex, true));
#else
output = new SharedComponentDataArray <T>(m_TypeManager.GetSharedComponentDataManager(), indexInComponentGroup, iterator, length);
#endif
}
public NativeArray <T> ToComponentDataArray <T>(Allocator allocator, out JobHandle jobhandle)
where T : struct, IComponentData
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
var componentType = new ArchetypeChunkComponentType <T>(m_SafetyManager.GetSafetyHandle(TypeManager.GetTypeIndex <T>(), true), true, EntityDataManager->GlobalSystemVersion);
#else
var componentType = new ArchetypeChunkComponentType <T>(true, EntityDataManager->GlobalSystemVersion);
#endif
return(ComponentChunkIterator.CreateComponentDataArray(m_GroupData->MatchingArchetypes, allocator, componentType, this, ref m_Filter, out jobhandle, GetDependency()));
}
public NativeArray <Entity> ToEntityArray(Allocator allocator, out JobHandle jobhandle)
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
var entityType = new ArchetypeChunkEntityType(m_SafetyManager.GetSafetyHandle(TypeManager.GetTypeIndex <Entity>(), true));
#else
var entityType = new ArchetypeChunkEntityType();
#endif
return(ComponentChunkIterator.CreateEntityArray(m_GroupData->MatchingArchetypes, allocator, entityType, this, ref m_Filter, out jobhandle, GetDependency()));
}
public ComponentDataArraySt <T> GetComponentDataArraySt <T>() where T : struct, IComponentData
{
var typeIndex = TypeManager.GetTypeIndex <T>();
var iterator = new ComponentChunkIterator(m_GroupData->MatchingArchetypes, m_EntityComponentStore->GlobalSystemVersion, ref m_Filter);
iterator.IndexInEntityQuery = GetIndexInEntityQuery(typeIndex);
return(new ComponentDataArraySt <T>(iterator, CalculateLength()));
}
public BufferArray <T> GetBufferArray <T>() where T : struct, IBufferElementData
{
int length = CalculateLength();
ComponentChunkIterator iterator = GetComponentChunkIterator();
var indexInComponentGroup = GetIndexInComponentGroup(TypeManager.GetTypeIndex <T>());
BufferArray <T> res;
GetBufferArray(ref iterator, indexInComponentGroup, length, out res);
return(res);
}
internal void RemoveComponent(UnsafeMatchingArchetypePtrList archetypeList, EntityQueryFilter filter, ComponentType componentType)
{
//@TODO: Missing EntityQuery.SyncFilter
var jobHandle = new JobHandle();
using (var chunks = ComponentChunkIterator.CreateArchetypeChunkArray(archetypeList, Allocator.TempJob, out jobHandle, ref filter))
{
jobHandle.Complete();
RemoveComponent(chunks, componentType);
}
}
internal unsafe EntityArray(ComponentChunkIterator iterator, int length)
#endif
{
m_Length = length;
m_Iterator = iterator;
m_Cache = default(ComponentChunkCache);
#if ENABLE_UNITY_COLLECTIONS_CHECKS
m_Safety = safety;
#endif
}
internal void AddSharedComponentData(UnsafeMatchingArchetypePtrList archetypeList, EntityQueryFilter filter,
int sharedComponentIndex, ComponentType componentType)
{
var jobHandle = new JobHandle();
//@TODO: Missing EntityQuery.SyncFilter
using (var chunks = ComponentChunkIterator.CreateArchetypeChunkArray(archetypeList, Allocator.TempJob, out jobHandle, ref filter))
{
jobHandle.Complete();
AddSharedComponentData(chunks, sharedComponentIndex, componentType);
}
}
/// <summary>
/// Creates a NativeArray containing the selected entities.
/// </summary>
/// <remarks>This version of the function blocks until the Job used to fill the array is complete.</remarks>
/// <param name="allocator">The type of memory to allocate.</param>
/// <returns>An array containing all the entities selected by the EntityQuery.</returns>
public NativeArray <Entity> ToEntityArray(Allocator allocator)
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
var entityType = new ArchetypeChunkEntityType(m_SafetyManager->GetEntityManagerSafetyHandle());
#else
var entityType = new ArchetypeChunkEntityType();
#endif
JobHandle job;
var res = ComponentChunkIterator.CreateEntityArray(m_QueryData->MatchingArchetypes, allocator, entityType, this, ref m_Filter, out job, GetDependency());
job.Complete();
return(res);
}
internal static unsafe JobHandle ScheduleInternal <T>(ref T jobData, EntityQuery query, JobHandle dependsOn, ScheduleMode mode)
where T : struct, IJobChunk
{
ComponentChunkIterator iterator = query.GetComponentChunkIterator();
var unfilteredChunkCount = query.CalculateChunkCountWithoutFiltering();
var prefilterHandle = ComponentChunkIterator.PreparePrefilteredChunkLists(unfilteredChunkCount,
iterator.m_MatchingArchetypeList, iterator.m_Filter, dependsOn, mode, out var prefilterData,
out var deferredCountData);
JobChunkData <T> fullData = new JobChunkData <T>
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
// All IJobChunk jobs have a EntityManager safety handle to ensure that BeforeStructuralChange throws an error if
// jobs without any other safety handles are still running (haven't been synced).
safety = new EntitySafetyHandle {
m_Safety = query.SafetyManager->GetEntityManagerSafetyHandle()
},
#endif
Data = jobData,
PrefilterData = prefilterData,
};
var scheduleParams = new JobsUtility.JobScheduleParameters(
UnsafeUtility.AddressOf(ref fullData),
JobChunk_Process <T> .Initialize(),
prefilterHandle,
mode);
#if ENABLE_UNITY_COLLECTIONS_CHECKS
try
{
#endif
if (mode == ScheduleMode.Batched)
{
return(JobsUtility.ScheduleParallelForDeferArraySize(ref scheduleParams, 1, deferredCountData, null));
}
else
{
var count = unfilteredChunkCount;
return(JobsUtility.ScheduleParallelFor(ref scheduleParams, count, 1));
}
#if ENABLE_UNITY_COLLECTIONS_CHECKS
}
catch (InvalidOperationException e)
{
prefilterData.Dispose();
throw e;
}
#endif
}
internal unsafe void UpdateEntries(ComponentGroup entityGroup, ref ComponentChunkIterator iterator, int length, byte *groupStructPtr)
{
if (!HasEntries)
{
return;
}
foreach (var info in m_Entries)
{
info.Hook.InjectEntry(info, entityGroup, ref iterator, length, groupStructPtr);
}
}
internal void GetFixedArrayArray <T>(ref ComponentChunkIterator iterator, int indexInComponentGroup, int length,
out FixedArrayArray <T> output) where T : struct
{
iterator.IndexInComponentGroup = indexInComponentGroup;
#if ENABLE_UNITY_COLLECTIONS_CHECKS
output = new FixedArrayArray <T>(iterator, length, m_ComponentGroupData.GetIsReadOnly(indexInComponentGroup),
GetSafetyHandle(indexInComponentGroup));
#else
output =
new FixedArrayArray <T>(iterator, length, m_ComponentGroupData.GetIsReadOnly(indexInComponentGroup));
#endif
}
internal ComponentDataArray(ComponentChunkIterator iterator, int length)
#endif
{
m_Iterator = iterator;
m_Cache = default(ComponentChunkCache);
m_Length = length;
#if ENABLE_UNITY_COLLECTIONS_CHECKS
m_MinIndex = 0;
m_MaxIndex = length - 1;
m_Safety = safety;
#endif
}
