Exemple #1
0
    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);
    }
Exemple #2
0
    //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);
    }