protected override void OnUpdate()
        {
            if (m_Requests == null || m_Requests.Count == 0)
            {
                return;
            }

            var handle = JobHandle.CombineDependencies(Dependency, m_BuildPhysicsWorldSystem.GetOutputDependency());

            JobHandle combinedJobs = handle;

            for (int i = 0; i < m_Requests.Count; i++)
            {
                JobHandle rcj = new RaycastJob
                {
                    Results          = m_Results[0].PixelData.AsWriter(),
                    Request          = m_Requests[0],
                    World            = m_BuildPhysicsWorldSystem.PhysicsWorld.CollisionWorld,
                    NumDynamicBodies = m_BuildPhysicsWorldSystem.PhysicsWorld.NumDynamicBodies
                }.Schedule(m_Results[0].PixelData.ForEachCount, 1, handle);
                rcj.Complete(); //<todo.eoin How can we properly wait on this task when reading results?
                combinedJobs = JobHandle.CombineDependencies(combinedJobs, rcj);
            }

            m_Requests.Clear();
            m_Results.Clear();

            Dependency = combinedJobs;
        }
        protected override JobHandle OnUpdate(JobHandle inputDeps)
        {
            if (m_Requests == null || m_Requests.Count == 0)
            {
                return(inputDeps);
            }

            inputDeps = JobHandle.CombineDependencies(inputDeps, m_BuildPhysicsWorldSystem.FinalJobHandle);

            JobHandle combinedJobs = inputDeps;

            for (int i = 0; i < m_Requests.Count; i++)
            {
                JobHandle rcj = new RaycastJob
                {
                    Results          = m_Results[0].PixelData,
                    Request          = m_Requests[0],
                    World            = m_BuildPhysicsWorldSystem.PhysicsWorld.CollisionWorld,
                    NumDynamicBodies = m_BuildPhysicsWorldSystem.PhysicsWorld.NumDynamicBodies
                }.Schedule(m_Results[0].PixelData.ForEachCount, 1, inputDeps);
                rcj.Complete(); //<todo.eoin How can we properly wait on this task when reading results?
                combinedJobs = JobHandle.CombineDependencies(combinedJobs, rcj);
            }

            m_Requests.Clear();
            m_Results.Clear();

            return(combinedJobs);
        }
Пример #3
0
        protected override void OnUpdate()
        {
            if (m_Requests == null || m_Requests.Count == 0)
            {
                return;
            }

            Dependency = JobHandle.CombineDependencies(Dependency, m_BuildPhysicsWorldSystem.GetOutputDependency());

            JobHandle combinedJobs = Dependency;

            for (int i = 0; i < m_Requests.Count; i++)
            {
                JobHandle rcj = new RaycastJob
                {
                    Results          = m_Results[0].PixelData.AsWriter(),
                    Request          = m_Requests[0],
                    World            = m_BuildPhysicsWorldSystem.PhysicsWorld.CollisionWorld,
                    NumDynamicBodies = m_BuildPhysicsWorldSystem.PhysicsWorld.NumDynamicBodies
                }.Schedule(m_Results[0].PixelData.ForEachCount, 1, Dependency);
                combinedJobs = JobHandle.CombineDependencies(combinedJobs, rcj);
            }

            m_Requests.Clear();
            m_Results.Clear();

            Dependency = combinedJobs;

            m_OutputDependency = Dependency;
            // Inform next system in the pipeline of its dependency
            m_BuildPhysicsWorldSystem.AddInputDependencyToComplete(m_OutputDependency);
        }
Пример #4
0
        protected override JobHandle OnUpdate(JobHandle inputDeps)
        {
            var job = new RaycastJob
            {
                quadrants = _quadrantSystem.GetQuadrantAccess()
            };

            return(job.Schedule(this, inputDeps));
        }
    public static JobHandle ScheduleBatchRayCast(CollisionWorld world, NativeArray <RaycastInput> inputs, NativeArray <RaycastHit> results, JobHandle inputDeps)
    {
        JobHandle rcj = new RaycastJob {
            Inputs  = inputs,
            Results = results,
            World   = world,
        }.Schedule(inputs.Length, 4, inputDeps);

        return(rcj);
    }
    public static JobHandle ScheduleBatchRayCast(CollisionWorld world, NativeArray <RaycastInput> inputs, NativeArray <Unity.Physics.RaycastHit> results, JobHandle dependency)
    {
        JobHandle rcj = new RaycastJob
        {
            inputs  = inputs,
            results = results,
            world   = world
        }.Schedule(inputs.Length, 100, dependency);

        return(rcj);
    }
        public JobHandle ScheduleBatchRayCast(NativeArray <RaycastInput> inputs, NativeArray <RaycastHit> results)
        {
            JobHandle rcj = new RaycastJob
            {
                Inputs  = inputs,
                Results = results,
                World   = m_physicsWorldSystem.PhysicsWorld.CollisionWorld
            }.Schedule(inputs.Length, 5);

            return(rcj);
        }
Пример #8
0
        public static JobHandle ScheduleRaycast(CollisionWorld _collisionWorld, NativeArray <RaycastInput> _raycastInputs, NativeArray <RaycastHit> _raycastHits)
        {
            var raycastJob = new RaycastJob()
            {
                m_collisionWorld = _collisionWorld,
                m_raycastInputs  = _raycastInputs,
                m_results        = _raycastHits
            };

            JobHandle jobHandle = raycastJob.Schedule(_raycastInputs.Length, 1);

            return(jobHandle);
        }