Update to "Add the EventListener class"

DanielChappuis/reactphysics3d@07df001e8bcc55c5
b4915687cd9ddf349ee891f4

Author: DDoS

src/main/java/org/spout/physics/collision/CollisionDetection.java

@@ -61,7 +61,6 @@ public class CollisionDetection {
     private final GJKAlgorithm mNarrowPhaseGJKAlgorithm = new GJKAlgorithm();
     private final SphereVsSphereAlgorithm mNarrowPhaseSphereVsSphereAlgorithm = new SphereVsSphereAlgorithm();
     private final Set<IntPair> mNoCollisionPairs = new HashSet<>();
-    private final List<CollisionListener> mCallBacks = new ArrayList<>();
     private final LinkedPhase mLinkedPhase;
 
     /**
@@ -79,24 +78,6 @@ public CollisionDetection(CollisionWorld world) {
         }
     }
 
-    /**
-     * Gets the collision listeners for collision detection.
-     *
-     * @return The collision listeners
-     */
-    public List<CollisionListener> getListeners() {
-        return mCallBacks;
-    }
-
-    /**
-     * Adds a collision listener for the collision detection.
-     *
-     * @param listener The listener to add
-     */
-    public void addListener(CollisionListener listener) {
-        mCallBacks.add(listener);
-    }
-
     /**
      * Adds a body to the collision detection.
      *
@@ -192,20 +173,7 @@ private void computeNarrowPhase() {
             if (narrowPhaseAlgorithm.testCollision(body1.getCollisionShape(), body1.getTransform(), body2.getCollisionShape(), body2.getTransform(), contactInfo)) {
                 contactInfo.setFirstBody((RigidBody) body1);
                 contactInfo.setSecondBody((RigidBody) body2);
-                if (mCallBacks.isEmpty()) {
-                    mWorld.notifyNewContact(pair, contactInfo);
-                } else {
-                    boolean cancel = false;
-                    for (CollisionListener listener : mCallBacks) {
-                        if (listener.onCollide(body1, body2, contactInfo)) {
-                            cancel = true;
-                            break;
-                        }
-                    }
-                    if (!cancel) {
-                        mWorld.notifyNewContact(pair, contactInfo);
-                    }
-                }
+                mWorld.notifyNewContact(pair, contactInfo);
             }
         }
     }

src/main/java/org/spout/physics/engine/CollisionWorld.java

@@ -40,7 +40,6 @@
 import org.spout.physics.body.CollisionBody;
 import org.spout.physics.collision.BroadPhasePair;
 import org.spout.physics.collision.CollisionDetection;
-import org.spout.physics.collision.CollisionListener;
 import org.spout.physics.collision.RayCaster;
 import org.spout.physics.collision.RayCaster.IntersectedBody;
 import org.spout.physics.collision.shape.CollisionShape;
@@ -94,15 +93,6 @@ protected CollisionWorld() {
      */
     public abstract void updateOverlappingPair(BroadPhasePair pair);
 
-    /**
-     * Adds a collision listener for the collision detection.
-     *
-     * @param listener The listener to use
-     */
-    public void addListener(CollisionListener listener) {
-        mCollisionDetection.addListener(listener);
-    }
-
     /**
      * Gets the set of the bodies of the physics world.
      *

src/main/java/org/spout/physics/engine/DynamicsWorld.java

@@ -91,6 +91,7 @@ public class DynamicsWorld extends CollisionWorld {
     private float mSleepLinearVelocity;
     private float mSleepAngularVelocity;
     private float mTimeBeforeSleep;
+    private EventListener mEventListener;
     private boolean isTicking = false;
     // Tick cache
     private final Set<RigidBody> mRigidBodiesToAddCache = new HashSet<>();
@@ -288,6 +289,15 @@ public void setTimeBeforeSleep(float timeBeforeSleep) {
         mTimeBeforeSleep = timeBeforeSleep;
     }
 
+    /**
+     * Sets an event listener object to receive events callbacks. If you use <code>null</code> as an argument, the events callbacks will be disabled.
+     *
+     * @param eventListener The event listener, or null for none
+     */
+    public void setEventListener(EventListener eventListener) {
+        mEventListener = eventListener;
+    }
+
     /**
      * Gets the number of rigid bodies in the world.
      *
@@ -367,9 +377,9 @@ public void update() {
                 updateSleepingBodies();
             }
             updateRigidBodiesAABB();
-            resetBodiesForceAndTorque();
         }
         isTicking = false;
+        resetBodiesForceAndTorque();
         setInterpolationFactorToAllBodies();
         disperseCache();
     }
@@ -907,9 +917,17 @@ public void notifyNewContact(BroadPhasePair broadPhasePair, ContactPointInfo con
         if (overlappingPair == null) {
             throw new IllegalArgumentException("broad phase pair is not in the overlapping pairs");
         }
+        if (overlappingPair.getNbContactPoints() == 0) {
+            if (mEventListener != null) {
+                mEventListener.beginContact(contactInfo);
+            }
+        }
         overlappingPair.addContact(contact);
         mContactManifolds.add(overlappingPair.getContactManifold());
         addContactManifoldToBody(overlappingPair.getContactManifold(), overlappingPair.getFirstBody(), overlappingPair.getSecondBody());
+        if (mEventListener != null) {
+            mEventListener.newContact(contactInfo);
+        }
     }
 
     /**

…physics/collision/CollisionListener.java …/spout/physics/engine/EventListener.javasrc/main/java/org/spout/physics/collision/CollisionListener.java renamed to src/main/java/org/spout/physics/engine/EventListener.java src/main/java/org/spout/physics/collision/CollisionListener.java renamed to src/main/java/org/spout/physics/engine/EventListener.java

@@ -24,25 +24,26 @@
  * License and see <http://spout.in/licensev1> for the full license, including
  * the MIT license.
  */
-package org.spout.physics.collision;
+package org.spout.physics.engine;
 
-import org.spout.physics.body.CollisionBody;
 import org.spout.physics.constraint.ContactPoint.ContactPointInfo;
 
 /**
- * Reports the collisions between two bodies as they are occurring during the narrow-phase and allows for cancellation of the collision. Each collision will result in a call of {@link
- * #onCollide(org.spout.physics.body.CollisionBody, org.spout.physics.body.CollisionBody, ContactPointInfo)}. Implement this interface to listen to them. Use {@link
- * org.spout.physics.engine.CollisionWorld#addListener(CollisionListener)} to add a listener.
+ * This class can be used to receive event callbacks from the physics engine. In order to receive callbacks, you need to create a new class that inherits from this one and you must override the
+ * methods you need. Then, you need to register your new event listener class to the physics world using the {@link DynamicsWorld#setEventListener(EventListener)} method.
  */
-public interface CollisionListener {
+public interface EventListener {
     /**
-     * This method is called when two bodies are about to collide in a collision detection. Both bodies are provided, including the contact information, which includes the contact points on each body,
-     * the penetration depth, and the normal. The method returns a boolean. If it is true, the collision will be canceled.
+     * Called when a new contact point is found between two bodies that were separated before.
      *
-     * @param body1 The first body
-     * @param body2 The second body
-     * @param contactInfo The contact information
-     * @return Whether or not the collision should be canceled
+     * @param contactInfo The info for the contact
      */
-    public boolean onCollide(CollisionBody body1, CollisionBody body2, ContactPointInfo contactInfo);
+    void beginContact(ContactPointInfo contactInfo);
+
+    /**
+     * Called when a new contact point is found between two bodies.
+     *
+     * @param contactInfo The info for the contact
+     */
+    void newContact(ContactPointInfo contactInfo);
 }

src/test/java/org/spout/physics/DynamicsWorldTest.java

@@ -26,52 +26,67 @@
  */
 package org.spout.physics;
 
+import org.junit.Assert;
 import org.junit.Test;
 
 import org.spout.physics.body.RigidBody;
 import org.spout.physics.collision.shape.BoxShape;
+import org.spout.physics.constraint.ContactPoint.ContactPointInfo;
 import org.spout.physics.engine.DynamicsWorld;
+import org.spout.physics.engine.EventListener;
 import org.spout.physics.math.Matrix3x3;
 import org.spout.physics.math.Quaternion;
 import org.spout.physics.math.Transform;
 import org.spout.physics.math.Vector3;
 
 public class DynamicsWorldTest {
     private static final float RUN_TIME = 2;
+    private int beginContactCount = 0;
+    private int newContactCount = 0;
 
     @Test
     public void test() throws InterruptedException {
-        try {
-            final float timeStep = ReactDefaults.DEFAULT_TIMESTEP;
-            final DynamicsWorld world = new DynamicsWorld(new Vector3(0, -9.81f, 0), timeStep);
-            final BoxShape floorShape = new BoxShape(new Vector3(10, 0.5f, 10));
-            final Transform floorTransform = new Transform(new Vector3(0, 0, 0), Quaternion.identity());
-            final Matrix3x3 floorInertia = new Matrix3x3();
-            final float floorMass = 100;
-            floorShape.computeLocalInertiaTensor(floorInertia, floorMass);
-            final RigidBody floor = world.createRigidBody(floorTransform, floorMass, floorInertia, floorShape);
-            floor.setIsMotionEnabled(false);
-            final BoxShape boxShape = new BoxShape(new Vector3(1, 1, 1));
-            final Transform boxTransform = new Transform(new Vector3(0, 5, 0), Quaternion.identity());
-            final Matrix3x3 boxInertia = new Matrix3x3();
-            final float boxMass = 5;
-            boxShape.computeLocalInertiaTensor(boxInertia, boxMass);
-            final RigidBody box = world.createRigidBody(boxTransform, boxMass, boxInertia, boxShape);
-            final int stepCount = Math.round((1 / timeStep) * RUN_TIME);
-            final int sleepTime = Math.round(timeStep * 1000);
-            world.start();
-            for (int i = 0; i < stepCount; i++) {
-                final long start = System.nanoTime();
-                world.update();
-                final long delta = Math.round((System.nanoTime() - start) / 1000000d);
-                Thread.sleep(Math.max(sleepTime - delta, 0));
-            }
-            world.destroyRigidBody(floor);
-            world.destroyRigidBody(box);
-            world.stop();
-        } catch (Exception ex) {
-            ex.printStackTrace();
-            throw new RuntimeException(ex);
+        final float timeStep = ReactDefaults.DEFAULT_TIMESTEP;
+        final DynamicsWorld world = new DynamicsWorld(new Vector3(0, -9.81f, 0), timeStep);
+        final BoxShape floorShape = new BoxShape(new Vector3(10, 0.5f, 10));
+        final Transform floorTransform = new Transform(new Vector3(0, 0, 0), Quaternion.identity());
+        final Matrix3x3 floorInertia = new Matrix3x3();
+        final float floorMass = 100;
+        floorShape.computeLocalInertiaTensor(floorInertia, floorMass);
+        final RigidBody floor = world.createRigidBody(floorTransform, floorMass, floorInertia, floorShape);
+        floor.setIsMotionEnabled(false);
+        final BoxShape boxShape = new BoxShape(new Vector3(1, 1, 1));
+        final Transform boxTransform = new Transform(new Vector3(0, 5, 0), Quaternion.identity());
+        final Matrix3x3 boxInertia = new Matrix3x3();
+        final float boxMass = 5;
+        boxShape.computeLocalInertiaTensor(boxInertia, boxMass);
+        final RigidBody box = world.createRigidBody(boxTransform, boxMass, boxInertia, boxShape);
+        final int stepCount = Math.round((1 / timeStep) * RUN_TIME);
+        final int sleepTime = Math.round(timeStep * 1000);
+        world.setEventListener(new TestListener());
+        world.start();
+        for (int i = 0; i < stepCount; i++) {
+            final long start = System.nanoTime();
+            world.update();
+            final long delta = Math.round((System.nanoTime() - start) / 1000000d);
+            Thread.sleep(Math.max(sleepTime - delta, 0));
+        }
+        world.destroyRigidBody(floor);
+        world.destroyRigidBody(box);
+        world.stop();
+        Assert.assertTrue("There was no contact in the simulation", beginContactCount > 0);
+        Assert.assertTrue("There were more contacts begun than new contacts", newContactCount > beginContactCount);
+    }
+
+    private class TestListener implements EventListener {
+        @Override
+        public void beginContact(ContactPointInfo contactInfo) {
+            beginContactCount++;
+        }
+
+        @Override
+        public void newContact(ContactPointInfo contactInfo) {
+            newContactCount++;
         }
     }
 }

src/test/java/org/spout/physics/SweepAndPruneAlgorithmTest.java

@@ -42,38 +42,33 @@ public class SweepAndPruneAlgorithmTest {
 
     @Test
     public void test() {
-        try {
-            final SweepAndPruneAlgorithm sweepAndPrune = new SweepAndPruneAlgorithm(Dummies.newCollisionDetection());
-            final Set<CollisionBody> bodies = new HashSet<>();
-            for (int repeat = 0; repeat < 2; repeat++) {
-                for (int i = 0; i < BODY_COUNT / 10; i++) {
-                    final CollisionBody body = Dummies.newCollisionBody(ID++);
-                    bodies.add(body);
-                    sweepAndPrune.addObject(body, Dummies.newAABB());
-                }
-                Assert.assertEquals(BODY_COUNT / 10, sweepAndPrune.getNbObjects());
-                Assert.assertTrue(countNotNull(sweepAndPrune.getOverlappingPairs()) >= 0);
-                for (int i = 0; i < BODY_COUNT / 2; i++) {
-                    final AABB aabb = Dummies.newAABB();
-                    final CollisionBody body0 = Dummies.newCollisionBody(ID++);
-                    bodies.add(body0);
-                    sweepAndPrune.addObject(body0, aabb);
-                    final CollisionBody body1 = Dummies.newCollisionBody(ID++);
-                    bodies.add(body1);
-                    sweepAndPrune.addObject(body1, Dummies.newIntersectingAABB(aabb));
-                }
-                Assert.assertEquals(BODY_COUNT + BODY_COUNT / 10, sweepAndPrune.getNbObjects());
-                Assert.assertTrue(countNotNull(sweepAndPrune.getOverlappingPairs()) >= BODY_COUNT / 2);
-                for (CollisionBody body : bodies) {
-                    sweepAndPrune.removeObject(body);
-                }
-                Assert.assertEquals(0, sweepAndPrune.getNbObjects());
-                bodies.clear();
-                ID = 0;
+        final SweepAndPruneAlgorithm sweepAndPrune = new SweepAndPruneAlgorithm(Dummies.newCollisionDetection());
+        final Set<CollisionBody> bodies = new HashSet<>();
+        for (int repeat = 0; repeat < 2; repeat++) {
+            for (int i = 0; i < BODY_COUNT / 10; i++) {
+                final CollisionBody body = Dummies.newCollisionBody(ID++);
+                bodies.add(body);
+                sweepAndPrune.addObject(body, Dummies.newAABB());
             }
-        } catch (Exception ex) {
-            ex.printStackTrace();
-            throw new RuntimeException(ex);
+            Assert.assertEquals(BODY_COUNT / 10, sweepAndPrune.getNbObjects());
+            Assert.assertTrue(countNotNull(sweepAndPrune.getOverlappingPairs()) >= 0);
+            for (int i = 0; i < BODY_COUNT / 2; i++) {
+                final AABB aabb = Dummies.newAABB();
+                final CollisionBody body0 = Dummies.newCollisionBody(ID++);
+                bodies.add(body0);
+                sweepAndPrune.addObject(body0, aabb);
+                final CollisionBody body1 = Dummies.newCollisionBody(ID++);
+                bodies.add(body1);
+                sweepAndPrune.addObject(body1, Dummies.newIntersectingAABB(aabb));
+            }
+            Assert.assertEquals(BODY_COUNT + BODY_COUNT / 10, sweepAndPrune.getNbObjects());
+            Assert.assertTrue(countNotNull(sweepAndPrune.getOverlappingPairs()) >= BODY_COUNT / 2);
+            for (CollisionBody body : bodies) {
+                sweepAndPrune.removeObject(body);
+            }
+            Assert.assertEquals(0, sweepAndPrune.getNbObjects());
+            bodies.clear();
+            ID = 0;
         }
     }