pbox2d 0.6.0-java → 0.8.0-java

data/src/org/jbox2d/collision/WorldManifold.java

@@ -0,0 +1,200 @@
+/*******************************************************************************
+ * 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;
+
+import org.jbox2d.common.MathUtils;
+import org.jbox2d.common.Rot;
+import org.jbox2d.common.Settings;
+import org.jbox2d.common.Transform;
+import org.jbox2d.common.Vec2;
+
+/**
+ * This is used to compute the current state of a contact manifold.
+ * 
+ * @author daniel
+ */
+public class WorldManifold {
+  /**
+   * World vector pointing from A to B
+   */
+  public final Vec2 normal;
+
+  /**
+   * World contact point (point of intersection)
+   */
+  public final Vec2[] points;
+
+  /**
+   * A negative value indicates overlap, in meters.
+   */
+  public final float[] separations;
+
+  public WorldManifold() {
+    normal = new Vec2();
+    points = new Vec2[Settings.maxManifoldPoints];
+    separations = new float[Settings.maxManifoldPoints];
+    for (int i = 0; i < Settings.maxManifoldPoints; i++) {
+      points[i] = new Vec2();
+    }
+  }
+
+  private final Vec2 pool3 = new Vec2();
+  private final Vec2 pool4 = new Vec2();
+
+  public final void initialize(final Manifold manifold, final Transform xfA, float radiusA,
+      final Transform xfB, float radiusB) {
+    if (manifold.pointCount == 0) {
+      return;
+    }
+
+    switch (manifold.type) {
+      case CIRCLES: {
+        final Vec2 pointA = pool3;
+        final Vec2 pointB = pool4;
+
+        normal.x = 1;
+        normal.y = 0;
+        Vec2 v = manifold.localPoint;
+        // Transform.mulToOutUnsafe(xfA, manifold.localPoint, pointA);
+        // Transform.mulToOutUnsafe(xfB, manifold.points[0].localPoint, pointB);
+        pointA.x = (xfA.q.c * v.x - xfA.q.s * v.y) + xfA.p.x;
+        pointA.y = (xfA.q.s * v.x + xfA.q.c * v.y) + xfA.p.y;
+        Vec2 mp0p = manifold.points[0].localPoint;
+        pointB.x = (xfB.q.c * mp0p.x - xfB.q.s * mp0p.y) + xfB.p.x;
+        pointB.y = (xfB.q.s * mp0p.x + xfB.q.c * mp0p.y) + xfB.p.y;
+
+        if (MathUtils.distanceSquared(pointA, pointB) > Settings.EPSILON * Settings.EPSILON) {
+          normal.x = pointB.x - pointA.x;
+          normal.y = pointB.y - pointA.y;
+          normal.normalize();
+        }
+
+        final float cAx = normal.x * radiusA + pointA.x;
+        final float cAy = normal.y * radiusA + pointA.y;
+
+        final float cBx = -normal.x * radiusB + pointB.x;
+        final float cBy = -normal.y * radiusB + pointB.y;
+
+        points[0].x = (cAx + cBx) * .5f;
+        points[0].y = (cAy + cBy) * .5f;
+        separations[0] = (cBx - cAx) * normal.x + (cBy - cAy) * normal.y;
+      }
+        break;
+      case FACE_A: {
+        final Vec2 planePoint = pool3;
+
+        Rot.mulToOutUnsafe(xfA.q, manifold.localNormal, normal);
+        Transform.mulToOut(xfA, manifold.localPoint, planePoint);
+
+        final Vec2 clipPoint = pool4;
+
+        for (int i = 0; i < manifold.pointCount; i++) {
+          // b2Vec2 clipPoint = b2Mul(xfB, manifold->points[i].localPoint);
+          // b2Vec2 cA = clipPoint + (radiusA - b2Dot(clipPoint - planePoint,
+          // normal)) * normal;
+          // b2Vec2 cB = clipPoint - radiusB * normal;
+          // points[i] = 0.5f * (cA + cB);
+          Transform.mulToOut(xfB, manifold.points[i].localPoint, clipPoint);
+          // use cA as temporary for now
+          // cA.set(clipPoint).subLocal(planePoint);
+          // float scalar = radiusA - Vec2.dot(cA, normal);
+          // cA.set(normal).mulLocal(scalar).addLocal(clipPoint);
+          // cB.set(normal).mulLocal(radiusB).subLocal(clipPoint).negateLocal();
+          // points[i].set(cA).addLocal(cB).mulLocal(0.5f);
+
+          final float scalar =
+              radiusA
+                  - ((clipPoint.x - planePoint.x) * normal.x + (clipPoint.y - planePoint.y)
+                      * normal.y);
+
+          final float cAx = normal.x * scalar + clipPoint.x;
+          final float cAy = normal.y * scalar + clipPoint.y;
+
+          final float cBx = -normal.x * radiusB + clipPoint.x;
+          final float cBy = -normal.y * radiusB + clipPoint.y;
+
+          points[i].x = (cAx + cBx) * .5f;
+          points[i].y = (cAy + cBy) * .5f;
+          separations[i] = (cBx - cAx) * normal.x + (cBy - cAy) * normal.y;
+        }
+      }
+        break;
+      case FACE_B:
+        final Vec2 planePoint = pool3;
+        Rot.mulToOutUnsafe(xfB.q, manifold.localNormal, normal);
+        Transform.mulToOut(xfB, manifold.localPoint, planePoint);
+
+        // final Mat22 R = xfB.q;
+        // normal.x = R.ex.x * manifold.localNormal.x + R.ey.x * manifold.localNormal.y;
+        // normal.y = R.ex.y * manifold.localNormal.x + R.ey.y * manifold.localNormal.y;
+        // final Vec2 v = manifold.localPoint;
+        // planePoint.x = xfB.p.x + xfB.q.ex.x * v.x + xfB.q.ey.x * v.y;
+        // planePoint.y = xfB.p.y + xfB.q.ex.y * v.x + xfB.q.ey.y * v.y;
+
+        final Vec2 clipPoint = pool4;
+
+        for (int i = 0; i < manifold.pointCount; i++) {
+          // b2Vec2 clipPoint = b2Mul(xfA, manifold->points[i].localPoint);
+          // b2Vec2 cB = clipPoint + (radiusB - b2Dot(clipPoint - planePoint,
+          // normal)) * normal;
+          // b2Vec2 cA = clipPoint - radiusA * normal;
+          // points[i] = 0.5f * (cA + cB);
+
+          Transform.mulToOut(xfA, manifold.points[i].localPoint, clipPoint);
+          // cB.set(clipPoint).subLocal(planePoint);
+          // float scalar = radiusB - Vec2.dot(cB, normal);
+          // cB.set(normal).mulLocal(scalar).addLocal(clipPoint);
+          // cA.set(normal).mulLocal(radiusA).subLocal(clipPoint).negateLocal();
+          // points[i].set(cA).addLocal(cB).mulLocal(0.5f);
+
+          // points[i] = 0.5f * (cA + cB);
+
+          //
+          // clipPoint.x = xfA.p.x + xfA.q.ex.x * manifold.points[i].localPoint.x + xfA.q.ey.x *
+          // manifold.points[i].localPoint.y;
+          // clipPoint.y = xfA.p.y + xfA.q.ex.y * manifold.points[i].localPoint.x + xfA.q.ey.y *
+          // manifold.points[i].localPoint.y;
+
+          final float scalar =
+              radiusB
+                  - ((clipPoint.x - planePoint.x) * normal.x + (clipPoint.y - planePoint.y)
+                      * normal.y);
+
+          final float cBx = normal.x * scalar + clipPoint.x;
+          final float cBy = normal.y * scalar + clipPoint.y;
+
+          final float cAx = -normal.x * radiusA + clipPoint.x;
+          final float cAy = -normal.y * radiusA + clipPoint.y;
+
+          points[i].x = (cAx + cBx) * .5f;
+          points[i].y = (cAy + cBy) * .5f;
+          separations[i] = (cAx - cBx) * normal.x + (cAy - cBy) * normal.y;
+        }
+        // Ensure normal points from A to B.
+        normal.x = -normal.x;
+        normal.y = -normal.y;
+        break;
+    }
+  }
+}

data/src/org/jbox2d/collision/broadphase/BroadPhase.java

@@ -0,0 +1,92 @@
+package org.jbox2d.collision.broadphase;
+
+import org.jbox2d.callbacks.DebugDraw;
+import org.jbox2d.callbacks.PairCallback;
+import org.jbox2d.callbacks.TreeCallback;
+import org.jbox2d.callbacks.TreeRayCastCallback;
+import org.jbox2d.collision.AABB;
+import org.jbox2d.collision.RayCastInput;
+import org.jbox2d.common.Vec2;
+
+
+public interface BroadPhase {
+
+  public static final int NULL_PROXY = -1;
+
+  /**
+   * Create a proxy with an initial AABB. Pairs are not reported until updatePairs is called.
+   * 
+   * @param aabb
+   * @param userData
+   * @return
+   */
+  int createProxy(AABB aabb, Object userData);
+
+  /**
+   * Destroy a proxy. It is up to the client to remove any pairs.
+   * 
+   * @param proxyId
+   */
+  void destroyProxy(int proxyId);
+
+  /**
+   * Call MoveProxy as many times as you like, then when you are done call UpdatePairs to finalized
+   * the proxy pairs (for your time step).
+   */
+  void moveProxy(int proxyId, AABB aabb, Vec2 displacement);
+
+  void touchProxy(int proxyId);
+
+  Object getUserData(int proxyId);
+
+  AABB getFatAABB(int proxyId);
+
+  boolean testOverlap(int proxyIdA, int proxyIdB);
+
+  /**
+   * Get the number of proxies.
+   * 
+   * @return
+   */
+  int getProxyCount();
+
+  void drawTree(DebugDraw argDraw);
+
+  /**
+   * Update the pairs. This results in pair callbacks. This can only add pairs.
+   * 
+   * @param callback
+   */
+  void updatePairs(PairCallback callback);
+
+  /**
+   * Query an AABB for overlapping proxies. The callback class is called for each proxy that
+   * overlaps the supplied AABB.
+   * 
+   * @param callback
+   * @param aabb
+   */
+  void query(TreeCallback callback, AABB aabb);
+
+  /**
+   * Ray-cast against the proxies in the tree. This relies on the callback to perform a exact
+   * ray-cast in the case were the proxy contains a shape. The callback also performs the any
+   * collision filtering. This has performance roughly equal to k * log(n), where k is the number of
+   * collisions and n is the number of proxies in the tree.
+   * 
+   * @param input the ray-cast input data. The ray extends from p1 to p1 + maxFraction * (p2 - p1).
+   * @param callback a callback class that is called for each proxy that is hit by the ray.
+   */
+  void raycast(TreeRayCastCallback callback, RayCastInput input);
+
+  /**
+   * Get the height of the embedded tree.
+   * 
+   * @return
+   */
+  int getTreeHeight();
+
+  int getTreeBalance();
+
+  float getTreeQuality();
+}

data/src/org/jbox2d/collision/broadphase/BroadPhaseStrategy.java

@@ -0,0 +1,88 @@
+package org.jbox2d.collision.broadphase;
+
+import org.jbox2d.callbacks.DebugDraw;
+import org.jbox2d.callbacks.TreeCallback;
+import org.jbox2d.callbacks.TreeRayCastCallback;
+import org.jbox2d.collision.AABB;
+import org.jbox2d.collision.RayCastInput;
+import org.jbox2d.common.Vec2;
+
+public interface BroadPhaseStrategy {
+
+  /**
+   * Create a proxy. Provide a tight fitting AABB and a userData pointer.
+   * 
+   * @param aabb
+   * @param userData
+   * @return
+   */
+  int createProxy(AABB aabb, Object userData);
+
+  /**
+   * Destroy a proxy
+   * 
+   * @param proxyId
+   */
+  void destroyProxy(int proxyId);
+
+  /**
+   * Move a proxy with a swepted AABB. If the proxy has moved outside of its fattened AABB, then the
+   * proxy is removed from the tree and re-inserted. Otherwise the function returns immediately.
+   * 
+   * @return true if the proxy was re-inserted.
+   */
+  boolean moveProxy(int proxyId, AABB aabb, Vec2 displacement);
+  
+  Object getUserData(int proxyId);
+
+  AABB getFatAABB(int proxyId);
+
+  /**
+   * Query an AABB for overlapping proxies. The callback class is called for each proxy that
+   * overlaps the supplied AABB.
+   * 
+   * @param callback
+   * @param araabbgAABB
+   */
+  void query(TreeCallback callback, AABB aabb);
+
+  /**
+   * Ray-cast against the proxies in the tree. This relies on the callback to perform a exact
+   * ray-cast in the case were the proxy contains a shape. The callback also performs the any
+   * collision filtering. This has performance roughly equal to k * log(n), where k is the number of
+   * collisions and n is the number of proxies in the tree.
+   * 
+   * @param input the ray-cast input data. The ray extends from p1 to p1 + maxFraction * (p2 - p1).
+   * @param callback a callback class that is called for each proxy that is hit by the ray.
+   */
+  void raycast(TreeRayCastCallback callback, RayCastInput input);
+
+  /**
+   * Compute the height of the tree.
+   */
+  int computeHeight();
+
+  /**
+   * Compute the height of the binary tree in O(N) time. Should not be called often.
+   * 
+   * @return
+   */
+  int getHeight();
+
+  /**
+   * Get the maximum balance of an node in the tree. The balance is the difference in height of the
+   * two children of a node.
+   * 
+   * @return
+   */
+  int getMaxBalance();
+
+  /**
+   * Get the ratio of the sum of the node areas to the root area.
+   * 
+   * @return
+   */
+  float getAreaRatio();
+
+  void drawTree(DebugDraw draw);
+}

data/src/org/jbox2d/collision/broadphase/DefaultBroadPhaseBuffer.java

@@ -0,0 +1,268 @@
+/*******************************************************************************
+ * 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.broadphase;
+
+import java.util.Arrays;
+
+import org.jbox2d.callbacks.DebugDraw;
+import org.jbox2d.callbacks.PairCallback;
+import org.jbox2d.callbacks.TreeCallback;
+import org.jbox2d.callbacks.TreeRayCastCallback;
+import org.jbox2d.collision.AABB;
+import org.jbox2d.collision.RayCastInput;
+import org.jbox2d.common.Vec2;
+
+/**
+ * The broad-phase is used for computing pairs and performing volume queries and ray casts. This
+ * broad-phase does not persist pairs. Instead, this reports potentially new pairs. It is up to the
+ * client to consume the new pairs and to track subsequent overlap.
+ * 
+ * @author Daniel Murphy
+ */
+public class DefaultBroadPhaseBuffer implements TreeCallback, BroadPhase {
+
+  private final BroadPhaseStrategy m_tree;
+
+  private int m_proxyCount;
+
+  private int[] m_moveBuffer;
+  private int m_moveCapacity;
+  private int m_moveCount;
+
+  private Pair[] m_pairBuffer;
+  private int m_pairCapacity;
+  private int m_pairCount;
+
+  private int m_queryProxyId;
+
+  public DefaultBroadPhaseBuffer(BroadPhaseStrategy strategy) {
+    m_proxyCount = 0;
+
+    m_pairCapacity = 16;
+    m_pairCount = 0;
+    m_pairBuffer = new Pair[m_pairCapacity];
+    for (int i = 0; i < m_pairCapacity; i++) {
+      m_pairBuffer[i] = new Pair();
+    }
+
+    m_moveCapacity = 16;
+    m_moveCount = 0;
+    m_moveBuffer = new int[m_moveCapacity];
+
+    m_tree = strategy;
+    m_queryProxyId = NULL_PROXY;
+  }
+
+  @Override
+  public final int createProxy(final AABB aabb, Object userData) {
+    int proxyId = m_tree.createProxy(aabb, userData);
+    ++m_proxyCount;
+    bufferMove(proxyId);
+    return proxyId;
+  }
+
+  @Override
+  public final void destroyProxy(int proxyId) {
+    unbufferMove(proxyId);
+    --m_proxyCount;
+    m_tree.destroyProxy(proxyId);
+  }
+
+  @Override
+  public final void moveProxy(int proxyId, final AABB aabb, final Vec2 displacement) {
+    boolean buffer = m_tree.moveProxy(proxyId, aabb, displacement);
+    if (buffer) {
+      bufferMove(proxyId);
+    }
+  }
+
+  @Override
+  public void touchProxy(int proxyId) {
+    bufferMove(proxyId);
+  }
+
+  @Override
+  public Object getUserData(int proxyId) {
+    return m_tree.getUserData(proxyId);
+  }
+
+  @Override
+  public AABB getFatAABB(int proxyId) {
+    return m_tree.getFatAABB(proxyId);
+  }
+
+  @Override
+  public boolean testOverlap(int proxyIdA, int proxyIdB) {
+    // return AABB.testOverlap(proxyA.aabb, proxyB.aabb);
+    // return m_tree.overlap(proxyIdA, proxyIdB);
+    final AABB a = m_tree.getFatAABB(proxyIdA);
+    final AABB b = m_tree.getFatAABB(proxyIdB);
+    if (b.lowerBound.x - a.upperBound.x > 0.0f || b.lowerBound.y - a.upperBound.y > 0.0f) {
+      return false;
+    }
+
+    if (a.lowerBound.x - b.upperBound.x > 0.0f || a.lowerBound.y - b.upperBound.y > 0.0f) {
+      return false;
+    }
+
+    return true;
+  }
+
+  @Override
+  public final int getProxyCount() {
+    return m_proxyCount;
+  }
+
+  @Override
+  public void drawTree(DebugDraw argDraw) {
+    m_tree.drawTree(argDraw);
+  }
+
+  @Override
+  public final void updatePairs(PairCallback callback) {
+    // Reset pair buffer
+    m_pairCount = 0;
+
+    // Perform tree queries for all moving proxies.
+    for (int i = 0; i < m_moveCount; ++i) {
+      m_queryProxyId = m_moveBuffer[i];
+      if (m_queryProxyId == NULL_PROXY) {
+        continue;
+      }
+
+      // We have to query the tree with the fat AABB so that
+      // we don't fail to create a pair that may touch later.
+      final AABB fatAABB = m_tree.getFatAABB(m_queryProxyId);
+
+      // Query tree, create pairs and add them pair buffer.
+      // log.debug("quering aabb: "+m_queryProxy.aabb);
+      m_tree.query(this, fatAABB);
+    }
+    // log.debug("Number of pairs found: "+m_pairCount);
+
+    // Reset move buffer
+    m_moveCount = 0;
+
+    // Sort the pair buffer to expose duplicates.
+    Arrays.sort(m_pairBuffer, 0, m_pairCount);
+
+    // Send the pairs back to the client.
+    int i = 0;
+    while (i < m_pairCount) {
+      Pair primaryPair = m_pairBuffer[i];
+      Object userDataA = m_tree.getUserData(primaryPair.proxyIdA);
+      Object userDataB = m_tree.getUserData(primaryPair.proxyIdB);
+
+      // log.debug("returning pair: "+userDataA+", "+userDataB);
+      callback.addPair(userDataA, userDataB);
+      ++i;
+
+      // Skip any duplicate pairs.
+      while (i < m_pairCount) {
+        Pair pair = m_pairBuffer[i];
+        if (pair.proxyIdA != primaryPair.proxyIdA || pair.proxyIdB != primaryPair.proxyIdB) {
+          break;
+        }
+        ++i;
+      }
+    }
+  }
+
+  @Override
+  public final void query(final TreeCallback callback, final AABB aabb) {
+    m_tree.query(callback, aabb);
+  }
+
+  @Override
+  public final void raycast(final TreeRayCastCallback callback, final RayCastInput input) {
+    m_tree.raycast(callback, input);
+  }
+
+  @Override
+  public final int getTreeHeight() {
+    return m_tree.getHeight();
+  }
+
+  @Override
+  public int getTreeBalance() {
+    return m_tree.getMaxBalance();
+  }
+
+  @Override
+  public float getTreeQuality() {
+    return m_tree.getAreaRatio();
+  }
+
+  protected final void bufferMove(int proxyId) {
+    if (m_moveCount == m_moveCapacity) {
+      int[] old = m_moveBuffer;
+      m_moveCapacity *= 2;
+      m_moveBuffer = new int[m_moveCapacity];
+      System.arraycopy(old, 0, m_moveBuffer, 0, old.length);
+    }
+
+    m_moveBuffer[m_moveCount] = proxyId;
+    ++m_moveCount;
+  }
+
+  protected final void unbufferMove(int proxyId) {
+    for (int i = 0; i < m_moveCount; i++) {
+      if (m_moveBuffer[i] == proxyId) {
+        m_moveBuffer[i] = NULL_PROXY;
+      }
+    }
+  }
+
+  /**
+   * This is called from DynamicTree::query when we are gathering pairs.
+   */
+  public final boolean treeCallback(int proxyId) {
+    // A proxy cannot form a pair with itself.
+    if (proxyId == m_queryProxyId) {
+      return true;
+    }
+
+    // Grow the pair buffer as needed.
+    if (m_pairCount == m_pairCapacity) {
+      Pair[] oldBuffer = m_pairBuffer;
+      m_pairCapacity *= 2;
+      m_pairBuffer = new Pair[m_pairCapacity];
+      System.arraycopy(oldBuffer, 0, m_pairBuffer, 0, oldBuffer.length);
+      for (int i = oldBuffer.length; i < m_pairCapacity; i++) {
+        m_pairBuffer[i] = new Pair();
+      }
+    }
+
+    if (proxyId < m_queryProxyId) {
+      m_pairBuffer[m_pairCount].proxyIdA = proxyId;
+      m_pairBuffer[m_pairCount].proxyIdB = m_queryProxyId;
+    } else {
+      m_pairBuffer[m_pairCount].proxyIdA = m_queryProxyId;
+      m_pairBuffer[m_pairCount].proxyIdB = proxyId;
+    }
+
+    ++m_pairCount;
+    return true;
+  }
+}