public void destroyProxy(int proxyId) {
assert (0 < m_proxyCount && m_proxyCount <= Settings.maxProxies);
Proxy proxy = m_proxyPool[proxyId];
assert (proxy.isValid());
int boundCount = 2 * m_proxyCount;
for (int axis = 0; axis < 2; ++axis) {
Bound[] bounds = m_bounds[axis];
int lowerIndex = proxy.lowerBounds[axis];
int upperIndex = proxy.upperBounds[axis];
int lowerValue = bounds[lowerIndex].value;
int upperValue = bounds[upperIndex].value;
// memmove(bounds + lowerIndex, bounds + lowerIndex + 1,
// (upperIndex - lowerIndex - 1) * sizeof(b2Bound));
// memmove(bounds[lowerIndex + 1], bounds[lowerIndex],
// (upperIndex - lowerIndex) * sizeof(b2Bound));
System.arraycopy(
m_bounds[axis], lowerIndex + 1, m_bounds[axis], lowerIndex, upperIndex - lowerIndex - 1);
for (int i = 0; i < upperIndex - lowerIndex - 1; i++) {
m_bounds[axis][lowerIndex + i] = new Bound(m_bounds[axis][lowerIndex + i]);
}
// memmove(bounds + upperIndex-1, bounds + upperIndex + 1,
// (edgeCount - upperIndex - 1) * sizeof(b2Bound));
System.arraycopy(
m_bounds[axis],
upperIndex + 1,
m_bounds[axis],
upperIndex - 1,
boundCount - upperIndex - 1);
for (int i = 0; i < boundCount - upperIndex - 1; i++) {
m_bounds[axis][upperIndex - 1 + i] = new Bound(m_bounds[axis][upperIndex - 1 + i]);
}
// Fix bound indices.
for (int index = lowerIndex; index < boundCount - 2; ++index) {
Proxy proxyn = m_proxyPool[bounds[index].proxyId];
if (bounds[index].isLower()) {
proxyn.lowerBounds[axis] = index;
} else {
proxyn.upperBounds[axis] = index;
}
}
// Fix stabbing count.
for (int index = lowerIndex; index < upperIndex - 1; ++index) {
--bounds[index].stabbingCount;
}
// Query for pairs to be removed. lowerIndex and upperIndex are not
// needed.
int[] ignored = new int[2];
query(ignored, lowerValue, upperValue, bounds, boundCount - 2, axis);
}
assert (m_queryResultCount < Settings.maxProxies);
for (int i = 0; i < m_queryResultCount; ++i) {
assert (m_proxyPool[m_queryResults[i]].isValid());
m_pairManager.removeBufferedPair(proxyId, m_queryResults[i]);
}
m_pairManager.commit();
// Prepare for next query.
m_queryResultCount = 0;
incrementTimeStamp();
// Return the proxy to the pool.
proxy.userData = null;
proxy.overlapCount = BroadPhase.INVALID;
proxy.lowerBounds[0] = BroadPhase.INVALID;
proxy.lowerBounds[1] = BroadPhase.INVALID;
proxy.upperBounds[0] = BroadPhase.INVALID;
proxy.upperBounds[1] = BroadPhase.INVALID;
// Return the proxy to the pool.
proxy.setNext(m_freeProxy);
m_freeProxy = proxyId;
--m_proxyCount;
if (s_validate) {
validate();
}
}
public void commit() {
m_pairManager.commit();
}
// Create and destroy proxies. These call Flush first.
int createProxy(
AABB aabb, // int groupIndex, int categoryBits, int maskBits,
Object userData) {
if (debugPrint) {
System.out.println("CreateProxy()");
}
assert (m_proxyCount < Settings.maxProxies);
assert (m_freeProxy != PairManager.NULL_PROXY);
int proxyId = m_freeProxy;
Proxy proxy = m_proxyPool[proxyId];
m_freeProxy = proxy.getNext();
proxy.overlapCount = 0;
proxy.userData = userData;
// proxy.groupIndex = groupIndex;
// proxy.categoryBits = categoryBits;
// proxy.maskBits = maskBits;
// assert m_proxyCount < Settings.maxProxies;
int boundCount = 2 * m_proxyCount;
int lowerValues[] = new int[2];
int upperValues[] = new int[2];
computeBounds(lowerValues, upperValues, aabb);
for (int axis = 0; axis < 2; ++axis) {
Bound[] bounds = m_bounds[axis];
int[] indexes = new int[2];
query(indexes, lowerValues[axis], upperValues[axis], bounds, boundCount, axis);
int lowerIndex = indexes[0];
int upperIndex = indexes[1];
// System.out.println(edgeCount + ", "+lowerValues[axis] + ",
// "+upperValues[axis]);
// memmove(bounds[upperIndex + 2], bounds[upperIndex],
// (edgeCount - upperIndex) * sizeof(b2Bound));
System.arraycopy(
m_bounds[axis], upperIndex, m_bounds[axis], upperIndex + 2, boundCount - upperIndex);
for (int i = 0; i < boundCount - upperIndex; i++) {
m_bounds[axis][upperIndex + 2 + i] = new Bound(m_bounds[axis][upperIndex + 2 + i]);
}
// memmove(bounds[lowerIndex + 1], bounds[lowerIndex],
// (upperIndex - lowerIndex) * sizeof(b2Bound));
// System.out.println(lowerIndex+" "+upperIndex);
System.arraycopy(
m_bounds[axis], lowerIndex, m_bounds[axis], lowerIndex + 1, upperIndex - lowerIndex);
for (int i = 0; i < upperIndex - lowerIndex; i++) {
m_bounds[axis][lowerIndex + 1 + i] = new Bound(m_bounds[axis][lowerIndex + 1 + i]);
}
// The upper index has increased because of the lower bound
// insertion.
++upperIndex;
// Copy in the new bounds.
// if (bounds[lowerIndex] == null)
assert (bounds[lowerIndex] != null) : "Null pointer (lower)";
// if (bounds[upperIndex] == null)
assert (bounds[upperIndex] != null) : "Null pointer (upper)";
bounds[lowerIndex].value = lowerValues[axis];
bounds[lowerIndex].proxyId = proxyId;
bounds[upperIndex].value = upperValues[axis];
bounds[upperIndex].proxyId = proxyId;
bounds[lowerIndex].stabbingCount = lowerIndex == 0 ? 0 : bounds[lowerIndex - 1].stabbingCount;
bounds[upperIndex].stabbingCount = bounds[upperIndex - 1].stabbingCount;
// System.out.printf("lv: %d , lid: %d, uv: %d, uid: %d
// \n",lowerValues[axis],proxyId,upperValues[axis],proxyId);
// Adjust the stabbing count between the new bounds.
for (int index = lowerIndex; index < upperIndex; ++index) {
++bounds[index].stabbingCount;
}
// Adjust the all the affected bound indices.
for (int index = lowerIndex; index < boundCount + 2; ++index) {
Proxy proxyn = m_proxyPool[bounds[index].proxyId];
if (bounds[index].isLower()) {
proxyn.lowerBounds[axis] = index;
} else {
proxyn.upperBounds[axis] = index;
}
}
}
++m_proxyCount;
assert m_queryResultCount < Settings.maxProxies;
// Create pairs if the AABB is in range.
for (int i = 0; i < m_queryResultCount; ++i) {
assert (m_queryResults[i] < Settings.maxProxies);
assert (m_proxyPool[m_queryResults[i]].isValid());
m_pairManager.addBufferedPair(proxyId, m_queryResults[i]);
}
m_pairManager.commit();
if (s_validate) {
validate();
}
// Prepare for next query.
m_queryResultCount = 0;
incrementTimeStamp();
return proxyId;
}