Formatting cleanup, Javadoc column limit edition.

Author: Wulfspider

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

@@ -27,8 +27,7 @@
 package org.spout.physics;
 
 /**
- * This class contains static utilities. It was added for the port to implement some C++ code in
- * Java.
+ * This class contains static utilities. It was added for the port to implement some C++ code in Java.
  */
 public class Utilities {
 	/**

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

@@ -31,8 +31,7 @@
 import org.spout.physics.math.Transform;
 
 /**
- * Represents a body that is able to collide with others bodies. This class inherits from the Body
- * class.
+ * Represents a body that is able to collide with others bodies. This class inherits from the Body class.
  */
 public abstract class CollisionBody extends Body {
 	protected CollisionShape mCollisionShape;
@@ -118,11 +117,9 @@ public void setActive(boolean mIsActive) {
 	}
 
 	/**
-	 * Returns an interpolated body from the old to the current transform, based on this body's
-	 * interpolation factor.
+	 * Returns an interpolated body from the old to the current transform, based on this body's interpolation factor.
 	 *
-	 * @return A transform interpolated from the old to the current transform based on the
-	 *         interpolation factor
+	 * @return A transform interpolated from the old to the current transform based on the interpolation factor
 	 */
 	public Transform getInterpolatedTransform() {
 		return Transform.interpolateTransforms(msnapshotTransform, mliveTransform, mInterpolationFactor);
@@ -193,8 +190,7 @@ public void setCollisionEnabled(boolean isCollisionEnabled) {
 	}
 
 	/**
-	 * Update the old transform with the current one. This is used to compute the interpolated position
-	 * and orientation of the body.
+	 * Update the old transform with the current one. This is used to compute the interpolated position and orientation of the body.
 	 */
 	public void snapshotTransform() {
 		msnapshotTransform.set(mliveTransform);

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

@@ -31,9 +31,8 @@
 import org.spout.physics.math.Transform;
 
 /**
- * Detector body which only informs callbacks of a collision. This body will not incur any collision adjustments nor will it prevent objects from passing through.
- * <p>
- * Uses for this object are when you want to inform the callbacks of a collision but handle adjustments on your own (ex. Character movement, moving through water, etc.)
+ * Detector body which only informs callbacks of a collision. This body will not incur any collision adjustments nor will it prevent objects from passing through. <p> Uses for this object are when you
+ * want to inform the callbacks of a collision but handle adjustments on your own (ex. Character movement, moving through water, etc.)
  */
 public class GhostImmobileRigidBody extends ImmobileRigidBody {
 	/**

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

@@ -31,9 +31,8 @@
 import org.spout.physics.math.Transform;
 
 /**
- * Detector body which only informs callbacks of a collision. This body will not incur any collision adjustments nor will it prevent objects from passing through.
- * <p>
- * Uses for this object are when you want to inform the callbacks of a collision but handle adjustments on your own (ex. Character movement, moving through water, etc.)
+ * Detector body which only informs callbacks of a collision. This body will not incur any collision adjustments nor will it prevent objects from passing through. <p> Uses for this object are when you
+ * want to inform the callbacks of a collision but handle adjustments on your own (ex. Character movement, moving through water, etc.)
  */
 public class GhostMobileRigidBody extends MobileRigidBody {
 	/**

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

@@ -32,8 +32,7 @@
 import org.spout.physics.math.Vector3;
 
 /**
- * Represents an immobile rigid body. Such a body cannot move, but has all of the properties of a
- * normal rigid body, except for velocities. This can be used for scenery, floors, walls, etc.
+ * Represents an immobile rigid body. Such a body cannot move, but has all of the properties of a normal rigid body, except for velocities. This can be used for scenery, floors, walls, etc.
  */
 public class ImmobileRigidBody extends RigidBody {
 	private static final Vector3 ZERO = new Vector3(0, 0, 0);
@@ -44,8 +43,7 @@ public class ImmobileRigidBody extends RigidBody {
 	protected final Vector3 mExternalTorque = new Vector3();
 
 	/**
-	 * Constructs a new rigid body from its transform, mass, local inertia tensor, collision shape and
-	 * ID.
+	 * Constructs a new rigid body from its transform, mass, local inertia tensor, collision shape and ID.
 	 *
 	 * @param transform The transform (position and orientation)
 	 * @param mass The mass
@@ -77,7 +75,7 @@ public float getMass() {
 	 */
 	@Override
 	public float getMassInverse() {
-		return (1/mMass);
+		return (1 / mMass);
 	}
 
 	/**
@@ -109,10 +107,8 @@ public void setInertiaTensorLocal(Matrix3x3 inertiaTensorLocal) {
 	}
 
 	/**
-	 * Gets the inertia tensor in world coordinates. The inertia tensor I_w in world coordinates is
-	 * computed with the local inertia tensor I_b in body coordinates by I_w = R * I_b * R^T, where R
-	 * is the rotation matrix (and R^T its transpose) of the current orientation quaternion of the
-	 * body.
+	 * Gets the inertia tensor in world coordinates. The inertia tensor I_w in world coordinates is computed with the local inertia tensor I_b in body coordinates by I_w = R * I_b * R^T, where R is the
+	 * rotation matrix (and R^T its transpose) of the current orientation quaternion of the body.
 	 *
 	 * @return The world inertia tensor
 	 */

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

@@ -32,17 +32,15 @@
 import org.spout.physics.math.Vector3;
 
 /**
- * Represents a mobile rigid body. Such a body can move and has all of the properties of a normal
- * rigid body.
+ * Represents a mobile rigid body. Such a body can move and has all of the properties of a normal rigid body.
  */
 public class MobileRigidBody extends ImmobileRigidBody {
 	private final Vector3 mLinearVelocity = new Vector3();
 	private final Vector3 mAngularVelocity = new Vector3();
 	private boolean mIsMotionEnabled = true;
 
 	/**
-	 * Constructs a new rigid body from its transform, mass, local inertia tensor, collision shape and
-	 * ID.
+	 * Constructs a new rigid body from its transform, mass, local inertia tensor, collision shape and ID.
 	 *
 	 * @param transform The transform (position and orientation)
 	 * @param mass The mass

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

@@ -32,8 +32,7 @@
 import org.spout.physics.math.Vector3;
 
 /**
- * Represents a rigid body for the physics engine. A rigid body is a non-deformable body that has a
- * constant mass. This class inherits from the CollisionBody class.
+ * Represents a rigid body for the physics engine. A rigid body is a non-deformable body that has a constant mass. This class inherits from the CollisionBody class.
  */
 public abstract class RigidBody extends CollisionBody {
 	private static final RigidBodyMaterial DEFAULT_MATERIAL = RigidBodyMaterial.asUnmodifiableMaterial(new RigidBodyMaterial());
@@ -107,10 +106,8 @@ protected RigidBody(Transform transform, CollisionShape collisionShape, int id)
 	public abstract void setExternalTorque(Vector3 torque);
 
 	/**
-	 * Gets the inverse of the inertia tensor in world coordinates. The inertia tensor I_w in world
-	 * coordinates is computed with the local inverse inertia tensor I_b^-1 in body coordinates by I_w
-	 * = R * I_b^-1 * R^T, where R is the rotation matrix (and R^T its transpose) of the current
-	 * orientation quaternion of the body.
+	 * Gets the inverse of the inertia tensor in world coordinates. The inertia tensor I_w in world coordinates is computed with the local inverse inertia tensor I_b^-1 in body coordinates by I_w = R *
+	 * I_b^-1 * R^T, where R is the rotation matrix (and R^T its transpose) of the current orientation quaternion of the body.
 	 *
 	 * @return The world inverse inertia tensor
 	 */

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

@@ -29,16 +29,14 @@
 import org.spout.physics.ReactDefaults;
 
 /**
- * Represents a material for a rigid body. The material has the restitution and friction
- * coefficients. Altering these constants for a material will alter the constants for all bodies.
+ * Represents a material for a rigid body. The material has the restitution and friction coefficients. Altering these constants for a material will alter the constants for all bodies.
  */
 public class RigidBodyMaterial {
 	private float mRestitution = ReactDefaults.DEFAULT_RESTITUTION_COEFFICIENT;
 	private float mFriction = ReactDefaults.DEFAULT_FRICTION_COEFFICIENT;
 
 	/**
-	 * Constructs a new rigid body material using {@link ReactDefaults#DEFAULT_RESTITUTION_COEFFICIENT}
-	 * and {@link ReactDefaults#DEFAULT_FRICTION_COEFFICIENT} as the default restitution and friction
+	 * Constructs a new rigid body material using {@link ReactDefaults#DEFAULT_RESTITUTION_COEFFICIENT} and {@link ReactDefaults#DEFAULT_FRICTION_COEFFICIENT} as the default restitution and friction
 	 * coefficients.
 	 */
 	public RigidBodyMaterial() {
@@ -95,11 +93,9 @@ public void setFriction(float friction) {
 	}
 
 	/**
-	 * Returns a new unmodifiable rigid body material. Unmodifiable means that the {@link
-	 * #setRestitution(float)} and {@link #setFriction(float)} methods will throw an {@link
-	 * UnsupportedOperationException}. This is does not use a wrapper class, and the original material
-	 * is not linked to the one returned. That is, changes to the original material are not reflected
-	 * by the returned material.
+	 * Returns a new unmodifiable rigid body material. Unmodifiable means that the {@link #setRestitution(float)} and {@link #setFriction(float)} methods will throw an {@link
+	 * UnsupportedOperationException}. This is does not use a wrapper class, and the original material is not linked to the one returned. That is, changes to the original material are not reflected by
+	 * the returned material.
 	 *
 	 * @param material The material to make an unmodifiable copy of
 	 * @return A new unmodifiable rigid body material.

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

@@ -49,8 +49,7 @@
 import org.spout.physics.engine.linked.LinkedDynamicsWorld;
 
 /**
- * This class computes the collision detection algorithms. We first perform a broad-phase algorithm
- * to know which pairs of bodies can collide and then we run a narrow-phase algorithm to compute the
+ * This class computes the collision detection algorithms. We first perform a broad-phase algorithm to know which pairs of bodies can collide and then we run a narrow-phase algorithm to compute the
  * collision contacts between the bodies.
  */
 public class CollisionDetection {
@@ -176,8 +175,7 @@ private void computeNarrowPhase() {
 	}
 
 	/**
-	 * Allows the broad phase to notify the collision detection about an overlapping pair. This method
-	 * is called by a broad-phase collision detection algorithm.
+	 * Allows the broad phase to notify the collision detection about an overlapping pair. This method is called by a broad-phase collision detection algorithm.
 	 *
 	 * @param addedPair The pair that was added
 	 */

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

@@ -29,18 +29,14 @@
 import org.spout.physics.body.CollisionBody;
 
 /**
- * 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,
- * ContactInfo)}. Implement this interface to listen to them. Use {@link
+ * 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, ContactInfo)}. Implement this interface to listen to them. Use {@link
  * org.spout.physics.engine.CollisionWorld#addListener(CollisionListener)} to add a listener.
  */
 public interface CollisionListener {
 	/**
-	 * 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.
+	 * 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.
 	 *
 	 * @param body1 The first body
 	 * @param body2 The second body