protected override JobHandle OnUpdate(JobHandle inputDeps)
{
this.DisposeBuffers();
var handle = inputDeps;
var playerGroupLength = this._playerGroup.CalculateLength();
// ---------------------
// Allocate Memory
this._playerColliders = new NativeArray <SphereCollider>(
playerGroupLength,
Allocator.TempJob,
NativeArrayOptions.UninitializedMemory);
this._playerHashmap = new NativeMultiHashMap <int, int>(
playerGroupLength * MaxGridNum,
Allocator.TempJob);
// ---------------------
// ComponentDataArray
var copyPlayerColliderJobHandle = new CopyComponentData <SphereCollider>
{
Source = this._playerGroup.GetComponentDataArray <SphereCollider>(),
Results = this._playerColliders,
}.Schedule(playerGroupLength, 32, handle);
// Hashmap Settings
var playerHashmapJobHandle = new HashPositions
{
CellRadius = CellRadius,
Offsets = this._offsets,
SphereColliders = this._playerGroup.GetComponentDataArray <SphereCollider>(),
Hashmap = this._playerHashmap.ToConcurrent(),
}.Schedule(playerGroupLength, 32, handle);
// ※Jobの依存関係の結合
var handles = new NativeArray <JobHandle>(2, Allocator.Temp);
handles[0] = copyPlayerColliderJobHandle;
handles[1] = playerHashmapJobHandle;
handle = JobHandle.CombineDependencies(handles);
handles.Dispose();
// ---------------------
// Check Hit
handle = new CheckHitJob
{
CellRadius = CellRadius,
PlayerColliders = this._playerColliders,
PlayerHashmap = this._playerHashmap,
}.Schedule(this, handle);
return(handle);
}
protected override JobHandle OnUpdate(JobHandle inputDependencies)
{
int cellRadius = 50;
var boidCount = boidGroup.CalculateEntityCount();
var turretCount = turretGroup.CalculateEntityCount();
if (boidCount == 0)
{
// TODO: or maybe rotate to idle
return(inputDependencies);
}
var boidPosition = new NativeArray <float3>(boidCount, Allocator.TempJob,
NativeArrayOptions.UninitializedMemory);
var boidDict = new NativeMultiHashMap <int, int>(boidCount, Allocator.TempJob);
var turretTarget = new NativeHashMap <int, int>(turretCount, Allocator.TempJob);
//var turretTarget = new NativeArray<TurretTarget>(turretCount, Allocator.TempJob);
var nextData = new PrevData {
boidDict = boidDict,
boidPosition = boidPosition,
turretTarget = turretTarget
};
// Data Cleanup
if (prevData.Count != 0)
{
prevData[0].boidDict.Dispose();
prevData[0].boidPosition.Dispose();
prevData[0].turretTarget.Dispose();
}
else
{
prevData.Add(nextData);
}
prevData[0] = nextData;
var copyBoidPositionsJob = new CopyPositions {
positions = boidPosition
};
var copyBoidPositionsJobHandle = copyBoidPositionsJob.Schedule(boidGroup, inputDependencies);
var hashPositionsJob = new HashPositions {
boidDict = boidDict.AsParallelWriter(),
cellRadius = cellRadius
};
var hashPositionsJobHandle = hashPositionsJob.Schedule(boidGroup, copyBoidPositionsJobHandle);
ref PhysicsWorld physicsWorld = ref Unity.Entities.World.Active.GetExistingSystem <Unity.Physics.Systems.BuildPhysicsWorld>().PhysicsWorld;
protected override JobHandle OnUpdate(JobHandle inputDeps)
{
EntityManager.GetAllUniqueSharedComponentData(m_UniqueTypes);
var obstacleCount = m_ObstacleGroup.CalculateLength();
var targetCount = m_TargetGroup.CalculateLength();
// Ignore typeIndex 0, can't use the default for anything meaningful.
for (int typeIndex = 1; typeIndex < m_UniqueTypes.Count; typeIndex++)
{
var settings = m_UniqueTypes[typeIndex];
m_BoidGroup.SetFilter(settings);
var boidCount = m_BoidGroup.CalculateLength();
var cacheIndex = typeIndex - 1;
var cellIndices = new NativeArray <int>(boidCount, Allocator.TempJob, NativeArrayOptions.UninitializedMemory);
var hashMap = new NativeMultiHashMap <int, int>(boidCount, Allocator.TempJob);
var cellObstacleDistance = new NativeArray <float>(boidCount, Allocator.TempJob, NativeArrayOptions.UninitializedMemory);
var cellObstaclePositionIndex = new NativeArray <int>(boidCount, Allocator.TempJob, NativeArrayOptions.UninitializedMemory);
var cellTargetPositionIndex = new NativeArray <int>(boidCount, Allocator.TempJob, NativeArrayOptions.UninitializedMemory);
var cellCount = new NativeArray <int>(boidCount, Allocator.TempJob, NativeArrayOptions.UninitializedMemory);
var cellAlignment = new NativeArray <float3>(boidCount, Allocator.TempJob,
NativeArrayOptions.UninitializedMemory);
var cellSeparation = new NativeArray <float3>(boidCount, Allocator.TempJob,
NativeArrayOptions.UninitializedMemory);
var copyTargetPositions = new NativeArray <float3>(targetCount, Allocator.TempJob,
NativeArrayOptions.UninitializedMemory);
var copyObstaclePositions = new NativeArray <float3>(obstacleCount, Allocator.TempJob,
NativeArrayOptions.UninitializedMemory);
var initialCellAlignmentJob = new CopyHeadings
{
headings = cellAlignment
};
var initialCellAlignmentJobHandle = initialCellAlignmentJob.Schedule(m_BoidGroup, inputDeps);
var initialCellSeparationJob = new CopyPositions
{
positions = cellSeparation
};
var initialCellSeparationJobHandle = initialCellSeparationJob.Schedule(m_BoidGroup, inputDeps);
var copyTargetPositionsJob = new CopyPositions
{
positions = copyTargetPositions
};
var copyTargetPositionsJobHandle = copyTargetPositionsJob.Schedule(m_TargetGroup, inputDeps);
var copyObstaclePositionsJob = new CopyPositions
{
positions = copyObstaclePositions
};
var copyObstaclePositionsJobHandle = copyObstaclePositionsJob.Schedule(m_ObstacleGroup, inputDeps);
var nextCells = new PrevCells
{
cellIndices = cellIndices,
hashMap = hashMap,
copyObstaclePositions = copyObstaclePositions,
copyTargetPositions = copyTargetPositions,
cellAlignment = cellAlignment,
cellSeparation = cellSeparation,
cellObstacleDistance = cellObstacleDistance,
cellObstaclePositionIndex = cellObstaclePositionIndex,
cellTargetPositionIndex = cellTargetPositionIndex,
cellCount = cellCount
};
if (cacheIndex > (m_PrevCells.Count - 1))
{
m_PrevCells.Add(nextCells);
}
else
{
m_PrevCells[cacheIndex].hashMap.Dispose();
m_PrevCells[cacheIndex].cellIndices.Dispose();
m_PrevCells[cacheIndex].cellObstaclePositionIndex.Dispose();
m_PrevCells[cacheIndex].cellTargetPositionIndex.Dispose();
m_PrevCells[cacheIndex].copyTargetPositions.Dispose();
m_PrevCells[cacheIndex].copyObstaclePositions.Dispose();
m_PrevCells[cacheIndex].cellAlignment.Dispose();
m_PrevCells[cacheIndex].cellSeparation.Dispose();
m_PrevCells[cacheIndex].cellObstacleDistance.Dispose();
m_PrevCells[cacheIndex].cellCount.Dispose();
}
m_PrevCells[cacheIndex] = nextCells;
var hashPositionsJob = new HashPositions
{
hashMap = hashMap.ToConcurrent(),
cellRadius = settings.CellRadius
};
var hashPositionsJobHandle = hashPositionsJob.Schedule(m_BoidGroup, inputDeps);
var initialCellCountJob = new MemsetNativeArray <int>
{
Source = cellCount,
Value = 1
};
var initialCellCountJobHandle = initialCellCountJob.Schedule(boidCount, 64, inputDeps);
var initialCellBarrierJobHandle = JobHandle.CombineDependencies(initialCellAlignmentJobHandle, initialCellSeparationJobHandle, initialCellCountJobHandle);
var copyTargetObstacleBarrierJobHandle = JobHandle.CombineDependencies(copyTargetPositionsJobHandle, copyObstaclePositionsJobHandle);
var mergeCellsBarrierJobHandle = JobHandle.CombineDependencies(hashPositionsJobHandle, initialCellBarrierJobHandle, copyTargetObstacleBarrierJobHandle);
var mergeCellsJob = new MergeCells
{
cellIndices = cellIndices,
cellAlignment = cellAlignment,
cellSeparation = cellSeparation,
cellObstacleDistance = cellObstacleDistance,
cellObstaclePositionIndex = cellObstaclePositionIndex,
cellTargetPositionIndex = cellTargetPositionIndex,
cellCount = cellCount,
targetPositions = copyTargetPositions,
obstaclePositions = copyObstaclePositions
};
var mergeCellsJobHandle = mergeCellsJob.Schedule(hashMap, 64, mergeCellsBarrierJobHandle);
var steerJob = new Steer
{
cellIndices = nextCells.cellIndices,
settings = settings,
cellAlignment = cellAlignment,
cellSeparation = cellSeparation,
cellObstacleDistance = cellObstacleDistance,
cellObstaclePositionIndex = cellObstaclePositionIndex,
cellTargetPositionIndex = cellTargetPositionIndex,
cellCount = cellCount,
targetPositions = copyTargetPositions,
obstaclePositions = copyObstaclePositions,
dt = Time.deltaTime,
};
var steerJobHandle = steerJob.Schedule(m_BoidGroup, mergeCellsJobHandle);
inputDeps = steerJobHandle;
m_BoidGroup.AddDependency(inputDeps);
}
m_UniqueTypes.Clear();
return(inputDeps);
}
protected override JobHandle OnUpdate(JobHandle inputDeps)
{
dispose_resources();
handle_ = inputDeps;
player_colliders_ = new NativeArray <SphereCollider>(player_group_.Length,
Allocator.TempJob,
NativeArrayOptions.UninitializedMemory);
enemy_colliders_ = new NativeArray <SphereCollider>(enemy_group_.Length,
Allocator.TempJob,
NativeArrayOptions.UninitializedMemory);
player_bullet_colliders_ = new NativeArray <SphereCollider>(player_bullet_group_.Length,
Allocator.TempJob,
NativeArrayOptions.UninitializedMemory);
enemy_bullet_colliders_ = new NativeArray <SphereCollider>(enemy_bullet_group_.Length,
Allocator.TempJob,
NativeArrayOptions.UninitializedMemory);
player_hashmap_ = new NativeMultiHashMap <int, int>(player_group_.Length * 27 /* expanded */,
Allocator.TempJob);
enemy_hashmap_ = new NativeMultiHashMap <int, int>(enemy_group_.Length * 27 /* expanded */,
Allocator.TempJob);
player_bullet_hashmap_ = new NativeMultiHashMap <int, int>(player_bullet_group_.Length * 27 /* expand */,
Allocator.TempJob);
enemy_bullet_hashmap_ = new NativeMultiHashMap <int, int>(enemy_bullet_group_.Length * 27 /* expand */,
Allocator.TempJob);
var initial_player_collider_job = new CopyComponentData <SphereCollider> {
Source = player_group_.sphere_collider_list_,
Results = player_colliders_,
};
var initial_player_collider_handle_ = initial_player_collider_job.Schedule(player_group_.Length, 32, handle_);
var initial_enemy_collider_job = new CopyComponentData <SphereCollider> {
Source = enemy_group_.sphere_collider_list_,
Results = enemy_colliders_,
};
var initial_enemy_collider_handle_ = initial_enemy_collider_job.Schedule(enemy_group_.Length, 32, handle_);
var initial_player_bullet_collider_job = new CopyComponentData <SphereCollider> {
Source = player_bullet_group_.sphere_collider_list_,
Results = player_bullet_colliders_,
};
var initial_player_bullet_collider_handle_ = initial_player_bullet_collider_job.Schedule(player_bullet_group_.Length,
32, handle_);
var initial_enemy_bullet_collider_job = new CopyComponentData <SphereCollider> {
Source = enemy_bullet_group_.sphere_collider_list_,
Results = enemy_bullet_colliders_,
};
var initial_enemy_bullet_collider_handle_ = initial_enemy_bullet_collider_job.Schedule(enemy_bullet_group_.Length,
32, handle_);
const float CELL_RADIUS = 8f;
var initial_player_hashmap_job = new HashPositions {
cell_radius_ = CELL_RADIUS,
offsets_ = offsets_,
sphere_collider_list_ = player_group_.sphere_collider_list_,
hashmap_ = player_hashmap_,
};
var initial_player_hashmap_handle_ = initial_player_hashmap_job.Schedule(player_group_.Length, 32, handle_);
var initial_enemy_hashmap_job = new HashPositions {
cell_radius_ = CELL_RADIUS,
offsets_ = offsets_,
sphere_collider_list_ = enemy_group_.sphere_collider_list_,
hashmap_ = enemy_hashmap_,
};
var initial_enemy_hashmap_handle_ = initial_enemy_hashmap_job.Schedule(enemy_group_.Length, 32, handle_);
var initial_player_bullet_hashmap_job = new HashPositions {
cell_radius_ = CELL_RADIUS,
offsets_ = offsets_,
sphere_collider_list_ = player_bullet_group_.sphere_collider_list_,
hashmap_ = player_bullet_hashmap_,
};
var initial_player_bullet_hashmap_handle_ = initial_player_bullet_hashmap_job.Schedule(player_bullet_group_.Length,
32, handle_);
var initial_enemy_bullet_hashmap_job = new HashPositions {
cell_radius_ = CELL_RADIUS,
offsets_ = offsets_,
sphere_collider_list_ = enemy_bullet_group_.sphere_collider_list_,
hashmap_ = enemy_bullet_hashmap_,
};
var initial_enemy_bullet_hashmap_handle_ = initial_enemy_bullet_hashmap_job.Schedule(enemy_bullet_group_.Length,
32, handle_);
{
var handle_s = new NativeArray <JobHandle>(8, Allocator.Temp);
var idx = 0;
handle_s[idx] = initial_player_collider_handle_; ++idx;
handle_s[idx] = initial_enemy_collider_handle_; ++idx;
handle_s[idx] = initial_player_bullet_collider_handle_; ++idx;
handle_s[idx] = initial_enemy_bullet_collider_handle_; ++idx;
handle_s[idx] = initial_player_hashmap_handle_; ++idx;
handle_s[idx] = initial_enemy_hashmap_handle_; ++idx;
handle_s[idx] = initial_player_bullet_hashmap_handle_; ++idx;
handle_s[idx] = initial_enemy_bullet_hashmap_handle_; ++idx;
handle_ = JobHandle.CombineDependencies(handle_s);
handle_s.Dispose();
}
{
var job = new CheckEnemyToPlayer {
cell_radius_ = CELL_RADIUS,
enemy_colliders_ = enemy_colliders_,
player_colliders_ = player_colliders_,
player_hashmap_ = player_hashmap_,
enemy_list_ = enemy_group_.enemy_list_,
player_list_ = player_group_.player_list_,
};
handle_ = job.Schedule(enemy_group_.Length, 32, handle_);
}
{
var job = new CheckEnemyBulletToPlayer {
time_ = Time.GetCurrent(),
cell_radius_ = CELL_RADIUS,
enemy_bullet_colliders_ = enemy_bullet_colliders_,
player_colliders_ = player_colliders_,
player_hashmap_ = player_hashmap_,
player_list_ = player_group_.player_list_,
destroyable_list_ = enemy_bullet_group_.destroyable_list_,
enemy_bullet_collision_info_list_ = enemy_bullet_group_.collision_info_list_,
};
handle_ = job.Schedule(enemy_bullet_group_.Length, 32, handle_);
}
{
var job = new CheckPlayerBulletToEnemy {
time_ = Time.GetCurrent(),
cell_radius_ = CELL_RADIUS,
player_bullet_colliders_ = player_bullet_colliders_,
enemy_colliders_ = enemy_colliders_,
enemy_hashmap_ = enemy_hashmap_,
destroyable_list_ = player_bullet_group_.destroyable_list_,
enemy_list_ = enemy_group_.enemy_list_,
player_bullet_collision_info_list_ = player_bullet_group_.collision_info_list_,
};
handle_ = job.Schedule(player_bullet_group_.Length, 32, handle_);
}
return(handle_);
}
protected override JobHandle OnUpdate(JobHandle inputDeps)
{
EntityManager.GetAllUniqueSharedComponentData(m_UniqueTypes);
var obstacleCount = m_ObstacleQuery.CalculateEntityCount();
var targetCount = m_TargetQuery.CalculateEntityCount();
// Cannot call [DeallocateOnJobCompletion] on Hashmaps yet, so doing own cleanup here
// of the hashes created in the previous iteration.
for (int i = 0; i < m_PrevFrameHashmaps.Count; ++i)
{
m_PrevFrameHashmaps[i].Dispose();
}
m_PrevFrameHashmaps.Clear();
// Each variant of the Boid represents a different value of the SharedComponentData and is self-contained,
// meaning Boids of the same variant only interact with one another. Thus, this loop processes each
// variant type individually.
for (int boidVariantIndex = 0; boidVariantIndex < m_UniqueTypes.Count; boidVariantIndex++)
{
var settings = m_UniqueTypes[boidVariantIndex];
m_BoidQuery.SetFilter(settings);
var boidCount = m_BoidQuery.CalculateEntityCount();
if (boidCount == 0)
{
// Early out. If the given variant includes no Boids, move on to the next loop.
// For example, variant 0 will always exit early bc it's it represents a default, uninitialized
// Boid struct, which does not appear in this sample.
continue;
}
// The following calculates spatial cells of neighboring Boids
// note: working with a sparse grid and not a dense bounded grid so there
// are no predefined borders of the space.
var hashMap = new NativeMultiHashMap <int, int>(boidCount, Allocator.TempJob);
var cellIndices = new NativeArray <int>(boidCount, Allocator.TempJob, NativeArrayOptions.UninitializedMemory);
var cellObstaclePositionIndex = new NativeArray <int>(boidCount, Allocator.TempJob, NativeArrayOptions.UninitializedMemory);
var cellTargetPositionIndex = new NativeArray <int>(boidCount, Allocator.TempJob, NativeArrayOptions.UninitializedMemory);
var cellCount = new NativeArray <int>(boidCount, Allocator.TempJob, NativeArrayOptions.UninitializedMemory);
var cellObstacleDistance = new NativeArray <float>(boidCount, Allocator.TempJob, NativeArrayOptions.UninitializedMemory);
var cellAlignment = new NativeArray <float3>(boidCount, Allocator.TempJob, NativeArrayOptions.UninitializedMemory);
var cellSeparation = new NativeArray <float3>(boidCount, Allocator.TempJob, NativeArrayOptions.UninitializedMemory);
var copyTargetPositions = new NativeArray <float3>(targetCount, Allocator.TempJob, NativeArrayOptions.UninitializedMemory);
var copyObstaclePositions = new NativeArray <float3>(obstacleCount, Allocator.TempJob, NativeArrayOptions.UninitializedMemory);
// The following jobs all run in parallel because the same JobHandle is passed for their
// input dependencies when the jobs are scheduled; thus, they can run in any order (or concurrently).
// The concurrency is property of how they're scheduled, not of the job structs themselves.
var initialCellAlignmentJob = new CopyHeadings
{
headings = cellAlignment
};
var initialCellAlignmentJobHandle = initialCellAlignmentJob.Schedule(m_BoidQuery, inputDeps);
var initialCellSeparationJob = new CopyPositions
{
positions = cellSeparation
};
var initialCellSeparationJobHandle = initialCellSeparationJob.Schedule(m_BoidQuery, inputDeps);
var copyTargetPositionsJob = new CopyPositions
{
positions = copyTargetPositions
};
var copyTargetPositionsJobHandle = copyTargetPositionsJob.Schedule(m_TargetQuery, inputDeps);
var copyObstaclePositionsJob = new CopyPositions
{
positions = copyObstaclePositions
};
var copyObstaclePositionsJobHandle = copyObstaclePositionsJob.Schedule(m_ObstacleQuery, inputDeps);
// Cannot call [DeallocateOnJobCompletion] on Hashmaps yet, so adding resolved hashes to the list
// so that theyre usable in the upcoming cell jobs and also have a straight forward cleanup.
m_PrevFrameHashmaps.Add(hashMap);
// setting up the jobs for position and cell count
var hashPositionsJob = new HashPositions
{
hashMap = hashMap.AsParallelWriter(),
cellRadius = settings.CellRadius
};
var hashPositionsJobHandle = hashPositionsJob.Schedule(m_BoidQuery, inputDeps);
var initialCellCountJob = new MemsetNativeArray <int>
{
Source = cellCount,
Value = 1
};
var initialCellCountJobHandle = initialCellCountJob.Schedule(boidCount, 64, inputDeps);
var initialCellBarrierJobHandle = JobHandle.CombineDependencies(initialCellAlignmentJobHandle, initialCellSeparationJobHandle, initialCellCountJobHandle);
var copyTargetObstacleBarrierJobHandle = JobHandle.CombineDependencies(copyTargetPositionsJobHandle, copyObstaclePositionsJobHandle);
var mergeCellsBarrierJobHandle = JobHandle.CombineDependencies(hashPositionsJobHandle, initialCellBarrierJobHandle, copyTargetObstacleBarrierJobHandle);
var mergeCellsJob = new MergeCells
{
cellIndices = cellIndices,
cellAlignment = cellAlignment,
cellSeparation = cellSeparation,
cellObstacleDistance = cellObstacleDistance,
cellObstaclePositionIndex = cellObstaclePositionIndex,
cellTargetPositionIndex = cellTargetPositionIndex,
cellCount = cellCount,
targetPositions = copyTargetPositions,
obstaclePositions = copyObstaclePositions
};
var mergeCellsJobHandle = mergeCellsJob.Schedule(hashMap, 64, mergeCellsBarrierJobHandle);
var steerJob = new Steer
{
cellIndices = cellIndices,
settings = settings,
cellAlignment = cellAlignment,
cellSeparation = cellSeparation,
cellObstacleDistance = cellObstacleDistance,
cellObstaclePositionIndex = cellObstaclePositionIndex,
cellTargetPositionIndex = cellTargetPositionIndex,
cellCount = cellCount,
targetPositions = copyTargetPositions,
obstaclePositions = copyObstaclePositions,
dt = Time.deltaTime,
};
var steerJobHandle = steerJob.Schedule(m_BoidQuery, mergeCellsJobHandle);
inputDeps = steerJobHandle;
m_BoidQuery.AddDependency(inputDeps);
}
m_UniqueTypes.Clear();
return(inputDeps);
}
protected override JobHandle OnUpdate(JobHandle inputDeps)
{
if (cameraTransform == null)
{
cameraTransform = GameObject.Find("Main Camera").transform;
}
EntityManager.GetAllUniqueSharedComponentData(uniqueTypes);
ComponentDataArray <SPHCollider> colliders = SPHColliderGroup.GetComponentDataArray <SPHCollider>();
int colliderCount = colliders.Length;
for (int typeIndex = 1; typeIndex < uniqueTypes.Count; typeIndex++)
{
// Get the current chunk setting
SPHParticle settings = uniqueTypes[typeIndex];
SPHCharacterGroup.SetFilter(settings);
// Cache the data
ComponentDataArray <Position> positions = SPHCharacterGroup.GetComponentDataArray <Position>();
ComponentDataArray <SPHVelocity> velocities = SPHCharacterGroup.GetComponentDataArray <SPHVelocity>();
int cacheIndex = typeIndex - 1;
int particleCount = positions.Length;
NativeMultiHashMap <int, int> hashMap = new NativeMultiHashMap <int, int>(particleCount, Allocator.TempJob);
NativeArray <Position> particlesPosition = new NativeArray <Position>(particleCount, Allocator.TempJob, NativeArrayOptions.UninitializedMemory);
NativeArray <SPHVelocity> particlesVelocity = new NativeArray <SPHVelocity>(particleCount, Allocator.TempJob, NativeArrayOptions.UninitializedMemory);
NativeArray <float3> particlesForces = new NativeArray <float3>(particleCount, Allocator.TempJob, NativeArrayOptions.UninitializedMemory);
NativeArray <float> particlesPressure = new NativeArray <float>(particleCount, Allocator.TempJob, NativeArrayOptions.UninitializedMemory);
NativeArray <float> particlesDensity = new NativeArray <float>(particleCount, Allocator.TempJob, NativeArrayOptions.UninitializedMemory);
NativeArray <int> particleIndices = new NativeArray <int>(particleCount, Allocator.TempJob, NativeArrayOptions.UninitializedMemory);
NativeArray <int> cellOffsetTableNative = new NativeArray <int>(cellOffsetTable, Allocator.TempJob);
NativeArray <SPHCollider> copyColliders = new NativeArray <SPHCollider>(colliderCount, Allocator.TempJob, NativeArrayOptions.UninitializedMemory);
// Add new or dispose previous particle chunks
PreviousParticle nextParticles = new PreviousParticle
{
hashMap = hashMap,
particlesPosition = particlesPosition,
particlesVelocity = particlesVelocity,
particlesForces = particlesForces,
particlesPressure = particlesPressure,
particlesDensity = particlesDensity,
particleIndices = particleIndices,
cellOffsetTable = cellOffsetTableNative,
copyColliders = copyColliders
};
if (cacheIndex > previousParticles.Count - 1)
{
previousParticles.Add(nextParticles);
}
else
{
previousParticles[cacheIndex].hashMap.Dispose();
previousParticles[cacheIndex].particlesPosition.Dispose();
previousParticles[cacheIndex].particlesVelocity.Dispose();
previousParticles[cacheIndex].particlesForces.Dispose();
previousParticles[cacheIndex].particlesPressure.Dispose();
previousParticles[cacheIndex].particlesDensity.Dispose();
previousParticles[cacheIndex].particleIndices.Dispose();
previousParticles[cacheIndex].cellOffsetTable.Dispose();
previousParticles[cacheIndex].copyColliders.Dispose();
}
previousParticles[cacheIndex] = nextParticles;
// Copy the component data to native arrays
CopyComponentData <Position> particlesPositionJob = new CopyComponentData <Position> {
Source = positions, Results = particlesPosition
};
JobHandle particlesPositionJobHandle = particlesPositionJob.Schedule(particleCount, 64, inputDeps);
CopyComponentData <SPHVelocity> particlesVelocityJob = new CopyComponentData <SPHVelocity> {
Source = velocities, Results = particlesVelocity
};
JobHandle particlesVelocityJobHandle = particlesVelocityJob.Schedule(particleCount, 64, inputDeps);
CopyComponentData <SPHCollider> copyCollidersJob = new CopyComponentData <SPHCollider> {
Source = colliders, Results = copyColliders
};
JobHandle copyCollidersJobHandle = copyCollidersJob.Schedule(colliderCount, 64, inputDeps);
MemsetNativeArray <float> particlesPressureJob = new MemsetNativeArray <float> {
Source = particlesPressure, Value = 0.0f
};
JobHandle particlesPressureJobHandle = particlesPressureJob.Schedule(particleCount, 64, inputDeps);
MemsetNativeArray <float> particlesDensityJob = new MemsetNativeArray <float> {
Source = particlesDensity, Value = 0.0f
};
JobHandle particlesDensityJobHandle = particlesDensityJob.Schedule(particleCount, 64, inputDeps);
MemsetNativeArray <int> particleIndicesJob = new MemsetNativeArray <int> {
Source = particleIndices, Value = 0
};
JobHandle particleIndicesJobHandle = particleIndicesJob.Schedule(particleCount, 64, inputDeps);
MemsetNativeArray <float3> particlesForcesJob = new MemsetNativeArray <float3> {
Source = particlesForces, Value = new float3(0, 0, 0)
};
JobHandle particlesForcesJobHandle = particlesForcesJob.Schedule(particleCount, 64, inputDeps);
// Put positions into a hashMap
HashPositions hashPositionsJob = new HashPositions
{
positions = particlesPosition,
hashMap = hashMap.ToConcurrent(),
cellRadius = settings.radius
};
JobHandle hashPositionsJobHandle = hashPositionsJob.Schedule(particleCount, 64, particlesPositionJobHandle);
JobHandle mergedPositionIndicesJobHandle = JobHandle.CombineDependencies(hashPositionsJobHandle, particleIndicesJobHandle);
MergeParticles mergeParticlesJob = new MergeParticles
{
particleIndices = particleIndices
};
JobHandle mergeParticlesJobHandle = mergeParticlesJob.Schedule(hashMap, 64, mergedPositionIndicesJobHandle);
JobHandle mergedMergedParticlesDensityPressure = JobHandle.CombineDependencies(mergeParticlesJobHandle, particlesPressureJobHandle, particlesDensityJobHandle);
// Compute density pressure
ComputeDensityPressure computeDensityPressureJob = new ComputeDensityPressure
{
particlesPosition = particlesPosition,
densities = particlesDensity,
pressures = particlesPressure,
hashMap = hashMap,
cellOffsetTable = cellOffsetTableNative,
settings = settings
};
JobHandle computeDensityPressureJobHandle = computeDensityPressureJob.Schedule(particleCount, 64, mergedMergedParticlesDensityPressure);
JobHandle mergeComputeDensityPressureVelocityForces = JobHandle.CombineDependencies(computeDensityPressureJobHandle, particlesForcesJobHandle, particlesVelocityJobHandle);
// Compute forces
ComputeForces computeForcesJob = new ComputeForces
{
particlesPosition = particlesPosition,
particlesVelocity = particlesVelocity,
particlesForces = particlesForces,
particlesPressure = particlesPressure,
particlesDensity = particlesDensity,
cellOffsetTable = cellOffsetTableNative,
hashMap = hashMap,
settings = settings
};
JobHandle computeForcesJobHandle = computeForcesJob.Schedule(particleCount, 64, mergeComputeDensityPressureVelocityForces);
// Integrate
Integrate integrateJob = new Integrate
{
particlesPosition = particlesPosition,
particlesVelocity = particlesVelocity,
particlesDensity = particlesDensity,
particlesForces = particlesForces
};
JobHandle integrateJobHandle = integrateJob.Schedule(particleCount, 64, computeForcesJobHandle);
JobHandle mergedIntegrateCollider = JobHandle.CombineDependencies(integrateJobHandle, copyCollidersJobHandle);
// Compute Colliders
ComputeColliders computeCollidersJob = new ComputeColliders
{
particlesPosition = particlesPosition,
particlesVelocity = particlesVelocity,
copyColliders = copyColliders,
settings = settings
};
JobHandle computeCollidersJobHandle = computeCollidersJob.Schedule(particleCount, 64, mergedIntegrateCollider);
// Apply positions
ApplyPositions applyPositionsJob = new ApplyPositions
{
particlesPosition = particlesPosition,
particlesVelocity = particlesVelocity,
positions = positions,
velocities = velocities
};
JobHandle applyPositionsJobHandle = applyPositionsJob.Schedule(particleCount, 64, computeCollidersJobHandle);
inputDeps = applyPositionsJobHandle;
}
// Done
uniqueTypes.Clear();
return(inputDeps);
}
protected override JobHandle OnUpdate(JobHandle inputDependencies)
{
Settings settings;
settings.CellRadius = 16;
settings.SeparationWeight = 1;
settings.AlignmentWeight = 1;
settings.TargetWeight = 2;
settings.MaxTargetDistance = 10000;
//settings.ObstacleAversionDistance = 35;
settings.MoveSpeed = 25;
settings.boidRadius = 0.5f;
EntityManager.GetAllUniqueSharedComponentData(uniqueFactions);
int healthCount = healthQuery.CalculateEntityCount();
for (int i = 0; i < prevFrameHashmaps.Count; i++)
{
prevFrameHashmaps[i].Dispose();
}
prevFrameHashmaps.Clear();
for (int index = 0; index < uniqueFactions.Count; index++)
{
boidQuery.SetFilter(uniqueFactions[index]);
int boidCount = boidQuery.CalculateEntityCount();
if (boidCount == 0)
{
continue;
}
var cellIndices = new NativeArray <int>(boidCount, Allocator.TempJob, NativeArrayOptions.UninitializedMemory);
var hashMap = new NativeMultiHashMap <int, int>(boidCount, Allocator.TempJob);
var cellObstacleDistance = new NativeArray <float>(boidCount, Allocator.TempJob, NativeArrayOptions.UninitializedMemory);
var cellCount = new NativeArray <int>(boidCount, Allocator.TempJob, NativeArrayOptions.UninitializedMemory);
var killTrigger = new NativeArray <int>(boidCount, Allocator.TempJob, NativeArrayOptions.UninitializedMemory);
var cellAlignment = new NativeArray <float3>(boidCount, Allocator.TempJob,
NativeArrayOptions.UninitializedMemory);
var cellSeparation = new NativeArray <float3>(boidCount, Allocator.TempJob,
NativeArrayOptions.UninitializedMemory);
var boidsData = new NativeArray <Boid>(boidCount, Allocator.TempJob,
NativeArrayOptions.UninitializedMemory);
var cellTargetPositions = new NativeArray <float3>(boidCount, Allocator.TempJob,
NativeArrayOptions.UninitializedMemory);
var cellObstaclePositions = new NativeArray <float3>(boidCount, Allocator.TempJob,
NativeArrayOptions.UninitializedMemory);
var bulletSpawns = new NativeArray <BulletSpawn>(boidCount, Allocator.TempJob,
NativeArrayOptions.ClearMemory);
var damageDict = new NativeMultiHashMap <int, int>(boidCount, Allocator.TempJob);
var initialCellAlignmentJob = new CopyHeadings {
headings = cellAlignment
};
var initialCellAlignmentJobHandle = initialCellAlignmentJob.Schedule(boidQuery, inputDependencies);
var initialCellSeparationJob = new CopyPositions {
positions = cellSeparation
};
var initialCellSeparationJobHandle = initialCellSeparationJob.Schedule(boidQuery, inputDependencies);
var initialBoidData = new CopyBoids {
boids = boidsData
};
var initialBoidDataJobHandle = initialBoidData.Schedule(boidQuery, inputDependencies);
// Cannot call [DeallocateOnJobCompletion] on Hashmaps yet
prevFrameHashmaps.Add(hashMap);
var hashPositionsJob = new HashPositions {
hashMap = hashMap.AsParallelWriter(),
cellRadius = settings.CellRadius
};
var hashPositionsJobHandle = hashPositionsJob.Schedule(boidQuery, inputDependencies);
var initialCellCountJob = new MemsetNativeArray <int> {
Source = cellCount,
Value = 1
};
var initialCellCountJobHandle = initialCellCountJob.Schedule(boidCount, 64, inputDependencies);
var killTriggerJob = new MemsetNativeArray <int> {
Source = killTrigger,
Value = 0
};
var killTriggerJobHandle = killTriggerJob.Schedule(boidCount, 64, inputDependencies);
var initialCellBarrierJobHandle = JobHandle.CombineDependencies(initialCellAlignmentJobHandle, initialCellSeparationJobHandle, initialCellCountJobHandle);
var initialBoidBarrierJobHandle = JobHandle.CombineDependencies(initialBoidDataJobHandle, killTriggerJobHandle);
var mergeCellsBarrierJobHandle = JobHandle.CombineDependencies(hashPositionsJobHandle, initialCellBarrierJobHandle, initialBoidBarrierJobHandle);
ref PhysicsWorld physicsWorld = ref Unity.Entities.World.Active.GetExistingSystem <BuildPhysicsWorld>().PhysicsWorld;
var commandBuffer = m_Barrier.CreateCommandBuffer().ToConcurrent();
prevFrameHashmaps.Add(damageDict);
var mergeCellsJob = new MergeCells {
cellIndices = cellIndices,
cellObstaclePositions = cellObstaclePositions,
cellTargetPositions = cellTargetPositions,
cellAlignment = cellAlignment,
cellSeparation = cellSeparation,
cellObstacleDistance = cellObstacleDistance,
cellCount = cellCount,
boidsData = boidsData,
killTrigger = killTrigger,
physicsWorld = physicsWorld,
damageDict = damageDict.AsParallelWriter(),
bulletSpawns = bulletSpawns,
commandBuffer = commandBuffer,
bulletPrefab = BulletPrefabAuthoring.Prefab,
//enemyEntityLook = Setup.enemyEntityLook,
groupIndex = math.select(4u, 8u, uniqueFactions[index].Value == 0),
time = Time.time,
settings = settings,
};
var mergeCellsJobHandle = mergeCellsJob.Schedule(hashMap, 64, mergeCellsBarrierJobHandle);
m_Barrier.AddJobHandleForProducer(mergeCellsJobHandle);
var applyBulletSpawnDataJob = new ApplyBulletSpawnData {
bulletSpawns = bulletSpawns,
destroyAtTime = Time.time + 5,
commandBuffer = commandBuffer,
bulletPrefab = BulletPrefabAuthoring.Prefab
};
var applyBulletSpawnDataJobHandle = applyBulletSpawnDataJob.Schedule(boidCount, 64, mergeCellsJobHandle);
m_Barrier.AddJobHandleForProducer(applyBulletSpawnDataJobHandle);
var updateBoidData = new UpdateBoidData {
boidsData = boidsData
};
var updateBoidDataJobHandle = updateBoidData.Schedule(boidQuery, applyBulletSpawnDataJobHandle);
var steerJob = new Steer {
cellIndices = cellIndices,
settings = settings,
cellAlignment = cellAlignment,
cellSeparation = cellSeparation,
cellObstacleDistance = cellObstacleDistance,
cellCount = cellCount,
targetPositions = cellTargetPositions,
obstaclePositions = cellObstaclePositions,
boidsData = boidsData,
dt = Time.deltaTime,
};
var steerJobHandle = steerJob.Schedule(boidQuery, updateBoidDataJobHandle);
var killJob = new Kill {
killTrigger = killTrigger,
commandBuffer = commandBuffer,
};
var killJobHandle = killJob.Schedule(boidQuery, steerJobHandle);
m_Barrier.AddJobHandleForProducer(killJobHandle);
var applyDamageJob = new ApplyDamage {
damageDict = damageDict
};
var applyDamageJobHandle = applyDamageJob.Schedule(healthQuery, mergeCellsJobHandle);
inputDependencies = JobHandle.CombineDependencies(killJobHandle, applyDamageJobHandle, applyBulletSpawnDataJobHandle);
boidQuery.AddDependency(inputDependencies);
}
protected override JobHandle OnUpdate(JobHandle inputDeps)
{
BoidActionSort boidActionsSort = new BoidActionSort();
NonBoidActionSort nonBoidActionSort = new NonBoidActionSort();
EntityManager.GetAllUniqueSharedComponentData(m_UniqueTypes);
int obstacleCount = m_ObstacleGroup.CalculateLength();
int targetCount = m_TargetGroup.CalculateLength();
// Ingore typeIndex 0, can't use the default for anything meaningful.
for (int typeIndex = 1; typeIndex < m_UniqueTypes.Count; typeIndex++)
{
MainBoid uniqueBoidConfig = m_UniqueTypes[typeIndex];
m_BoidGroup.SetFilter(uniqueBoidConfig);
int boidCount = m_BoidGroup.CalculateLength();
//some of this can be cached from last time to reduce component data calls.
int cacheIndex = typeIndex - 1;
//this was causing an undisposed allocation error
//NativeArray<JobHandle> initializationJobHandles = new NativeArray<JobHandle>(5, Allocator.Temp);
NativeArray <Heading> boidHeadings = m_BoidGroup.ToComponentDataArray <Heading>(Allocator.TempJob, out JobHandle initialCellAlignmentJobHandle);
//TODO: make this into a 2d array so that the 2d positions doesnt have to be calculated all the time.
NativeArray <Translation> boidPositions = m_BoidGroup.ToComponentDataArray <Translation>(Allocator.TempJob, out JobHandle initialCellSeparationJobHandle);
NativeArray <Translation> copyTargetPositions = m_TargetGroup.ToComponentDataArray <Translation>(Allocator.TempJob, out JobHandle copyTargetPositionsJobHandle);
NativeArray <Translation> copyObstaclePositions = m_ObstacleGroup.ToComponentDataArray <Translation>(Allocator.TempJob, out JobHandle copyObstaclePositionsJobHandle);
// initializationJobHandles[0] = initialCellAlignmentJobHandle;
// initializationJobHandles[1] = initialCellSeparationJobHandle;
// initializationJobHandles[2] = copyTargetPositionsJobHandle;
// initializationJobHandles[3] = copyObstaclePositionsJobHandle;
NativeArray <BoidAction> orderedBoidActions = new NativeArray <BoidAction>(uniqueBoidConfig.boidActions.Length, Allocator.TempJob);
orderedBoidActions.CopyFrom(uniqueBoidConfig.boidActions);
NativeArray <NonBoidAction> orderedNonBoidActions = new NativeArray <NonBoidAction>(uniqueBoidConfig.boidActions.Length, Allocator.TempJob);
orderedBoidActions.CopyFrom(uniqueBoidConfig.boidActions);
orderedNonBoidActions.Sort(nonBoidActionSort);
orderedBoidActions.Sort(boidActionsSort);
var hashMap = new NativeHashMap <float3, int>(boidCount, Allocator.TempJob);
var hashPositionsJob = new HashPositions
{
hashMap = hashMap.ToConcurrent()
};
var hashPositionsJobHandle = hashPositionsJob.Schedule(m_BoidGroup, inputDeps);
// initializationJobHandles[4] = hashPositionsJobHandle;
var nextCells = new PrevCells
{
hashMap = hashMap,
boidHeadings = boidHeadings,
boidPositions = boidPositions,
copyObstaclePositions = copyObstaclePositions,
copyTargetPositions = copyTargetPositions,
orderedBoidActions = orderedBoidActions,
orderedNonBoidActions = orderedNonBoidActions,
};
if (cacheIndex > (m_PrevCells.Count - 1))
{
m_PrevCells.Add(nextCells);
}
else
{
m_PrevCells[cacheIndex].hashMap.Dispose();
m_PrevCells[cacheIndex].copyTargetPositions.Dispose();
m_PrevCells[cacheIndex].copyObstaclePositions.Dispose();
m_PrevCells[cacheIndex].boidHeadings.Dispose();
m_PrevCells[cacheIndex].boidPositions.Dispose();
m_PrevCells[cacheIndex].orderedBoidActions.Dispose();
m_PrevCells[cacheIndex].orderedNonBoidActions.Dispose();
}
m_PrevCells[cacheIndex] = nextCells;
JobHandle initialCellBarrierJobHandle = JobHandle.CombineDependencies(initialCellAlignmentJobHandle, initialCellSeparationJobHandle, copyTargetPositionsJobHandle);
JobHandle copyTargetObstacleBarrierJobHandle = JobHandle.CombineDependencies(initialCellBarrierJobHandle, copyObstaclePositionsJobHandle, hashPositionsJobHandle);
Steer steerJob = new Steer
{
// boidActionFunctions = boidActionFunctions,
//boidConfig = uniqueBoidConfig,
boidIndexs = hashMap,
boidHeadings = boidHeadings,
boidPositions = boidPositions,
orderedBoidActions = orderedBoidActions,
orderedNonBoidActions = orderedNonBoidActions,
targetPositions = copyTargetPositions,
obstaclePositions = copyObstaclePositions,
dt = Time.deltaTime
};
JobHandle steerJobHandle = steerJob.Schedule(m_BoidGroup, copyTargetObstacleBarrierJobHandle);
inputDeps = steerJobHandle;
m_BoidGroup.AddDependency(inputDeps);
}
m_UniqueTypes.Clear();
return(inputDeps);
}
//La data del sphereParticle es compartiiiida
protected override JobHandle OnUpdate(JobHandle inputDeps)
{
if (cameraTransform == null)
{
cameraTransform = GameObject.Find("Main Camera").transform;
}
EntityManager.GetAllUniqueSharedComponentData(uniqueTypes);
ComponentDataArray <SMBCollider> colliders = SMBColliderGroup.GetComponentDataArray <SMBCollider>();
int colliderCount = colliders.Length;
for (int typeIndex = 1; typeIndex < uniqueTypes.Count; typeIndex++)
{
// Get the current chunk setting
SMBProperties settings = uniqueTypes[typeIndex];
//SMBDestination smbdestination = _destination[typeIndex];
SMBCharacterGroup.SetFilter(settings);
// Cache the data
ComponentDataArray <Position> positions = SMBCharacterGroup.GetComponentDataArray <Position>();
ComponentDataArray <SMBVelocity> velocities = SMBCharacterGroup.GetComponentDataArray <SMBVelocity>();
ComponentDataArray <SMBDestination> SMBdestinations = SMBCharacterGroup.GetComponentDataArray <SMBDestination>();
ComponentDataArray <SMBSspeed> SMBSspeeds = SMBCharacterGroup.GetComponentDataArray <SMBSspeed>();
ComponentDataArray <SMBPath> indexPaths = SMBCharacterGroup.GetComponentDataArray <SMBPath>();
int cacheIndex = typeIndex - 1;
int particleCount = positions.Length;
NativeMultiHashMap <int, int> hashMap = new NativeMultiHashMap <int, int>(particleCount, Allocator.TempJob);
NativeArray <Position> particlesPosition = new NativeArray <Position>(particleCount, Allocator.TempJob, NativeArrayOptions.UninitializedMemory);
NativeArray <Position> finalposition = new NativeArray <Position>(particleCount, Allocator.TempJob, NativeArrayOptions.UninitializedMemory);
NativeArray <SMBVelocity> particlesVelocity = new NativeArray <SMBVelocity>(particleCount, Allocator.TempJob, NativeArrayOptions.UninitializedMemory);
NativeArray <SMBDestination> particlesDestination = new NativeArray <SMBDestination>(particleCount, Allocator.TempJob, NativeArrayOptions.UninitializedMemory);
NativeArray <SMBSspeed> particlesSspeed = new NativeArray <SMBSspeed>(particleCount, Allocator.TempJob, NativeArrayOptions.UninitializedMemory);
NativeArray <SMBPath> particlesindexPaths = new NativeArray <SMBPath>(particleCount, Allocator.TempJob, NativeArrayOptions.UninitializedMemory);
NativeArray <float3> particlesForces = new NativeArray <float3>(particleCount, Allocator.TempJob, NativeArrayOptions.UninitializedMemory);
NativeArray <float> particlesPressure = new NativeArray <float>(particleCount, Allocator.TempJob, NativeArrayOptions.UninitializedMemory);
NativeArray <float> particlesDensity = new NativeArray <float>(particleCount, Allocator.TempJob, NativeArrayOptions.UninitializedMemory);
NativeArray <int> particleIndices = new NativeArray <int>(particleCount, Allocator.TempJob, NativeArrayOptions.UninitializedMemory);
NativeArray <int> cellOffsetTableNative = new NativeArray <int>(cellOffsetTable, Allocator.TempJob);
NativeArray <SMBCollider> copyColliders = new NativeArray <SMBCollider>(colliderCount, Allocator.TempJob, NativeArrayOptions.UninitializedMemory);
// Add new or dispose previous particle chunks
PreviousParticle nextParticles = new PreviousParticle
{
hashMap = hashMap,
particlesPosition = particlesPosition,
particlesVelocity = particlesVelocity,
particlesDestination = particlesDestination,
particlesSspeed = particlesSspeed,
particlesindexPaths = particlesindexPaths,
particlesForces = particlesForces,
particlesPressure = particlesPressure,
particlesDensity = particlesDensity,
particleIndices = particleIndices,
cellOffsetTable = cellOffsetTableNative,
copyColliders = copyColliders
};
if (cacheIndex > previousParticles.Count - 1)
{
previousParticles.Add(nextParticles);
}
else
{
previousParticles[cacheIndex].hashMap.Dispose();
previousParticles[cacheIndex].particlesPosition.Dispose();
previousParticles[cacheIndex].particlesVelocity.Dispose();
previousParticles[cacheIndex].particlesDestination.Dispose();
previousParticles[cacheIndex].particlesSspeed.Dispose();
previousParticles[cacheIndex].particlesindexPaths.Dispose();
previousParticles[cacheIndex].particlesForces.Dispose();
previousParticles[cacheIndex].particlesPressure.Dispose();
previousParticles[cacheIndex].particlesDensity.Dispose();
previousParticles[cacheIndex].particleIndices.Dispose();
previousParticles[cacheIndex].cellOffsetTable.Dispose();
previousParticles[cacheIndex].copyColliders.Dispose();
}
previousParticles[cacheIndex] = nextParticles;
// Copy the component data to native arrays
CopyComponentData <Position> particlesPositionJob = new CopyComponentData <Position> {
Source = positions, Results = particlesPosition
};
JobHandle particlesPositionJobHandle = particlesPositionJob.Schedule(particleCount, 64, inputDeps);
CopyComponentData <SMBVelocity> particlesVelocityJob = new CopyComponentData <SMBVelocity> {
Source = velocities, Results = particlesVelocity
};
JobHandle particlesVelocityJobHandle = particlesVelocityJob.Schedule(particleCount, 64, inputDeps);
CopyComponentData <SMBDestination> particlesDestinationJob = new CopyComponentData <SMBDestination> {
Source = SMBdestinations, Results = particlesDestination
};
JobHandle particlesDestinationJobHandle = particlesDestinationJob.Schedule(particleCount, 64, inputDeps);
CopyComponentData <SMBSspeed> particlesSspeedJob = new CopyComponentData <SMBSspeed> {
Source = SMBSspeeds, Results = particlesSspeed
};
JobHandle particlesSspeedJobHandle = particlesSspeedJob.Schedule(particleCount, 64, inputDeps);
CopyComponentData <SMBCollider> copyCollidersJob = new CopyComponentData <SMBCollider> {
Source = colliders, Results = copyColliders
};
JobHandle copyCollidersJobHandle = copyCollidersJob.Schedule(colliderCount, 64, inputDeps);
MemsetNativeArray <float> particlesPressureJob = new MemsetNativeArray <float> {
Source = particlesPressure, Value = 0.0f
};
JobHandle particlesPressureJobHandle = particlesPressureJob.Schedule(particleCount, 64, inputDeps);
MemsetNativeArray <float> particlesDensityJob = new MemsetNativeArray <float> {
Source = particlesDensity, Value = 0.0f
};
JobHandle particlesDensityJobHandle = particlesDensityJob.Schedule(particleCount, 64, inputDeps);
MemsetNativeArray <int> particleIndicesJob = new MemsetNativeArray <int> {
Source = particleIndices, Value = 0
};
JobHandle particleIndicesJobHandle = particleIndicesJob.Schedule(particleCount, 64, inputDeps);
MemsetNativeArray <float3> particlesForcesJob = new MemsetNativeArray <float3> {
Source = particlesForces, Value = new float3(0, 0, 0)
};
JobHandle particlesForcesJobHandle = particlesForcesJob.Schedule(particleCount, 64, inputDeps);
MemsetNativeArray <Position> finalpositionJob = new MemsetNativeArray <Position> {
Source = finalposition, Value = new Position {
Value = new float3()
}
};
JobHandle finalpositionJobHandle = finalpositionJob.Schedule(particleCount, 64, inputDeps);
//JobHandle computepathsJobHandle = particlesPositionJobHandle;
if (first)
{
int index = 0, firsTriangle = 1;
for (int i = 0; i < particleCount; ++i)
{
astar.cleanStructures();
astar.setOrigin(positions[i].Value);
astar.setDestination(SMBdestinations[i].destination);
astar.trianglePath2();
//Allpaths.AddRange(astar.trianglePath2());
wayPointsPath.AddRange(astar.getWayPoints());
int aux = wayPointsPath.Count;
if (aux - index == 0)
{
firsTriangle = -1;
}
else
{
firsTriangle = 1;
}
Unity.Mathematics.Random ola = new Unity.Mathematics.Random(1);
indexPaths[i] = new SMBPath {
indexIni = index, indexFin = aux, NextPoint = new float3(), Firsttriangle = firsTriangle, recalculate = ola.NextInt(15), fordwarDir = new float3()
};
index = aux;
}
first = false;
}
//Una vez llegado al destino ir a otro, funciona pero va muuuuy lento
/*else
* {
* int index = 0, firsTriangle = 1, aux = 0;
* int diff = 0;
* for (int i = 0; i < particleCount; ++i)
* {
* index = indexPaths[i].indexIni + diff;
* aux = indexPaths[i].indexFin + diff;
* float3 NextPoint = indexPaths[i].NextPoint, fordwarDir = indexPaths[i].fordwarDir;
* int recalculate = indexPaths[i].recalculate;
* firsTriangle = indexPaths[i].Firsttriangle;
* if (SMBdestinations[i].finished == 1)
* {
* firsTriangle = 1;
* astar.cleanStructures();
* astar.setOrigin(positions[i].Value);
* astar.setDestination(SMBdestinations[i].destinations2);
* astar.trianglePath2();
* int count = 0;
* if (i == 0)
* {
* wayPointsPath.RemoveRange(0, indexPaths[i].indexFin);
* index = 0;
* count = indexPaths[i].indexFin;
* }
* else
* {
* index = indexPaths[i - 1].indexFin;
* count = indexPaths[i].indexFin + diff - indexPaths[i - 1].indexFin;
* wayPointsPath.RemoveRange(indexPaths[i - 1].indexFin, count);
* }
* List<SMBWaypoint> wayaux = astar.getWayPoints();
* wayPointsPath.InsertRange(index, wayaux);
*
* aux = wayaux.Count;
*
* indexPaths[i] = new SMBPath { indexIni = index, indexFin = aux + index, NextPoint = new float3(), Firsttriangle = firsTriangle, recalculate = recalculate, fordwarDir = new float3() };
* SMBdestinations[i] = new SMBDestination {finished = 2, destinations2 = SMBdestinations[i].destinations2, destination = SMBdestinations[i].destination };
* diff += aux - count;
* }
* else indexPaths[i] = new SMBPath { indexIni = index, indexFin = aux, NextPoint = NextPoint, Firsttriangle = firsTriangle, recalculate = recalculate, fordwarDir = fordwarDir };
* }
* }*/
NativeArray <SMBWaypoint> NwayPointspaths = new NativeArray <SMBWaypoint>(wayPointsPath.Count, Allocator.TempJob);
//MemsetNativeArray<SMBWaypoint> waypointsJob = new MemsetNativeArray<SMBWaypoint> { Source = NwayPointspaths, Value = new SMBWaypoint { } };
//NativeArray<int>.Copy(Allpaths.ToArray(), paths);
NativeArray <SMBWaypoint> .Copy(wayPointsPath.ToArray(), NwayPointspaths, wayPointsPath.Count);
//CopyComponentData<SMBDestination> particlesDestinationJob = new CopyComponentData<SMBDestination> { Source = SMBdestinations, Results = particlesDestination };
//JobHandle particlesDestinationJobHandle = particlesDestinationJob.Schedule(particleCount, 64, inputDeps);
CopyComponentData <SMBPath> particlesIndexPathJob = new CopyComponentData <SMBPath> {
Source = indexPaths, Results = particlesindexPaths
};
JobHandle particlesIndexPathJobHandle = particlesIndexPathJob.Schedule(particleCount, 64, inputDeps);
// Put positions into a hashMap
HashPositions hashPositionsJob = new HashPositions
{
positions = particlesPosition,
hashMap = hashMap.ToConcurrent(),
cellRadius = settings.radius
};
JobHandle hashPositionsJobHandle = hashPositionsJob.Schedule(particleCount, 64, particlesPositionJobHandle);
JobHandle mergedPositionIndicesJobHandle = JobHandle.CombineDependencies(hashPositionsJobHandle, particleIndicesJobHandle);
MergeParticles mergeParticlesJob = new MergeParticles
{
particleIndices = particleIndices
};
JobHandle mergeParticlesJobHandle = mergeParticlesJob.Schedule(hashMap, 64, mergedPositionIndicesJobHandle);
JobHandle mergedMergedParticlesDensityPressure = JobHandle.CombineDependencies(mergeParticlesJobHandle, particlesPressureJobHandle, particlesDensityJobHandle);
// Compute density pressure
ComputeDensityPressure computeDensityPressureJob = new ComputeDensityPressure
{
particlesPosition = particlesPosition,
densities = particlesDensity,
pressures = particlesPressure,
hashMap = hashMap,
cellOffsetTable = cellOffsetTableNative,
settings = settings
};
JobHandle computeDensityPressureJobHandle = computeDensityPressureJob.Schedule(particleCount, 64, mergedMergedParticlesDensityPressure);
JobHandle mergeComputeDensityPressureVelocityForces = JobHandle.CombineDependencies(computeDensityPressureJobHandle, particlesForcesJobHandle, particlesVelocityJobHandle);
// Compute forces
ComputeForces computeForcesJob = new ComputeForces
{
particlesPosition = particlesPosition,
particlesVelocity = particlesVelocity,
particlesForces = particlesForces,
particlesPressure = particlesPressure,
particlesDensity = particlesDensity,
cellOffsetTable = cellOffsetTableNative,
hashMap = hashMap,
settings = settings
};
JobHandle computeForcesJobHandle = computeForcesJob.Schedule(particleCount, 64, mergeComputeDensityPressureVelocityForces);
// Integrate
Integrate integrateJob = new Integrate
{
particlesPosition = particlesPosition,
particlesVelocity = particlesVelocity,
particlesDensity = particlesDensity,
particlesForces = particlesForces
};
JobHandle integrateJobHandle = integrateJob.Schedule(particleCount, 64, computeForcesJobHandle);
JobHandle mergedIntegrateCollider = JobHandle.CombineDependencies(integrateJobHandle, copyCollidersJobHandle);
//JobHandle mergedIntegrateCollider = JobHandle.CombineDependencies(particlesPositionJobHandle, particlesVelocityJobHandle, copyCollidersJobHandle);
// Compute Colliders
ComputeColliders computeCollidersJob = new ComputeColliders
{
particlesPosition = particlesPosition,
particlesVelocity = particlesVelocity,
copyColliders = copyColliders,
settings = settings
};
JobHandle computeCollidersJobHandle = computeCollidersJob.Schedule(particleCount, 64, mergedIntegrateCollider);
JobHandle allReady = JobHandle.CombineDependencies(computeCollidersJobHandle, particlesIndexPathJobHandle, particlesDestinationJobHandle);
ComputeNewPoint computeNewPointJob = new ComputeNewPoint
{
particlesPosition = particlesPosition,
waypoints = NwayPointspaths,
indexPaths = particlesindexPaths,
particlesDestination = particlesDestination
};
JobHandle computeNewPointJobHandle = computeNewPointJob.Schedule(particleCount, 64, allReady);
computeNewPointJobHandle = JobHandle.CombineDependencies(computeNewPointJobHandle, finalpositionJobHandle);
RecomputeNewPoint RecomputeNewPointJob = new RecomputeNewPoint
{
particlesPosition = particlesPosition,
waypoints = NwayPointspaths,
indexPaths = particlesindexPaths
};
JobHandle RecomputeNewPointJobHandle = RecomputeNewPointJob.Schedule(particleCount, 64, computeNewPointJobHandle);
JobHandle preparedToComputePositions = JobHandle.CombineDependencies(RecomputeNewPointJobHandle, particlesSspeedJobHandle);
ComputePosition computePositionJob = new ComputePosition
{
particlesPosition = particlesPosition,
particlesDestination = particlesDestination,
particlesSspeed = particlesSspeed,
particlesVelocity = particlesVelocity,
indexPaths = particlesindexPaths,
hashMap = hashMap,
settings = settings,
cellOffsetTable = cellOffsetTableNative,
finalPosition = finalposition
};
JobHandle comptePositionJobHandle = computePositionJob.Schedule(particleCount, 64, preparedToComputePositions);
// Apply positions
ApplyPositions applyPositionsJob = new ApplyPositions
{
particlesPosition = finalposition,
particlesVelocity = particlesVelocity,
particlesindexPaths = particlesindexPaths,
//particlesDestination = particlesDestination,
particlesSspeed = particlesSspeed,
positions = positions,
velocities = velocities,
indexPaths = indexPaths,
SMBSspeeds = SMBSspeeds,
//SMBdestinations = SMBdestinations,
};
JobHandle applyPositionsJobHandle = applyPositionsJob.Schedule(particleCount, 64, comptePositionJobHandle);
inputDeps = applyPositionsJobHandle;
inputDeps.Complete();
NwayPointspaths.Dispose();
finalposition.Dispose();
}
// Done
uniqueTypes.Clear();
return(inputDeps);
}
protected override JobHandle OnUpdate(JobHandle inputDependencies)
{
EntityManager.GetAllUniqueSharedComponentData(uniqueTypes);
var obstacleCount = obstacleQuery.CalculateEntityCount();
var targetCount = targetQuery.CalculateEntityCount();
for (int i = 0; i < prevFrameHashmaps.Count; i++)
{
prevFrameHashmaps[i].Dispose();
}
prevFrameHashmaps.Clear();
for (int hordeVariantIndex = 0; hordeVariantIndex < uniqueTypes.Count; hordeVariantIndex++)
{
var settings = uniqueTypes[hordeVariantIndex];
hordeQuery.SetFilter(settings);
var hordeCount = hordeQuery.CalculateEntityCount();
if (hordeCount == 0)
{
continue;
}
//Debug.Log(hordeCount);
#region Initial vars
var hashMap = new NativeMultiHashMap <int, int>(hordeCount, Allocator.TempJob);
var cellIndices = new NativeArray <int>(hordeCount, Allocator.TempJob, NativeArrayOptions.UninitializedMemory);
var cellObstaclePositionIndex = new NativeArray <int>(hordeCount, Allocator.TempJob, NativeArrayOptions.UninitializedMemory);
var cellTargetPositionIndex = new NativeArray <int>(hordeCount, Allocator.TempJob, NativeArrayOptions.UninitializedMemory);
var cellCount = new NativeArray <int>(hordeCount, Allocator.TempJob, NativeArrayOptions.UninitializedMemory);
var cellObstacleDistance = new NativeArray <float>(hordeCount, Allocator.TempJob, NativeArrayOptions.UninitializedMemory);
var cellAlignment = new NativeArray <float3>(hordeCount, Allocator.TempJob, NativeArrayOptions.UninitializedMemory);
var cellSeparation = new NativeArray <float3>(hordeCount, Allocator.TempJob, NativeArrayOptions.UninitializedMemory);
var copyTargetPositions = new NativeArray <float3>(targetCount, Allocator.TempJob, NativeArrayOptions.UninitializedMemory);
var copyObstaclePositions = new NativeArray <float3>(obstacleCount, Allocator.TempJob, NativeArrayOptions.UninitializedMemory);
#endregion
#region Initial jobs
var initialCellAlignmentJob = new CopyHeadings {
headings = cellAlignment
};
var initialCellAlignmentJobHandle = initialCellAlignmentJob.Schedule(hordeQuery, inputDependencies);
var initialCellSeparationJob = new CopyPositions {
positions = cellSeparation
};
var initialCellSeparationJobHandle = initialCellSeparationJob.Schedule(hordeQuery, inputDependencies);
var copyTargetPositionsJob = new CopyPositions {
positions = copyTargetPositions
};
var copyTargetPositionsJobHandle = copyTargetPositionsJob.Schedule(targetQuery, inputDependencies);
var copyObstaclePositionsJob = new CopyPositions {
positions = copyObstaclePositions
};
var copyObstaclePositionsJobHandle = copyObstaclePositionsJob.Schedule(obstacleQuery, inputDependencies);
prevFrameHashmaps.Add(hashMap);
var hashPositionsJob = new HashPositions
{
hashMap = hashMap.AsParallelWriter(),
cellRadius = settings.CellRadius
};
var hashPositionsJobHandle = hashPositionsJob.Schedule(hordeQuery, inputDependencies);
var initialCellCountJob = new MemsetNativeArray <int>
{
Source = cellCount,
Value = 1
};
var initialCellCountJobHandle = initialCellCountJob.Schedule(hordeCount, 64, inputDependencies);
#endregion
var initialCellBarrierJobHandle = JobHandle.CombineDependencies(initialCellAlignmentJobHandle, initialCellSeparationJobHandle, initialCellCountJobHandle);
var copyTargetObstacleBarrierJobHandle = JobHandle.CombineDependencies(copyTargetPositionsJobHandle, copyObstaclePositionsJobHandle);
var mergeCellsBarrierJobHandle = JobHandle.CombineDependencies(hashPositionsJobHandle, initialCellBarrierJobHandle, copyTargetObstacleBarrierJobHandle);
var mergeCellsJob = new MergeCells
{
cellIndices = cellIndices,
cellAlignment = cellAlignment,
cellSeparation = cellSeparation,
cellObstacleDistance = cellObstacleDistance,
cellObstaclePositionIndex = cellObstaclePositionIndex,
cellTargetPositionIndex = cellTargetPositionIndex,
cellCount = cellCount,
targetPositions = copyTargetPositions,
obstaclePositions = copyObstaclePositions
};
var mergeCellsJobHandle = mergeCellsJob.Schedule(hashMap, 64, mergeCellsBarrierJobHandle);
var steerJob = new Steer
{
cellIndices = cellIndices,
settings = settings,
cellAlignment = cellAlignment,
cellSeparation = cellSeparation,
cellObstacleDistance = cellObstacleDistance,
cellObstaclePositionIndex = cellObstaclePositionIndex,
cellTargetPositionIndex = cellTargetPositionIndex,
cellCount = cellCount,
targetPositions = copyTargetPositions,
obstaclePositions = copyObstaclePositions,
dt = Time.deltaTime,
};
var steerJobHandle = steerJob.Schedule(hordeQuery, mergeCellsJobHandle);
inputDependencies = steerJobHandle;
hordeQuery.AddDependency(inputDependencies);
}
uniqueTypes.Clear();
return(inputDependencies);
}
protected override JobHandle OnUpdate(JobHandle inputDeps)
{
var boidCount = m_Boids.boidTag.Length;
var cellIndices = new NativeArray <int>(boidCount, Allocator.TempJob, NativeArrayOptions.UninitializedMemory);
var hashMap = new NativeMultiHashMap <int, int>(boidCount, Allocator.TempJob);
var copyTargetPositions = new NativeArray <Position>(m_Boids.boidTarget.Length, Allocator.TempJob, NativeArrayOptions.UninitializedMemory);
var copyObstaclePositions = new NativeArray <Position>(m_Obstacles.obstaclePositions.Length, Allocator.TempJob, NativeArrayOptions.UninitializedMemory);
var cellSeparation = new NativeArray <Position>(boidCount, Allocator.TempJob, NativeArrayOptions.UninitializedMemory);
var cellObstacleDistance = new NativeArray <float>(boidCount, Allocator.TempJob, NativeArrayOptions.UninitializedMemory);
var cellObstaclePositionIndex = new NativeArray <int>(boidCount, Allocator.TempJob, NativeArrayOptions.UninitializedMemory);
var cellCount = new NativeArray <int>(boidCount, Allocator.TempJob, NativeArrayOptions.UninitializedMemory);
var hashPositionsJob = new HashPositions
{
positions = m_Boids.boidPositions,
hashMap = hashMap,
cellRadius = ECSBootstrapper.boidSettings.cellRadius
};
var hashPositionsJobHandle = hashPositionsJob.Schedule(boidCount, 64, inputDeps);
var initialCellSeparationJob = new CopyComponentData <Position>
{
Source = m_Boids.boidPositions,
Results = cellSeparation
};
var initialCellSeparationJobHandle = initialCellSeparationJob.Schedule(boidCount, 64, inputDeps);
var initialCellCountJob = new MemsetNativeArray <int>
{
Source = cellCount,
Value = 1
};
var initialCellCountJobHandle = initialCellCountJob.Schedule(boidCount, 64, inputDeps);
var initialCellBarrierJobHandle = JobHandle.CombineDependencies(initialCellSeparationJobHandle, initialCellCountJobHandle);
var copyTargetPositionJob = new CopyTargetPositions
{
Source = m_Boids.boidTarget,
Results = copyTargetPositions
};
var copyTargetPositionsJobHandle = copyTargetPositionJob.Schedule(m_Boids.boidTarget.Length, 2, inputDeps);
var copyObstaclePositionsJob = new CopyComponentData <Position>
{
Source = m_Obstacles.obstaclePositions,
Results = copyObstaclePositions
};
var copyObstaclePositionsJobHandle = copyObstaclePositionsJob.Schedule(m_Obstacles.obstaclePositions.Length, 2, inputDeps);
var copyTargetObstacleBarrierJobHandle = JobHandle.CombineDependencies(copyTargetPositionsJobHandle, copyObstaclePositionsJobHandle);
var mergeCellsBarrierJobHandle = JobHandle.CombineDependencies(hashPositionsJobHandle, initialCellBarrierJobHandle, copyTargetObstacleBarrierJobHandle);
var mergeCellsJob = new MergeCells
{
cellIndices = cellIndices,
cellSeparation = cellSeparation,
cellObstacleDistance = cellObstacleDistance,
cellObstaclePositionIndex = cellObstaclePositionIndex,
cellCount = cellCount,
obstaclePositions = copyObstaclePositions
};
var mergeCellsJobHandle = mergeCellsJob.Schedule(hashMap, 64, mergeCellsBarrierJobHandle);
var steerJob = new Steer
{
cellIndices = cellIndices, //D
settings = ECSBootstrapper.boidSettings,
cellSeparation = cellSeparation,
cellObstacleDistance = cellObstacleDistance,
cellObstaclePositionIndex = cellObstaclePositionIndex,
cellCount = cellCount,
targetPositions = copyTargetPositions,
obstaclePositions = copyObstaclePositions,
dt = Time.deltaTime,
positions = m_Boids.boidPositions,
headings = m_Boids.boidHeadings,
};
var steerJobHandle = steerJob.Schedule(boidCount, 64, mergeCellsJobHandle);
steerJobHandle.Complete();
cellIndices.Dispose();
hashMap.Dispose();
copyTargetPositions.Dispose();
copyObstaclePositions.Dispose();
cellSeparation.Dispose();
cellObstacleDistance.Dispose();
cellObstaclePositionIndex.Dispose();
cellCount.Dispose();
return(inputDeps);
}
