pbox2d 0.6.0-java → 0.8.0-java

data/src/org/jbox2d/collision/shapes/Shape.java

@@ -0,0 +1,136 @@
+/*******************************************************************************
+ * 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.collision.shapes;
+
+import org.jbox2d.collision.AABB;
+import org.jbox2d.collision.RayCastInput;
+import org.jbox2d.collision.RayCastOutput;
+import org.jbox2d.common.Transform;
+import org.jbox2d.common.Vec2;
+
+/**
+ * A shape is used for collision detection. You can create a shape however you like. Shapes used for
+ * simulation in World are created automatically when a Fixture is created. Shapes may encapsulate a
+ * one or more child shapes.
+ */
+public abstract class Shape {
+
+  public final ShapeType m_type;
+  public float m_radius;
+
+  public Shape(ShapeType type) {
+    this.m_type = type;
+  }
+
+  /**
+   * Get the type of this shape. You can use this to down cast to the concrete shape.
+   * 
+   * @return the shape type.
+   */
+  public ShapeType getType() {
+    return m_type;
+  }
+
+  /**
+   * The radius of the underlying shape. This can refer to different things depending on the shape
+   * implementation
+   * 
+   * @return
+   */
+  public float getRadius() {
+    return m_radius;
+  }
+
+  /**
+   * Sets the radius of the underlying shape. This can refer to different things depending on the
+   * implementation
+   * 
+   * @param radius
+   */
+  public void setRadius(float radius) {
+    this.m_radius = radius;
+  }
+
+  /**
+   * Get the number of child primitives
+   * 
+   * @return
+   */
+  public abstract int getChildCount();
+
+  /**
+   * Test a point for containment in this shape. This only works for convex shapes.
+   * 
+   * @param xf the shape world transform.
+   * @param p a point in world coordinates.
+     * @return 
+   */
+  public abstract boolean testPoint(final Transform xf, final Vec2 p);
+
+  /**
+   * Cast a ray against a child shape.
+   * 
+   * @param output
+   * @param input
+   * @param transform
+   * @param childIndex
+   *  @return if hit
+   */
+  public abstract boolean raycast(RayCastOutput output, RayCastInput input, Transform transform,
+      int childIndex);
+
+
+  /**
+   * Given a transform, compute the associated axis aligned bounding box for a child shape.
+   * 
+   * @param aabb returns the axis aligned box.
+   * @param xf the world transform of the shape.
+   * @param childIndex
+   */
+  public abstract void computeAABB(final AABB aabb, final Transform xf, int childIndex);
+
+  /**
+   * Compute the mass properties of this shape using its dimensions and density. The inertia tensor
+   * is computed about the local origin.
+   * 
+   * @param massData returns the mass data for this shape.
+   * @param density the density in kilograms per meter squared.
+   */
+  public abstract void computeMass(final MassData massData, final float density);
+
+  /**
+   * Compute the distance from the current shape to the specified point. This only works for convex
+   * shapes.
+   * 
+   * @param xf the shape world transform.
+   * @param p a point in world coordinates.
+   * @param childIndex
+   * @param normalOut returns the direction in which the distance increases.
+   * @return distance returns the distance from the current shape.
+   */
+  public abstract float computeDistanceToOut(Transform xf, Vec2 p, int childIndex, Vec2 normalOut);
+
+  @Override
+  public abstract Shape clone();
+}

data/src/org/jbox2d/collision/shapes/ShapeType.java

@@ -0,0 +1,32 @@
+/*******************************************************************************
+ * 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.collision.shapes;
+
+/**
+ * Types of shapes
+ * @author Daniel
+ */
+public enum ShapeType {
+	CIRCLE, EDGE, POLYGON, CHAIN
+}

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

@@ -0,0 +1,209 @@
+package org.jbox2d.common;
+
+import java.lang.reflect.Array;
+
+public class BufferUtils {
+
+    /**
+     * Reallocate a buffer.
+     *
+     * @param <T>
+     * @param klass
+     * @param oldBuffer
+     * @param oldCapacity
+     * @param newCapacity
+     * @return
+     */
+    public static <T> T[] reallocateBuffer(Class<T> klass, T[] oldBuffer, int oldCapacity,
+            int newCapacity) {
+        assert (newCapacity > oldCapacity);
+        @SuppressWarnings("unchecked")
+        T[] newBuffer = (T[]) Array.newInstance(klass, newCapacity);
+        if (oldBuffer != null) {
+            System.arraycopy(oldBuffer, 0, newBuffer, 0, oldCapacity);
+        }
+        for (int i = oldCapacity; i < newCapacity; i++) {
+            try {
+                newBuffer[i] = klass.newInstance();
+            } catch (InstantiationException | IllegalAccessException e) {
+                throw new RuntimeException(e);
+            }
+        }
+        return newBuffer;
+    }
+
+    /**
+     * Reallocate a buffer.
+     *
+     * @param oldBuffer
+     * @param oldCapacity
+     * @param newCapacity
+     * @return
+     */
+    public static int[] reallocateBuffer(int[] oldBuffer, int oldCapacity, int newCapacity) {
+        assert (newCapacity > oldCapacity);
+        int[] newBuffer = new int[newCapacity];
+        if (oldBuffer != null) {
+            System.arraycopy(oldBuffer, 0, newBuffer, 0, oldCapacity);
+        }
+        return newBuffer;
+    }
+
+    /**
+     * Reallocate a buffer.
+     *
+     * @param oldBuffer
+     * @param oldCapacity
+     * @param newCapacity
+     * @return
+     */
+    public static float[] reallocateBuffer(float[] oldBuffer, int oldCapacity, int newCapacity) {
+        assert (newCapacity > oldCapacity);
+        float[] newBuffer = new float[newCapacity];
+        if (oldBuffer != null) {
+            System.arraycopy(oldBuffer, 0, newBuffer, 0, oldCapacity);
+        }
+        return newBuffer;
+    }
+
+    /**
+     * Reallocate a buffer. A 'deferred' buffer is reallocated only if it is not
+     * NULL. If 'userSuppliedCapacity' is not zero, buffer is user supplied and
+     * must be kept.
+     *
+     * @param <T>
+     * @param klass
+     * @param buffer
+     * @param userSuppliedCapacity
+     * @param oldCapacity
+     * @param newCapacity
+     * @param deferred
+     * @return
+     */
+    public static <T> T[] reallocateBuffer(Class<T> klass, T[] buffer, int userSuppliedCapacity,
+            int oldCapacity, int newCapacity, boolean deferred) {
+        assert (newCapacity > oldCapacity);
+        assert (userSuppliedCapacity == 0 || newCapacity <= userSuppliedCapacity);
+        if ((!deferred || buffer != null) && userSuppliedCapacity == 0) {
+            buffer = reallocateBuffer(klass, buffer, oldCapacity, newCapacity);
+        }
+        return buffer;
+    }
+
+    /**
+     * Reallocate an int buffer. A 'deferred' buffer is reallocated only if it
+     * is not NULL. If 'userSuppliedCapacity' is not zero, buffer is user
+     * supplied and must be kept.
+     *
+     * @param buffer
+     * @param userSuppliedCapacity
+     * @param oldCapacity
+     * @param newCapacity
+     * @param deferred
+     * @return
+     */
+    public static int[] reallocateBuffer(int[] buffer, int userSuppliedCapacity, int oldCapacity,
+            int newCapacity, boolean deferred) {
+        assert (newCapacity > oldCapacity);
+        assert (userSuppliedCapacity == 0 || newCapacity <= userSuppliedCapacity);
+        if ((!deferred || buffer != null) && userSuppliedCapacity == 0) {
+            buffer = reallocateBuffer(buffer, oldCapacity, newCapacity);
+        }
+        return buffer;
+    }
+
+    /**
+     * Reallocate a float buffer. A 'deferred' buffer is reallocated only if it
+     * is not NULL. If 'userSuppliedCapacity' is not zero, buffer is user
+     * supplied and must be kept.
+     *
+     * @param buffer
+     * @param userSuppliedCapacity
+     * @param oldCapacity
+     * @param newCapacity
+     * @param deferred
+     * @return
+     */
+    public static float[] reallocateBuffer(float[] buffer, int userSuppliedCapacity, int oldCapacity,
+            int newCapacity, boolean deferred) {
+        assert (newCapacity > oldCapacity);
+        assert (userSuppliedCapacity == 0 || newCapacity <= userSuppliedCapacity);
+        if ((!deferred || buffer != null) && userSuppliedCapacity == 0) {
+            buffer = reallocateBuffer(buffer, oldCapacity, newCapacity);
+        }
+        return buffer;
+    }
+
+    /**
+     * Rotate an array, see std::rotate
+     *
+     * @param <T>
+     * @param ray
+     * @param first
+     * @param new_first
+     * @param last
+     */
+    public static <T> void rotate(T[] ray, int first, int new_first, int last) {
+        int next = new_first;
+        while (next != first) {
+            T temp = ray[first];
+            ray[first] = ray[next];
+            ray[next] = temp;
+            first++;
+            next++;
+            if (next == last) {
+                next = new_first;
+            } else if (first == new_first) {
+                new_first = next;
+            }
+        }
+    }
+
+    /**
+     * Rotate an array, see std::rotate
+     *
+     * @param ray
+     * @param first
+     * @param new_first
+     * @param last
+     */
+    public static void rotate(int[] ray, int first, int new_first, int last) {
+        int next = new_first;
+        while (next != first) {
+            int temp = ray[first];
+            ray[first] = ray[next];
+            ray[next] = temp;
+            first++;
+            next++;
+            if (next == last) {
+                next = new_first;
+            } else if (first == new_first) {
+                new_first = next;
+            }
+        }
+    }
+
+    /**
+     * Rotate an array, see std::rotate
+     *
+     * @param ray
+     * @param first
+     * @param new_first
+     * @param last
+     */
+    public static void rotate(float[] ray, int first, int new_first, int last) {
+        int next = new_first;
+        while (next != first) {
+            float temp = ray[first];
+            ray[first] = ray[next];
+            ray[next] = temp;
+            first++;
+            next++;
+            if (next == last) {
+                next = new_first;
+            } else if (first == new_first) {
+                new_first = next;
+            }
+        }
+    }
+}

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

@@ -0,0 +1,88 @@
+/*******************************************************************************
+ * 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.
+ ******************************************************************************/
+/*
+ * JBox2D - A Java Port of Erin Catto's Box2D
+ * 
+ * JBox2D homepage: http://jbox2d.sourceforge.net/ 
+ * Box2D homepage: http://www.box2d.org
+ * 
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ * 
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ * 
+ * 1. The origin of this software must not be misrepresented; you must not
+ * claim that you wrote the original software. If you use this software
+ * in a product, an acknowledgment in the product documentation would be
+ * appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ * misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+package org.jbox2d.common;
+
+// updated to rev 100
+/**
+ * Similar to javax.vecmath.Color3f holder
+ * @author ewjordan
+ *
+ */
+public class Color3f {
+	
+	public static final Color3f WHITE = new Color3f(1, 1, 1);
+	public static final Color3f BLACK = new Color3f(0, 0, 0);
+	public static final Color3f BLUE = new Color3f(0, 0, 1);
+	public static final Color3f GREEN = new Color3f(0, 1, 0);
+	public static final Color3f RED = new Color3f(1, 0, 0);
+	
+	public float x;
+	public float y;
+	public float z;
+
+	
+	public Color3f(){
+		x = y = z = 0;
+	}
+	public Color3f(float r, float g, float b) {
+		x = r;
+		y = g;
+		z = b;
+	}
+	
+	public void set(float r, float g, float b){
+		x = r;
+		y = g;
+		z = b;
+	}
+	
+	public void set(Color3f argColor){
+		x = argColor.x;
+		y = argColor.y;
+		z = argColor.z;
+	}
+}

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

@@ -0,0 +1,133 @@
+/*******************************************************************************
+ * 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;
+
+/**
+ * This is the viewport transform used from drawing. Use yFlip if you are drawing from the top-left
+ * corner.
+ * 
+ * @author Daniel
+ */
+public interface IViewportTransform {
+
+  /**
+   * @return if the transform flips the y axis
+   */
+  boolean isYFlip();
+
+  /**
+   * @param yFlip if we flip the y axis when transforming
+   */
+  void setYFlip(boolean yFlip);
+
+  /**
+   * This is the half-width and half-height. This should be the actual half-width and half-height,
+   * not anything transformed or scaled. Not a copy.
+     * @return 
+   */
+  Vec2 getExtents();
+
+  /**
+   * This sets the half-width and half-height. This should be the actual half-width and half-height,
+   * not anything transformed or scaled.
+     * @param extents
+   */
+  void setExtents(Vec2 extents);
+
+  /**
+   * This sets the half-width and half-height of the viewport. This should be the actual half-width
+   * and half-height, not anything transformed or scaled.
+     * @param halfWidth
+     * @param halfHeight
+   */
+  void setExtents(float halfWidth, float halfHeight);
+
+  /**
+   * center of the viewport. Not a copy.
+     * @return 
+   */
+  Vec2 getCenter();
+
+  /**
+   * sets the center of the viewport.
+     * @param pos
+   */
+  void setCenter(Vec2 pos);
+
+  /**
+   * sets the center of the viewport.
+     * @param x
+     * @param y
+   */
+  void setCenter(float x, float y);
+
+  /**
+   * Sets the transform's center to the given x and y coordinates, and using the given scale.
+     * @param x
+     * @param y
+     * @param scale
+   */
+  void setCamera(float x, float y, float scale);
+
+  /**
+   * Transforms the given directional vector by the viewport transform (not positional)
+     * @param world
+     * @param screen
+   */
+  void getWorldVectorToScreen(Vec2 world, Vec2 screen);
+
+
+  /**
+   * Transforms the given directional screen vector back to the world direction.
+     * @param screen
+     * @param world
+   */
+  void getScreenVectorToWorld(Vec2 screen, Vec2 world);
+  
+  Mat22 getMat22Representation();
+
+
+  /**
+   * takes the world coordinate (world) puts the corresponding screen coordinate in screen. It
+   * should be safe to give the same object as both parameters.
+     * @param world
+     * @param screen
+   */
+  void getWorldToScreen(Vec2 world, Vec2 screen);
+
+
+  /**
+   * takes the screen coordinates (screen) and puts the corresponding world coordinates in world. It
+   * should be safe to give the same object as both parameters.
+     * @param screen
+     * @param world
+   */
+  void getScreenToWorld(Vec2 screen, Vec2 world);
+
+  /**
+   * Multiplies the viewport transform by the given Mat22
+     * @param transform
+   */
+  void mulByTransform(Mat22 transform);
+}