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 }