protected override void OnUpdate()
    {
        // Complete the simulation
        Dependency.Complete();

        NativeList <TriggerEvent> triggerEvents = new NativeList <TriggerEvent>(Allocator.TempJob);

        var collectTriggerEventsJob = new CollectTriggerEventsJob
        {
            m_TriggerEvents = triggerEvents
        };

        // Collect all events
        var handle = collectTriggerEventsJob.Schedule(m_StepPhysicsWorldSystem.Simulation, Dependency);

        handle.Complete();

        var physicsWorld = m_BuildPhysicsWorldSystem.PhysicsWorld;
        int expectedNumberOfTriggerEvents = 0;

        Entities
        .WithName("ValidateTriggerEventsJob")
        .WithReadOnly(physicsWorld)
        .WithReadOnly(triggerEvents)
        .WithoutBurst()
        .ForEach((ref Entity entity, ref TriggerEventChecker component) =>
        {
            int numTriggerEvents           = 0;
            TriggerEvent triggerEvent      = default;
            expectedNumberOfTriggerEvents += component.NumExpectedEvents;

            for (int i = 0; i < triggerEvents.Length; i++)
            {
                if (triggerEvents[i].EntityA == entity || triggerEvents[i].EntityB == entity)
                {
                    triggerEvent = triggerEvents[i];
                    numTriggerEvents++;
                }
            }

            Assert.IsTrue(numTriggerEvents == component.NumExpectedEvents, "Missing events!");

            if (numTriggerEvents == 0)
            {
                return;
            }

            // Even if component.NumExpectedEvents is > 1, we still take one trigger event, and not all, because the only
            // difference will be in ColliderKeys which we're not checking here
            int nonTriggerBodyIndex = triggerEvent.EntityA == entity ? triggerEvent.BodyIndexA : triggerEvent.BodyIndexB;
            int triggerBodyIndex    = triggerEvent.EntityA == entity ? triggerEvent.BodyIndexB : triggerEvent.BodyIndexA;

            Assert.IsTrue(nonTriggerBodyIndex == physicsWorld.GetRigidBodyIndex(entity), "Wrong body index!");

            RigidBody nonTriggerBody = physicsWorld.Bodies[nonTriggerBodyIndex];
            RigidBody triggerBody    = physicsWorld.Bodies[triggerBodyIndex];

            bool isTrigger = false;
            unsafe
            {
                ConvexCollider *colliderPtr = (ConvexCollider *)triggerBody.Collider.GetUnsafePtr();
                var material = colliderPtr->Material;

                isTrigger = colliderPtr->Material.CollisionResponse == CollisionResponsePolicy.RaiseTriggerEvents;
            }

            Assert.IsTrue(isTrigger, "Event doesn't have valid trigger index");

            float distance = math.distance(triggerBody.WorldFromBody.pos, nonTriggerBody.WorldFromBody.pos);

            Assert.IsTrue(distance < 10.0f, "The trigger index is wrong!");
        }).Run();

        Assert.IsTrue(expectedNumberOfTriggerEvents == triggerEvents.Length, "Incorrect number of events: Expected: " + expectedNumberOfTriggerEvents + " Actual: " + triggerEvents.Length);

        triggerEvents.Dispose();
    }
Exemplo n.º 2
0
        protected override void OnUpdate()
        {
            if (m_Query.CalculateEntityCount() == 0)
            {
                return;
            }

            Dependency = JobHandle.CombineDependencies(m_StepPhysicsWorld.FinalSimulationJobHandle, Dependency);

            Entities
            .WithName("ClearTriggerEventDynamicBuffersJobParallel")
            .WithBurst()
            .WithNone <ExcludeFromTriggerEventConversion>()
            .ForEach((ref DynamicBuffer <StatefulTriggerEvent> buffer) =>
            {
                buffer.Clear();
            }).ScheduleParallel();

            SwapTriggerEventStates();

            var currentFrameTriggerEvents  = m_CurrentFrameTriggerEvents;
            var previousFrameTriggerEvents = m_PreviousFrameTriggerEvents;

            var triggerEventBufferFromEntity = GetBufferFromEntity <StatefulTriggerEvent>();
            var physicsWorld = m_BuildPhysicsWorld.PhysicsWorld;

            var collectTriggerEventsJob = new CollectTriggerEventsJob
            {
                TriggerEvents = currentFrameTriggerEvents
            };

            var collectJobHandle = collectTriggerEventsJob.Schedule(m_StepPhysicsWorld.Simulation, ref physicsWorld, Dependency);

            // Using HashMap since HashSet doesn't exist
            // Setting value type to byte to minimize memory waste
            NativeHashMap <Entity, byte> entitiesWithBuffersMap = new NativeHashMap <Entity, byte>(0, Allocator.TempJob);

            var collectTriggerBuffersHandle = Entities
                                              .WithName("CollectTriggerBufferJob")
                                              .WithBurst()
                                              .WithNone <ExcludeFromTriggerEventConversion>()
                                              .ForEach((Entity e, ref DynamicBuffer <StatefulTriggerEvent> buffer) =>
            {
                entitiesWithBuffersMap.Add(e, 0);
            }).Schedule(Dependency);

            Dependency = JobHandle.CombineDependencies(collectJobHandle, collectTriggerBuffersHandle);

            Job
            .WithName("ConvertTriggerEventStreamToDynamicBufferJob")
            .WithBurst()
            .WithCode(() =>
            {
                currentFrameTriggerEvents.Sort();

                var triggerEventsWithStates = new NativeList <StatefulTriggerEvent>(currentFrameTriggerEvents.Length, Allocator.Temp);

                UpdateTriggerEventState(previousFrameTriggerEvents, currentFrameTriggerEvents, triggerEventsWithStates);
                AddTriggerEventsToDynamicBuffers(triggerEventsWithStates, ref triggerEventBufferFromEntity, entitiesWithBuffersMap);
            }).Schedule();

            m_EndFramePhysicsSystem.AddInputDependency(Dependency);
            entitiesWithBuffersMap.Dispose(Dependency);
        }