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
}
public static T[] ToComponentArray <T>(this EntityQuery group) where T : Component
{
int length = group.CalculateLength();
ComponentChunkIterator iterator = group.GetComponentChunkIterator();
var indexInComponentGroup = group.GetIndexInEntityQuery(TypeManager.GetTypeIndex <T>());
iterator.IndexInEntityQuery = indexInComponentGroup;
var arr = new T[length];
var cache = default(ComponentChunkCache);
for (int i = 0; i < length; ++i)
{
if (i < cache.CachedBeginIndex || i >= cache.CachedEndIndex)
{
iterator.MoveToEntityIndexAndUpdateCache(i, out cache, true);
}
arr[i] = (T)iterator.GetManagedObject(group.ManagedComponentStore, cache.CachedBeginIndex, i);
}
return(arr);
}
/// <summary>
/// Destroy all entities having a common set of component types.
/// </summary>
/// <remarks>Since entities in the same chunk share the same component structure, this function effectively destroys
/// the chunks holding any entities identified by the `entityQueryFilter` parameter.</remarks>
/// <param name="entityQueryFilter">Defines the components an entity must have to qualify for destruction.</param>
public void DestroyEntity(EntityQuery entityQuery)
{
var iterator = entityQuery.GetComponentChunkIterator();
DestroyEntity(iterator.m_MatchingArchetypeList, iterator.m_Filter);
}
/// <summary>
/// Adds a component to a set of entities defined by a EntityQuery.
/// </summary>
/// <remarks>
/// Adding a component changes an entity's archetype and results in the entity being moved to a different
/// chunk.
///
/// The added components have the default values for the type.
///
/// **Important:** This function creates a sync point, which means that the EntityManager waits for all
/// currently running Jobs to complete before adding the component and no additional Jobs can start before
/// the function is finished. A sync point can cause a drop in performance because the ECS framework may not
/// be able to make use of the processing power of all available cores.
/// </remarks>
/// <param name="entityQuery">The EntityQuery defining the entities to modify.</param>
/// <param name="componentType">The type of component to add.</param>
public void AddComponent(EntityQuery entityQuery, ComponentType componentType)
{
var iterator = entityQuery.GetComponentChunkIterator();
AddComponent(iterator.m_MatchingArchetypeList, iterator.m_Filter, componentType);
}
