Update to "Implement the islands computation"

DanielChappuis/reactphysics3d@f1d29b5123f649aa
e8bb042b13383cec04ae93cb

Author: DDoS

src/main/java/org/spout/physics/ReactDefaults.java

@@ -57,7 +57,7 @@ public class ReactDefaults {
     /**
      * True if the deactivation (sleeping) of inactive bodies is enabled. Default: true
      */
-    public static final boolean DEACTIVATION_ENABLED = true;
+    public static final boolean SLEEPING_ENABLED = true;
     /**
      * Object margin for collision detection in meters (for the GJK-EPA Algorithm). Default: 0.04
      */

src/main/java/org/spout/physics/body/Body.java

@@ -31,6 +31,9 @@
  */
 public class Body {
     protected final int mID;
+    protected boolean mIsAlreadyInIsland;
+    protected boolean mIsAllowedToSleep;
+    protected boolean mIsSleeping;
 
     /**
      * Construct a new body from its ID.
@@ -50,6 +53,60 @@ public int getID() {
         return mID;
     }
 
+    /**
+     * Returns true if the body has already been added in an island (for the sleeping technique).
+     *
+     * @return Whether or not the body is already in an island
+     */
+    public boolean isAlreadyInIsland() {
+        return mIsAlreadyInIsland;
+    }
+
+    /**
+     * Sets the value of to know if the body has already been added into an island.
+     *
+     * @param isAlreadyInIsland Whether or not the body is in an island
+     */
+    public void setIsAlreadyInIsland(boolean isAlreadyInIsland) {
+        mIsAlreadyInIsland = isAlreadyInIsland;
+    }
+
+    /**
+     * Returns whether or not the body is allowed to sleep.
+     *
+     * @return Whether or not the body can sleep
+     */
+    public boolean isAllowedToSleep() {
+        return mIsAllowedToSleep;
+    }
+
+    /**
+     * Set whether or not the body is allowed to go to sleep.
+     *
+     * @param isAllowedToSleep Whether or not the body should be able to sleep
+     */
+    public void setIsAllowedToSleep(boolean isAllowedToSleep) {
+        mIsAllowedToSleep = isAllowedToSleep;
+    }
+
+    /**
+     * Returns whether or not the body is sleeping.
+     *
+     * @return Whether or not the body is sleeping
+     */
+    public boolean isSleeping() {
+        return mIsSleeping;
+    }
+
+    /**
+     * Set the variable to know whether or not the body is sleeping.
+     *
+     * @param isSleeping Whether or not the body is sleeping
+     */
+    public void setIsSleeping(boolean isSleeping) {
+        mIsSleeping = isSleeping;
+    }
+
     /**
      * Returns true this body's ID is smaller than the other body's ID, false if not.
      *

src/main/java/org/spout/physics/body/CollisionBody.java

@@ -28,6 +28,7 @@
 
 import org.spout.physics.collision.shape.AABB;
 import org.spout.physics.collision.shape.CollisionShape;
+import org.spout.physics.engine.ContactManifold.ContactManifoldListElement;
 import org.spout.physics.math.Transform;
 
 /**
@@ -43,6 +44,7 @@ public class CollisionBody extends Body {
     protected boolean mIsCollisionEnabled;
     protected final AABB mAabb = new AABB();
     protected boolean mHasMoved;
+    protected ContactManifoldListElement mContactManifoldsList;
 
     /**
      * Constructs a new collision body from its transform, collision shape, and ID.
@@ -65,6 +67,7 @@ public CollisionBody(Transform transform, CollisionShape collisionShape, int id)
         mInterpolationFactor = 0;
         mOldTransform = transform;
         mCollisionShape.updateAABB(mAabb, transform);
+        mContactManifoldsList = null;
     }
 
     /**
@@ -220,4 +223,29 @@ public void updateAABB() {
             mCollisionShape.updateAABB(mAabb, mTransform);
         }
     }
+
+    /**
+     * Returns the first element of the linked list of contact manifolds involving this body.
+     *
+     * @return The first element of the list
+     */
+    public ContactManifoldListElement getContactManifoldsLists() {
+        return mContactManifoldsList;
+    }
+
+    /**
+     * Sets the first element in the contact element list, discarding the entire list.
+     *
+     * @param contactManifoldsList The first element in the list
+     */
+    public void setContactManifoldsList(ContactManifoldListElement contactManifoldsList) {
+        mContactManifoldsList = contactManifoldsList;
+    }
+
+    /**
+     * Resets the contact manifold lists.
+     */
+    public void resetContactManifoldsList() {
+        mContactManifoldsList = null;
+    }
 }

src/main/java/org/spout/physics/body/RigidBody.java

@@ -27,6 +27,8 @@
 package org.spout.physics.body;
 
 import org.spout.physics.collision.shape.CollisionShape;
+import org.spout.physics.constraint.Constraint;
+import org.spout.physics.constraint.Constraint.JointListElement;
 import org.spout.physics.engine.Material;
 import org.spout.physics.math.Matrix3x3;
 import org.spout.physics.math.Transform;
@@ -49,6 +51,7 @@ public class RigidBody extends CollisionBody {
     private final Vector3 mAngularVelocity = new Vector3();
     private float mLinearDamping;
     private float mAngularDamping;
+    private JointListElement mJointsList;
 
     /**
      * Constructs a new rigid body from its transform, mass, local inertia tensor, collision shape and ID.
@@ -68,6 +71,7 @@ public RigidBody(Transform transform, float mass, Matrix3x3 inertiaTensorLocal,
         mIsGravityEnabled = true;
         mLinearDamping = 0;
         mAngularDamping = 0;
+        mJointsList = null;
     }
 
     /**
@@ -297,4 +301,49 @@ public void setAngularDamping(float angularDamping) {
         }
         mAngularDamping = angularDamping;
     }
+
+    /**
+     * Returns the first element of the linked list of joints involving this body.
+     *
+     * @return The first element of the list
+     */
+    public JointListElement getJointsList() {
+        return mJointsList;
+    }
+
+    /**
+     * Sets the first element in the joint list, discarding the entire list.
+     *
+     * @param jointsList The first element in the list
+     */
+    public void setJointsList(JointListElement jointsList) {
+        mJointsList = jointsList;
+    }
+
+    /**
+     * Removes a joint from the joints list.
+     *
+     * @param joint The joint to remove
+     */
+    public void removeJointFromJointsList(Constraint joint) {
+        if (joint == null) {
+            throw new IllegalArgumentException("Joint cannot be null");
+        }
+        if (mJointsList == null) {
+            throw new IllegalStateException("The joint list is already empty");
+        }
+        if (mJointsList.getJoint() == joint) {
+            final JointListElement elementToRemove = mJointsList;
+            mJointsList = elementToRemove.getNext();
+        } else {
+            final JointListElement currentElement = mJointsList;
+            while (currentElement.getNext() != null) {
+                if (currentElement.getNext().getJoint() == joint) {
+                    final JointListElement elementToRemove = currentElement.getNext();
+                    currentElement.setNext(elementToRemove.getNext());
+                    break;
+                }
+            }
+        }
+    }
 }

src/main/java/org/spout/physics/constraint/Constraint.java

@@ -42,6 +42,7 @@ public abstract class Constraint {
     protected int mIndexBody2;
     protected final JointsPositionCorrectionTechnique mPositionCorrectionTechnique;
     protected final boolean mIsCollisionEnabled;
+    protected boolean mIsAlreadyInIsland;
 
     /**
      * Constructs a new constraint from the provided constraint info.
@@ -61,6 +62,7 @@ public Constraint(ConstraintInfo constraintInfo) {
         mType = constraintInfo.getType();
         mPositionCorrectionTechnique = constraintInfo.getPositionCorrectionTechnique();
         mIsCollisionEnabled = constraintInfo.isCollisionEnabled();
+        mIsAlreadyInIsland = false;
     }
 
     /**
@@ -136,6 +138,24 @@ public boolean isCollisionEnabled() {
         return mIsCollisionEnabled;
     }
 
+    /**
+     * Returns true if the joint has already been added into an island.
+     *
+     * @return Whether or not the joint is already in an island
+     */
+    public boolean isAlreadyInIsland() {
+        return mIsAlreadyInIsland;
+    }
+
+    /**
+     * Sets whether or not this joint has already been added into an island.
+     *
+     * @param isAlreadyInIsland Whether or not the joint is already in an island
+     */
+    public void setIsAlreadyInIsland(boolean isAlreadyInIsland) {
+        mIsAlreadyInIsland = isAlreadyInIsland;
+    }
+
     /**
      * An enumeration of the possible constraint types (contact).
      */
@@ -266,4 +286,59 @@ public void setPositionCorrectionTechnique(JointsPositionCorrectionTechnique pos
             this.positionCorrectionTechnique = positionCorrectionTechnique;
         }
     }
+
+    /**
+     * This structure represents a single element of a linked list of joints.
+     */
+    public static class JointListElement {
+        private Constraint joint;
+        private JointListElement next;
+
+        /**
+         * Constructs a new joint list element from the initial joint and next list element.
+         *
+         * @param initJoint The joint
+         * @param initNext The next element
+         */
+        public JointListElement(Constraint initJoint, JointListElement initNext) {
+            joint = initJoint;
+            next = initNext;
+        }
+
+        /**
+         * Returns the joint in this list element.
+         *
+         * @return The joint
+         */
+        public Constraint getJoint() {
+            return joint;
+        }
+
+        /**
+         * Sets the joint in this list element.
+         *
+         * @param joint The joint
+         */
+        public void setJoint(Constraint joint) {
+            this.joint = joint;
+        }
+
+        /**
+         * Returns the next element in the list.
+         *
+         * @return The next element
+         */
+        public JointListElement getNext() {
+            return next;
+        }
+
+        /**
+         * Sets the next element in the list.
+         *
+         * @param next The next element
+         */
+        public void setNext(JointListElement next) {
+            this.next = next;
+        }
+    }
 }