pbox2d 0.6.0-java → 0.8.0-java

data/src/org/jbox2d/particle/ParticleType.java

@@ -0,0 +1,28 @@
+package org.jbox2d.particle;
+
+/**
+ * The particle type. Can be combined with | operator. Zero means liquid.
+ * 
+ * @author dmurph
+ */
+public class ParticleType {
+  public static final int b2_waterParticle = 0;
+  /** removed after next step */
+  public static final int b2_zombieParticle = 1 << 1;
+  /** zero velocity */
+  public static final int b2_wallParticle = 1 << 2;
+  /** with restitution from stretching */
+  public static final int b2_springParticle = 1 << 3;
+  /** with restitution from deformation */
+  public static final int b2_elasticParticle = 1 << 4;
+  /** with viscosity */
+  public static final int b2_viscousParticle = 1 << 5;
+  /** without isotropic pressure */
+  public static final int b2_powderParticle = 1 << 6;
+  /** with surface tension */
+  public static final int b2_tensileParticle = 1 << 7;
+  /** mixing color between contacting particles */
+  public static final int b2_colorMixingParticle = 1 << 8;
+  /** call b2DestructionListener on destruction */
+  public static final int b2_destructionListener = 1 << 9;
+}

data/src/org/jbox2d/particle/StackQueue.java

@@ -0,0 +1,44 @@
+package org.jbox2d.particle;
+
+
+public class StackQueue<T> {
+
+  private T[] m_buffer;
+  private int m_front;
+  private int m_back;
+  private int m_end;
+
+  public StackQueue() {}
+
+  public void reset(T[] buffer) {
+    m_buffer = buffer;
+    m_front = 0;
+    m_back = 0;
+    m_end = buffer.length;
+  }
+
+  public void push(T task) {
+    if (m_back >= m_end) {
+      System.arraycopy(m_buffer, m_front, m_buffer, 0, m_back - m_front);
+      m_back -= m_front;
+      m_front = 0;
+      if (m_back >= m_end) {
+        return;
+      }
+    }
+    m_buffer[m_back++] = task;
+  }
+
+  public T pop() {
+    assert (m_front < m_back);
+    return m_buffer[m_front++];
+  }
+
+  public boolean empty() {
+    return m_front >= m_back;
+  }
+
+  public T front() {
+    return m_buffer[m_front];
+  }
+}

data/src/org/jbox2d/particle/VoronoiDiagram.java

@@ -0,0 +1,209 @@
+package org.jbox2d.particle;
+
+import org.jbox2d.common.MathUtils;
+import org.jbox2d.common.Vec2;
+import org.jbox2d.pooling.normal.MutableStack;
+
+public class VoronoiDiagram {
+  public static class Generator {
+    final Vec2 center = new Vec2();
+    int tag;
+  }
+  public static class VoronoiDiagramTask {
+    int m_x, m_y, m_i;
+    Generator m_generator;
+
+    public VoronoiDiagramTask() {}
+
+    public VoronoiDiagramTask(int x, int y, int i, Generator g) {
+      m_x = x;
+      m_y = y;
+      m_i = i;
+      m_generator = g;
+    }
+
+    public VoronoiDiagramTask set(int x, int y, int i, Generator g) {
+      m_x = x;
+      m_y = y;
+      m_i = i;
+      m_generator = g;
+      return this;
+    }
+  }
+
+  public static interface VoronoiDiagramCallback {
+    void callback(int aTag, int bTag, int cTag);
+  }
+
+  private Generator[] m_generatorBuffer;
+  private int m_generatorCount;
+  private int m_countX, m_countY;
+  // The diagram is an array of "pointers".
+  private Generator[] m_diagram;
+
+  public VoronoiDiagram(int generatorCapacity) {
+    m_generatorBuffer = new Generator[generatorCapacity];
+    for (int i = 0; i < generatorCapacity; i++) {
+      m_generatorBuffer[i] = new Generator();
+    }
+    m_generatorCount = 0;
+    m_countX = 0;
+    m_countY = 0;
+    m_diagram = null;
+  }
+
+  public void getNodes(VoronoiDiagramCallback callback) {
+    for (int y = 0; y < m_countY - 1; y++) {
+      for (int x = 0; x < m_countX - 1; x++) {
+        int i = x + y * m_countX;
+        Generator a = m_diagram[i];
+        Generator b = m_diagram[i + 1];
+        Generator c = m_diagram[i + m_countX];
+        Generator d = m_diagram[i + 1 + m_countX];
+        if (b != c) {
+          if (a != b && a != c) {
+            callback.callback(a.tag, b.tag, c.tag);
+          }
+          if (d != b && d != c) {
+            callback.callback(b.tag, d.tag, c.tag);
+          }
+        }
+      }
+    }
+  }
+
+  public void addGenerator(Vec2 center, int tag) {
+    Generator g = m_generatorBuffer[m_generatorCount++];
+    g.center.x = center.x;
+    g.center.y = center.y;
+    g.tag = tag;
+  }
+
+  private final Vec2 lower = new Vec2();
+  private final Vec2 upper = new Vec2();
+  private MutableStack<VoronoiDiagramTask> taskPool =
+      new MutableStack<VoronoiDiagram.VoronoiDiagramTask>(50) {
+        @Override
+        protected VoronoiDiagramTask newInstance() {
+          return new VoronoiDiagramTask();
+        }
+
+        @Override
+        protected VoronoiDiagramTask[] newArray(int size) {
+          return new VoronoiDiagramTask[size];
+        }
+      };
+  private final StackQueue<VoronoiDiagramTask> queue = new StackQueue<VoronoiDiagramTask>();
+
+  public void generate(float radius) {
+    assert (m_diagram == null);
+    float inverseRadius = 1 / radius;
+    lower.x = Float.MAX_VALUE;
+    lower.y = Float.MAX_VALUE;
+    upper.x = -Float.MAX_VALUE;
+    upper.y = -Float.MAX_VALUE;
+    for (int k = 0; k < m_generatorCount; k++) {
+      Generator g = m_generatorBuffer[k];
+      Vec2.minToOut(lower, g.center, lower);
+      Vec2.maxToOut(upper, g.center, upper);
+    }
+    m_countX = 1 + (int) (inverseRadius * (upper.x - lower.x));
+    m_countY = 1 + (int) (inverseRadius * (upper.y - lower.y));
+    m_diagram = new Generator[m_countX * m_countY];
+    queue.reset(new VoronoiDiagramTask[4 * m_countX * m_countX]);
+    for (int k = 0; k < m_generatorCount; k++) {
+      Generator g = m_generatorBuffer[k];
+      g.center.x = inverseRadius * (g.center.x - lower.x);
+      g.center.y = inverseRadius * (g.center.y - lower.y);
+      int x = MathUtils.max(0, MathUtils.min((int) g.center.x, m_countX - 1));
+      int y = MathUtils.max(0, MathUtils.min((int) g.center.y, m_countY - 1));
+      queue.push(taskPool.pop().set(x, y, x + y * m_countX, g));
+    }
+    while (!queue.empty()) {
+      VoronoiDiagramTask front = queue.pop();
+      int x = front.m_x;
+      int y = front.m_y;
+      int i = front.m_i;
+      Generator g = front.m_generator;
+      if (m_diagram[i] == null) {
+        m_diagram[i] = g;
+        if (x > 0) {
+          queue.push(taskPool.pop().set(x - 1, y, i - 1, g));
+        }
+        if (y > 0) {
+          queue.push(taskPool.pop().set(x, y - 1, i - m_countX, g));
+        }
+        if (x < m_countX - 1) {
+          queue.push(taskPool.pop().set(x + 1, y, i + 1, g));
+        }
+        if (y < m_countY - 1) {
+          queue.push(taskPool.pop().set(x, y + 1, i + m_countX, g));
+        }
+      }
+      taskPool.push(front);
+    }
+    int maxIteration = m_countX + m_countY;
+    for (int iteration = 0; iteration < maxIteration; iteration++) {
+      for (int y = 0; y < m_countY; y++) {
+        for (int x = 0; x < m_countX - 1; x++) {
+          int i = x + y * m_countX;
+          Generator a = m_diagram[i];
+          Generator b = m_diagram[i + 1];
+          if (a != b) {
+            queue.push(taskPool.pop().set(x, y, i, b));
+            queue.push(taskPool.pop().set(x + 1, y, i + 1, a));
+          }
+        }
+      }
+      for (int y = 0; y < m_countY - 1; y++) {
+        for (int x = 0; x < m_countX; x++) {
+          int i = x + y * m_countX;
+          Generator a = m_diagram[i];
+          Generator b = m_diagram[i + m_countX];
+          if (a != b) {
+            queue.push(taskPool.pop().set(x, y, i, b));
+            queue.push(taskPool.pop().set(x, y + 1, i + m_countX, a));
+          }
+        }
+      }
+      boolean updated = false;
+      while (!queue.empty()) {
+        VoronoiDiagramTask front = queue.pop();
+        int x = front.m_x;
+        int y = front.m_y;
+        int i = front.m_i;
+        Generator k = front.m_generator;
+        Generator a = m_diagram[i];
+        Generator b = k;
+        if (a != b) {
+          float ax = a.center.x - x;
+          float ay = a.center.y - y;
+          float bx = b.center.x - x;
+          float by = b.center.y - y;
+          float a2 = ax * ax + ay * ay;
+          float b2 = bx * bx + by * by;
+          if (a2 > b2) {
+            m_diagram[i] = b;
+            if (x > 0) {
+              queue.push(taskPool.pop().set(x - 1, y, i - 1, b));
+            }
+            if (y > 0) {
+              queue.push(taskPool.pop().set(x, y - 1, i - m_countX, b));
+            }
+            if (x < m_countX - 1) {
+              queue.push(taskPool.pop().set(x + 1, y, i + 1, b));
+            }
+            if (y < m_countY - 1) {
+              queue.push(taskPool.pop().set(x, y + 1, i + m_countX, b));
+            }
+            updated = true;
+          }
+        }
+        taskPool.push(front);
+      }
+      if (!updated) {
+        break;
+      }
+    }
+  }
+}

data/src/org/jbox2d/pooling/IDynamicStack.java

@@ -0,0 +1,47 @@
+/*******************************************************************************
+ * 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.pooling;
+
+/**
+ * Same functionality of a regular java.util stack.  Object
+ * return order does not matter.
+ * @author Daniel
+ *
+ * @param <E>
+ */
+public interface IDynamicStack<E> {
+
+	/**
+	 * Pops an item off the stack
+	 * @return
+	 */
+	public E pop();
+
+	/**
+	 * Pushes an item back on the stack
+	 * @param argObject
+	 */
+	public void push(E argObject);
+
+}

data/src/org/jbox2d/pooling/IOrderedStack.java

@@ -0,0 +1,57 @@
+/*******************************************************************************
+ * 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.pooling;
+
+/**
+ * This stack assumes that when you push 'n' items back,
+ * you're pushing back the last 'n' items popped.
+ * @author Daniel
+ *
+ * @param <E>
+ */
+public interface IOrderedStack<E> {
+
+	/**
+	 * Returns the next object in the pool
+	 * @return
+	 */
+	public E pop();
+
+	/**
+	 * Returns the next 'argNum' objects in the pool
+	 * in an array
+	 * @param argNum
+	 * @return an array containing the next pool objects in
+	 * 		   items 0-argNum.  Array length and uniqueness not
+	 * 		   guaranteed.
+	 */
+	public E[] pop(int argNum);
+
+	/**
+	 * Tells the stack to take back the last 'argNum' items
+	 * @param argNum
+	 */
+	public void push(int argNum);
+
+}

data/src/org/jbox2d/pooling/IWorldPool.java

@@ -0,0 +1,101 @@
+/*******************************************************************************
+ * 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.pooling;
+
+import org.jbox2d.collision.AABB;
+import org.jbox2d.collision.Collision;
+import org.jbox2d.collision.Distance;
+import org.jbox2d.collision.TimeOfImpact;
+import org.jbox2d.common.Mat22;
+import org.jbox2d.common.Mat33;
+import org.jbox2d.common.Rot;
+import org.jbox2d.common.Vec2;
+import org.jbox2d.common.Vec3;
+import org.jbox2d.dynamics.contacts.Contact;
+
+/**
+ * World pool interface
+ * @author Daniel
+ *
+ */
+public interface IWorldPool {
+
+	public IDynamicStack<Contact> getPolyContactStack();
+
+	public IDynamicStack<Contact> getCircleContactStack();
+
+	public IDynamicStack<Contact> getPolyCircleContactStack();
+	
+    public IDynamicStack<Contact> getEdgeCircleContactStack();
+    
+    public IDynamicStack<Contact> getEdgePolyContactStack();
+
+    public IDynamicStack<Contact> getChainCircleContactStack();
+    
+    public IDynamicStack<Contact> getChainPolyContactStack();
+    
+	public Vec2 popVec2();
+
+	public Vec2[] popVec2(int num);
+
+	public void pushVec2(int num);
+
+	public Vec3 popVec3();
+
+	public Vec3[] popVec3(int num);
+
+	public void pushVec3(int num);
+
+	public Mat22 popMat22();
+
+	public Mat22[] popMat22(int num);
+
+	public void pushMat22(int num);
+	
+	public Mat33 popMat33();
+	
+	public void pushMat33(int num);
+
+	public AABB popAABB();
+
+	public AABB[] popAABB(int num);
+
+	public void pushAABB(int num);
+	
+	public Rot popRot();
+
+	public void pushRot(int num);
+	
+	public Collision getCollision();
+
+	public TimeOfImpact getTimeOfImpact();
+
+	public Distance getDistance();
+
+	public float[] getFloatArray(int argLength);
+
+	public int[] getIntArray(int argLength);
+
+	public Vec2[] getVec2Array(int argLength);
+}

data/src/org/jbox2d/pooling/arrays/FloatArray.java

@@ -0,0 +1,50 @@
+/*******************************************************************************
+ * 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.pooling.arrays;
+
+import java.util.HashMap;
+
+/**
+ * Not thread safe float[] pooling.
+ * @author Daniel
+ */
+public class FloatArray {
+	
+	private final HashMap<Integer, float[]> map = new HashMap<>();
+	
+	public float[] get( int argLength){
+		assert(argLength > 0);
+				
+		if(!map.containsKey(argLength)){
+			map.put(argLength, getInitializedArray(argLength));
+		}
+		
+		assert(map.get(argLength).length == argLength) : "Array not built of correct length";
+		return map.get(argLength);
+	}
+	
+	protected float[] getInitializedArray(int argLength){
+		return new float[argLength];
+	}
+}

data/src/org/jbox2d/pooling/arrays/GeneratorArray.java

@@ -0,0 +1,33 @@
+package org.jbox2d.pooling.arrays;
+
+import java.util.HashMap;
+
+import org.jbox2d.particle.VoronoiDiagram;
+
+public class GeneratorArray {
+
+  private final HashMap<Integer, VoronoiDiagram.Generator[]> map;
+
+    public GeneratorArray() {
+        this.map = new HashMap<>();
+    }
+
+  public VoronoiDiagram.Generator[] get(int length) {
+    assert (length > 0);
+
+    if (!map.containsKey(length)) {
+      map.put(length, getInitializedArray(length));
+    }
+
+    assert (map.get(length).length == length) : "Array not built of correct length";
+    return map.get(length);
+  }
+
+  protected VoronoiDiagram.Generator[] getInitializedArray(int length) {
+    final VoronoiDiagram.Generator[] ray = new VoronoiDiagram.Generator[length];
+    for (int i = 0; i < ray.length; i++) {
+      ray[i] = new VoronoiDiagram.Generator();
+    }
+    return ray;
+  }
+}

data/src/org/jbox2d/pooling/arrays/IntArray.java

@@ -0,0 +1,53 @@
+/*******************************************************************************
+ * 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.
+ ******************************************************************************/
+/**
+ * Created at 4:14:34 AM Jul 17, 2010
+ */
+package org.jbox2d.pooling.arrays;
+
+import java.util.HashMap;
+
+/**
+ * Not thread safe int[] pooling
+ * @author Daniel Murphy
+ */
+public class IntArray {
+	
+	private final HashMap<Integer, int[]> map = new HashMap<>();
+	
+	public int[] get( int argLength){
+		assert(argLength > 0);
+		
+		if(!map.containsKey(argLength)){
+			map.put(argLength, getInitializedArray(argLength));
+		}
+		
+		assert(map.get(argLength).length == argLength) : "Array not built of correct length";
+		return map.get(argLength);
+	}
+	
+	protected int[] getInitializedArray(int argLength){
+		return new int[argLength];
+	}
+}

data/src/org/jbox2d/pooling/arrays/Vec2Array.java

@@ -0,0 +1,57 @@
+/*******************************************************************************
+ * 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.pooling.arrays;
+
+import java.util.HashMap;
+
+import org.jbox2d.common.Vec2;
+
+/**
+ * not thread safe Vec2[] pool
+ * @author dmurph
+ *
+ */
+public class Vec2Array {
+
+	private final HashMap<Integer, Vec2[]> map = new HashMap<>();
+	
+	public Vec2[] get( int argLength){
+		assert(argLength > 0);
+		
+		if(!map.containsKey(argLength)){
+			map.put(argLength, getInitializedArray(argLength));
+		}
+		
+		assert(map.get(argLength).length == argLength) : "Array not built of correct length";
+		return map.get(argLength);
+	}
+	
+	protected Vec2[] getInitializedArray(int argLength){
+		final Vec2[] ray = new Vec2[argLength];
+		for (int i = 0; i < ray.length; i++) {
+			ray[i] = new Vec2();
+		}
+		return ray;
+	}
+}