pbox2d 0.6.0-java → 0.8.0-java

data/src/org/jbox2d/common/OBBViewportTransform.java

@@ -0,0 +1,174 @@
+/*******************************************************************************
+ * Copyright (c) 2013, Daniel Murphy
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 	* Redistributions of source code must retain the above copyright notice,
+ * 	  this list of conditions and the following disclaimer.
+ * 	* Redistributions in binary form must reproduce the above copyright notice,
+ * 	  this list of conditions and the following disclaimer in the documentation
+ * 	  and/or other materials provided with the distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ ******************************************************************************/
+package org.jbox2d.common;
+
+/**
+ * Orientated bounding box viewport transform
+ * 
+ * @author Daniel Murphy
+ */
+public class OBBViewportTransform implements IViewportTransform {
+
+  public static class OBB {
+    public final Mat22 R = new Mat22();
+    public final Vec2 center = new Vec2();
+    public final Vec2 extents = new Vec2();
+  }
+
+  protected final OBB box = new OBB();
+  private boolean yFlip = false;
+  private final Mat22 yFlipMat = new Mat22(1, 0, 0, -1);
+
+  public OBBViewportTransform() {
+    box.R.setIdentity();
+  }
+
+  public void set(OBBViewportTransform vpt) {
+    box.center.set(vpt.box.center);
+    box.extents.set(vpt.box.extents);
+    box.R.set(vpt.box.R);
+    yFlip = vpt.yFlip;
+  }
+
+  @Override
+  public void setCamera(float x, float y, float scale) {
+    box.center.set(x, y);
+    Mat22.createScaleTransform(scale, box.R);
+  }
+
+  @Override
+  public Vec2 getExtents() {
+    return box.extents;
+  }
+  
+  @Override
+  public Mat22 getMat22Representation() {
+    return box.R;
+  }
+
+  @Override
+  public void setExtents(Vec2 argExtents) {
+    box.extents.set(argExtents);
+  }
+
+  @Override
+  public void setExtents(float halfWidth, float halfHeight) {
+    box.extents.set(halfWidth, halfHeight);
+  }
+
+  @Override
+  public Vec2 getCenter() {
+    return box.center;
+  }
+
+  @Override
+  public void setCenter(Vec2 argPos) {
+    box.center.set(argPos);
+  }
+
+  @Override
+  public void setCenter(float x, float y) {
+    box.center.set(x, y);
+  }
+
+  /**
+   * Gets the transform of the viewport, transforms around the center. Not a copy.
+     * @return 
+   */
+  public Mat22 getTransform() {
+    return box.R;
+  }
+
+  /**
+   * Sets the transform of the viewport. Transforms about the center.
+     * @param transform
+   */
+  public void setTransform(Mat22 transform) {
+    box.R.set(transform);
+  }
+
+  /**
+   * Multiplies the obb transform by the given transform
+   */
+  @Override
+  public void mulByTransform(Mat22 transform) {
+    box.R.mulLocal(transform);
+  }
+
+  @Override
+  public boolean isYFlip() {
+    return yFlip;
+  }
+
+  @Override
+  public void setYFlip(boolean yFlip) {
+    this.yFlip = yFlip;
+  }
+
+  private final Mat22 inv = new Mat22();
+
+  @Override
+  public void getScreenVectorToWorld(Vec2 screen, Vec2 world) {
+    box.R.invertToOut(inv);
+    inv.mulToOut(screen, world);
+    if (yFlip) {
+      yFlipMat.mulToOut(world, world);
+    }
+  }
+
+  @Override
+  public void getWorldVectorToScreen(Vec2 world, Vec2 screen) {
+    box.R.mulToOut(world, screen);
+    if (yFlip) {
+      yFlipMat.mulToOut(screen, screen);
+    }
+  }
+
+  @Override
+  public void getWorldToScreen(Vec2 world, Vec2 screen) {
+    screen.x = world.x - box.center.x;
+    screen.y = world.y - box.center.y;
+    box.R.mulToOut(screen, screen);
+    if (yFlip) {
+      yFlipMat.mulToOut(screen, screen);
+    }
+    screen.x += box.extents.x;
+    screen.y += box.extents.y;
+  }
+
+  private final Mat22 inv2 = new Mat22();
+
+  @Override
+  public void getScreenToWorld(Vec2 screen, Vec2 world) {
+    world.x = screen.x - box.extents.x;
+    world.y = screen.y - box.extents.y;
+    if (yFlip) {
+      yFlipMat.mulToOut(world, world);
+    }
+    box.R.invertToOut(inv2);
+    inv2.mulToOut(world, world);
+    world.x += box.center.x;
+    world.y += box.center.y;
+  }
+}

data/src/org/jbox2d/common/PlatformMathUtils.java

@@ -0,0 +1,46 @@
+/*******************************************************************************
+ * Copyright (c) 2013, Daniel Murphy
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 	* Redistributions of source code must retain the above copyright notice,
+ * 	  this list of conditions and the following disclaimer.
+ * 	* Redistributions in binary form must reproduce the above copyright notice,
+ * 	  this list of conditions and the following disclaimer in the documentation
+ * 	  and/or other materials provided with the distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ ******************************************************************************/
+package org.jbox2d.common;
+
+/**
+ * Contains methods from MathUtils that rely on JVM features. These are separated out from
+ * MathUtils so that they can be overridden when compiling for GWT.
+ */
+class PlatformMathUtils {
+
+  private static final float SHIFT23 = 1 << 23;
+  private static final float INV_SHIFT23 = 1.0f / SHIFT23;
+
+  public static final float fastPow(float a, float b) {
+    float x = Float.floatToRawIntBits(a);
+    x *= INV_SHIFT23;
+    x -= 127;
+    float y = x - (x >= 0 ? (int) x : (int) x - 1);
+    b *= x + (y - y * y) * 0.346607f;
+    y = b - (b >= 0 ? (int) b : (int) b - 1);
+    y = (y - y * y) * 0.33971f;
+    return Float.intBitsToFloat((int) ((b + 127 - y) * SHIFT23));
+  }
+}
+

data/src/org/jbox2d/common/RaycastResult.java

@@ -0,0 +1,37 @@
+/*******************************************************************************
+ * Copyright (c) 2013, Daniel Murphy
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 	* Redistributions of source code must retain the above copyright notice,
+ * 	  this list of conditions and the following disclaimer.
+ * 	* Redistributions in binary form must reproduce the above copyright notice,
+ * 	  this list of conditions and the following disclaimer in the documentation
+ * 	  and/or other materials provided with the distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ ******************************************************************************/
+package org.jbox2d.common;
+
+// updated to rev 100
+
+public class RaycastResult {
+	public float lambda = 0.0f;
+	public final Vec2 normal = new Vec2();
+	
+	public RaycastResult set(RaycastResult argOther){
+		lambda = argOther.lambda;
+		normal.set( argOther.normal);
+		return this;
+	}
+}

data/src/org/jbox2d/common/Rot.java

@@ -0,0 +1,150 @@
+/*******************************************************************************
+ * Copyright (c) 2013, Daniel Murphy
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 	* Redistributions of source code must retain the above copyright notice,
+ * 	  this list of conditions and the following disclaimer.
+ * 	* Redistributions in binary form must reproduce the above copyright notice,
+ * 	  this list of conditions and the following disclaimer in the documentation
+ * 	  and/or other materials provided with the distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ ******************************************************************************/
+package org.jbox2d.common;
+
+import java.io.Serializable;
+
+/**
+ * Represents a rotation
+ * 
+ * @author Daniel
+ */
+public class Rot implements Serializable {
+  private static final long serialVersionUID = 1L;
+
+  public float s, c; // sin and cos
+
+  public Rot() {
+    setIdentity();
+  }
+
+  public Rot(float angle) {
+    set(angle);
+  }
+
+  public float getSin() {
+    return s;
+  }
+
+  @Override
+  public String toString() {
+    return "Rot(s:" + s + ", c:" + c + ")";
+  }
+
+  public float getCos() {
+    return c;
+  }
+
+  public Rot set(float angle) {
+    s = MathUtils.sin(angle);
+    c = MathUtils.cos(angle);
+    return this;
+  }
+
+  public Rot set(Rot other) {
+    s = other.s;
+    c = other.c;
+    return this;
+  }
+
+  public Rot setIdentity() {
+    s = 0;
+    c = 1;
+    return this;
+  }
+
+  public float getAngle() {
+    return MathUtils.atan2(s, c);
+  }
+
+  public void getXAxis(Vec2 xAxis) {
+    xAxis.set(c, s);
+  }
+
+  public void getYAxis(Vec2 yAxis) {
+    yAxis.set(-s, c);
+  }
+
+  // @Override // annotation omitted for GWT-compatibility
+  public Rot clone() {
+    Rot copy = new Rot();
+    copy.s = s;
+    copy.c = c;
+    return copy;
+  }
+
+  public static final void mul(Rot q, Rot r, Rot out) {
+    float tempc = q.c * r.c - q.s * r.s;
+    out.s = q.s * r.c + q.c * r.s;
+    out.c = tempc;
+  }
+
+  public static final void mulUnsafe(Rot q, Rot r, Rot out) {
+    assert (r != out);
+    assert (q != out);
+    // [qc -qs] * [rc -rs] = [qc*rc-qs*rs -qc*rs-qs*rc]
+    // [qs qc] [rs rc] [qs*rc+qc*rs -qs*rs+qc*rc]
+    // s = qs * rc + qc * rs
+    // c = qc * rc - qs * rs
+    out.s = q.s * r.c + q.c * r.s;
+    out.c = q.c * r.c - q.s * r.s;
+  }
+
+  public static final void mulTrans(Rot q, Rot r, Rot out) {
+    final float tempc = q.c * r.c + q.s * r.s;
+    out.s = q.c * r.s - q.s * r.c;
+    out.c = tempc;
+  }
+
+  public static final void mulTransUnsafe(Rot q, Rot r, Rot out) {
+    // [ qc qs] * [rc -rs] = [qc*rc+qs*rs -qc*rs+qs*rc]
+    // [-qs qc] [rs rc] [-qs*rc+qc*rs qs*rs+qc*rc]
+    // s = qc * rs - qs * rc
+    // c = qc * rc + qs * rs
+    out.s = q.c * r.s - q.s * r.c;
+    out.c = q.c * r.c + q.s * r.s;
+  }
+
+  public static final void mulToOut(Rot q, Vec2 v, Vec2 out) {
+    float tempy = q.s * v.x + q.c * v.y;
+    out.x = q.c * v.x - q.s * v.y;
+    out.y = tempy;
+  }
+
+  public static final void mulToOutUnsafe(Rot q, Vec2 v, Vec2 out) {
+    out.x = q.c * v.x - q.s * v.y;
+    out.y = q.s * v.x + q.c * v.y;
+  }
+
+  public static final void mulTrans(Rot q, Vec2 v, Vec2 out) {
+    final float tempy = -q.s * v.x + q.c * v.y;
+    out.x = q.c * v.x + q.s * v.y;
+    out.y = tempy;
+  }
+
+  public static final void mulTransUnsafe(Rot q, Vec2 v, Vec2 out) {
+    out.x = q.c * v.x + q.s * v.y;
+    out.y = -q.s * v.x + q.c * v.y;
+  }
+}

data/src/org/jbox2d/common/Settings.java

@@ -0,0 +1,246 @@
+/*******************************************************************************
+ * Copyright (c) 2013, Daniel Murphy
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ * 	* Redistributions of source code must retain the above copyright notice,
+ * 	  this list of conditions and the following disclaimer.
+ * 	* Redistributions in binary form must reproduce the above copyright notice,
+ * 	  this list of conditions and the following disclaimer in the documentation
+ * 	  and/or other materials provided with the distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ ******************************************************************************/
+package org.jbox2d.common;
+
+/**
+ * Global tuning constants based on MKS units and various integer maximums (vertices per shape,
+ * pairs, etc.).
+ */
+public class Settings {
+
+  /** A "close to zero" float epsilon value for use */
+  public static final float EPSILON = 1.1920928955078125E-7f;
+
+  /** Pi. */
+  public static final float PI = (float) Math.PI;
+
+  // JBox2D specific settings
+  public static boolean FAST_ABS = true;
+  public static boolean FAST_FLOOR = true;
+  public static boolean FAST_CEIL = true;
+  public static boolean FAST_ROUND = true;
+  public static boolean FAST_ATAN2 = true;
+  public static boolean FAST_POW = true;
+  public static int CONTACT_STACK_INIT_SIZE = 10;
+  public static boolean SINCOS_LUT_ENABLED = true;
+  /**
+   * smaller the precision, the larger the table. If a small table is used (eg, precision is .006 or
+   * greater), make sure you set the table to lerp it's results. Accuracy chart is in the MathUtils
+   * source. Or, run the tests yourself in {@link SinCosTest}.</br> </br> Good lerp precision
+   * values:
+   * <ul>
+   * <li>.0092</li>
+   * <li>.008201</li>
+   * <li>.005904</li>
+   * <li>.005204</li>
+   * <li>.004305</li>
+   * <li>.002807</li>
+   * <li>.001508</li>
+   * <li>9.32500E-4</li>
+   * <li>7.48000E-4</li>
+   * <li>8.47000E-4</li>
+   * <li>.0005095</li>
+   * <li>.0001098</li>
+   * <li>9.50499E-5</li>
+   * <li>6.08500E-5</li>
+   * <li>3.07000E-5</li>
+   * <li>1.53999E-5</li>
+   * </ul>
+   */
+  public static final float SINCOS_LUT_PRECISION = .00011f;
+  public static final int SINCOS_LUT_LENGTH = (int) Math.ceil(Math.PI * 2 / SINCOS_LUT_PRECISION);
+  /**
+   * Use if the table's precision is large (eg .006 or greater). Although it is more expensive, it
+   * greatly increases accuracy. Look in the MathUtils source for some test results on the accuracy
+   * and speed of lerp vs non lerp. Or, run the tests yourself in {@link SinCosTest}.
+   */
+  public static boolean SINCOS_LUT_LERP = false;
+
+
+  // Collision
+
+  /**
+   * The maximum number of contact points between two convex shapes.
+   */
+  public static int maxManifoldPoints = 2;
+
+  /**
+   * The maximum number of vertices on a convex polygon.
+   */
+  public static int maxPolygonVertices = 8;
+
+  /**
+   * This is used to fatten AABBs in the dynamic tree. This allows proxies to move by a small amount
+   * without triggering a tree adjustment. This is in meters.
+   */
+  public static float aabbExtension = 0.1f;
+
+  /**
+   * This is used to fatten AABBs in the dynamic tree. This is used to predict the future position
+   * based on the current displacement. This is a dimensionless multiplier.
+   */
+  public static float aabbMultiplier = 2.0f;
+
+  /**
+   * A small length used as a collision and constraint tolerance. Usually it is chosen to be
+   * numerically significant, but visually insignificant.
+   */
+  public static float linearSlop = 0.005f;
+
+  /**
+   * A small angle used as a collision and constraint tolerance. Usually it is chosen to be
+   * numerically significant, but visually insignificant.
+   */
+  public static float angularSlop = (2.0f / 180.0f * PI);
+
+  /**
+   * The radius of the polygon/edge shape skin. This should not be modified. Making this smaller
+   * means polygons will have and insufficient for continuous collision. Making it larger may create
+   * artifacts for vertex collision.
+   */
+  public static float polygonRadius = (2.0f * linearSlop);
+
+  /** Maximum number of sub-steps per contact in continuous physics simulation. */
+  public static int maxSubSteps = 8;
+
+  // Dynamics
+
+  /**
+   * Maximum number of contacts to be handled to solve a TOI island.
+   */
+  public static int maxTOIContacts = 32;
+
+  /**
+   * A velocity threshold for elastic collisions. Any collision with a relative linear velocity
+   * below this threshold will be treated as inelastic.
+   */
+  public static float velocityThreshold = 1.0f;
+
+  /**
+   * The maximum linear position correction used when solving constraints. This helps to prevent
+   * overshoot.
+   */
+  public static float maxLinearCorrection = 0.2f;
+
+  /**
+   * The maximum angular position correction used when solving constraints. This helps to prevent
+   * overshoot.
+   */
+  public static float maxAngularCorrection = (8.0f / 180.0f * PI);
+
+  /**
+   * The maximum linear velocity of a body. This limit is very large and is used to prevent
+   * numerical problems. You shouldn't need to adjust this.
+   */
+  public static float maxTranslation = 2.0f;
+  public static float maxTranslationSquared = (maxTranslation * maxTranslation);
+
+  /**
+   * The maximum angular velocity of a body. This limit is very large and is used to prevent
+   * numerical problems. You shouldn't need to adjust this.
+   */
+  public static float maxRotation = (0.5f * PI);
+  public static float maxRotationSquared = (maxRotation * maxRotation);
+
+  /**
+   * This scale factor controls how fast overlap is resolved. Ideally this would be 1 so that
+   * overlap is removed in one time step. However using values close to 1 often lead to overshoot.
+   */
+  public static float baumgarte = 0.2f;
+  public static float toiBaugarte = 0.75f;
+
+
+  // Sleep
+
+  /**
+   * The time that a body must be still before it will go to sleep.
+   */
+  public static float timeToSleep = 0.5f;
+
+  /**
+   * A body cannot sleep if its linear velocity is above this tolerance.
+   */
+  public static float linearSleepTolerance = 0.01f;
+
+  /**
+   * A body cannot sleep if its angular velocity is above this tolerance.
+   */
+  public static float angularSleepTolerance = (2.0f / 180.0f * PI);
+
+  // Particle
+
+  /**
+   * A symbolic constant that stands for particle allocation error.
+   */
+  public static final int invalidParticleIndex = (-1);
+
+  /**
+   * The standard distance between particles, divided by the particle radius.
+   */
+  public static final float particleStride = 0.75f;
+
+  /**
+   * The minimum particle weight that produces pressure.
+   */
+  public static final float minParticleWeight = 1.0f;
+
+  /**
+   * The upper limit for particle weight used in pressure calculation.
+   */
+  public static final float maxParticleWeight = 5.0f;
+
+  /**
+   * The maximum distance between particles in a triad, divided by the particle radius.
+   */
+  public static final int maxTriadDistance = 2;
+  public static final int maxTriadDistanceSquared = (maxTriadDistance * maxTriadDistance);
+
+  /**
+   * The initial size of particle data buffers.
+   */
+  public static final int minParticleBufferCapacity = 256;
+
+
+  /**
+   * Friction mixing law. Feel free to customize this. TODO djm: add customization
+   * 
+   * @param friction1
+   * @param friction2
+   * @return
+   */
+  public static float mixFriction(float friction1, float friction2) {
+    return MathUtils.sqrt(friction1 * friction2);
+  }
+
+  /**
+   * Restitution mixing law. Feel free to customize this. TODO djm: add customization
+   * 
+   * @param restitution1
+   * @param restitution2
+   * @return
+   */
+  public static float mixRestitution(float restitution1, float restitution2) {
+    return restitution1 > restitution2 ? restitution1 : restitution2;
+  }
+}