static public uint BinarySearch(List <b2Bound> bounds, int count, uint value)
{
int low = 0;
int high = count - 1;
while (low <= high)
{
int mid = ((low + high) / 2);
b2Bound bound = bounds[mid];
if (bound.value > value)
{
high = mid - 1;
}
else if (bound.value < value)
{
low = mid + 1;
}
else
{
return((uint)(mid));
}
}
return((uint)(low));
}
// This one is only used for validation.
private bool TestOverlapValidate(b2Proxy p1, b2Proxy p2)
{
for (int axis = 0; axis < 2; ++axis)
{
List <b2Bound> bounds = m_bounds[axis];
//b2Settings.b2Assert(p1.lowerBounds[axis] < 2 * m_proxyCount);
//b2Settings.b2Assert(p1.upperBounds[axis] < 2 * m_proxyCount);
//b2Settings.b2Assert(p2.lowerBounds[axis] < 2 * m_proxyCount);
//b2Settings.b2Assert(p2.upperBounds[axis] < 2 * m_proxyCount);
b2Bound bound1 = bounds[(int)p1.lowerBounds[axis]];
b2Bound bound2 = bounds[(int)p2.upperBounds[axis]];
if (bound1.value > bound2.value)
{
return(false);
}
bound1 = bounds[(int)p1.upperBounds[axis]];
bound2 = bounds[(int)p2.lowerBounds[axis]];
if (bound1.value < bound2.value)
{
return(false);
}
}
return(true);
}
public void Validate()
{
b2Pair pair;
b2Proxy proxy1;
b2Proxy proxy2;
bool overlap;
for (int axis = 0; axis < 2; ++axis)
{
List <b2Bound> bounds = m_bounds[axis];
uint boundCount = (uint)(2 * m_proxyCount);
uint stabbingCount = 0;
for (uint i = 0; i < boundCount; ++i)
{
b2Bound bound = bounds[(int)i];
//b2Settings.b2Assert(i == 0 || bounds[i-1].value <= bound->value);
//b2Settings.b2Assert(bound->proxyId != b2_nullProxy);
//b2Settings.b2Assert(m_proxyPool[bound->proxyId].IsValid());
if (bound.IsLower() == true)
{
//b2Settings.b2Assert(m_proxyPool[bound.proxyId].lowerBounds[axis] == i);
stabbingCount++;
}
else
{
//b2Settings.b2Assert(m_proxyPool[bound.proxyId].upperBounds[axis] == i);
stabbingCount--;
}
//b2Settings.b2Assert(bound.stabbingCount == stabbingCount);
}
}
}
public bool TestOverlapBound(b2BoundValues b, b2Proxy p)
{
for (int axis = 0; axis < 2; ++axis)
{
List <b2Bound> bounds = m_bounds[axis];
//b2Settings.b2Assert(p.lowerBounds[axis] < 2 * m_proxyCount);
//b2Settings.b2Assert(p.upperBounds[axis] < 2 * m_proxyCount);
b2Bound bound = bounds[(int)p.upperBounds[axis]];
if (b.lowerValues[axis] > bound.value)
{
return(false);
}
bound = bounds[(int)p.lowerBounds[axis]];
if (b.upperValues[axis] < bound.value)
{
return(false);
}
}
return(true);
}
// Create and destroy proxies. These call Flush first.
public object CreateProxy(b2AABB aabb, object userData)
{
uint index;
b2Proxy proxy;
int i;
int j;
//b2Settings.b2Assert(m_proxyCount < b2_maxProxies);
//b2Settings.b2Assert(m_freeProxy != b2Pair.b2_nullProxy);
if (m_freeProxy == null)
{
// As all proxies are allocated, m_proxyCount == m_proxyPool.length
m_freeProxy = m_proxyPool[m_proxyCount] = new b2Proxy();
m_freeProxy.next = null;
m_freeProxy.timeStamp = 0;
m_freeProxy.overlapCount = b2_invalid;
m_freeProxy.userData = null;
for (i = 0; i < 2; i++)
{
j = m_proxyCount * 2;
m_bounds[i][j++] = new b2Bound();
m_bounds[i][j] = new b2Bound();
}
}
proxy = m_freeProxy;
m_freeProxy = proxy.next;
proxy.overlapCount = 0;
proxy.userData = userData;
uint boundCount = (uint)(2 * m_proxyCount);
List <float> lowerValues = new List <float>();
List <float> upperValues = new List <float>();
ComputeBounds(lowerValues, upperValues, aabb);
for (int axis = 0; axis < 2; ++axis)
{
List <b2Bound> bounds = m_bounds[axis];
uint lowerIndex = 0;
uint upperIndex = 0;
List <uint> lowerIndexOut = new List <uint>();
lowerIndexOut.Add(lowerIndex);
List <uint> upperIndexOut = new List <uint>();
upperIndexOut.Add(upperIndex);
QueryAxis(lowerIndexOut, upperIndexOut, (uint)lowerValues[axis], (uint)upperValues[axis], bounds, boundCount, axis);
lowerIndex = lowerIndexOut[0];
upperIndex = upperIndexOut[0];
//bounds.splice(upperIndex, 0, bounds[bounds.length - 1]);
//bounds.length--;
//bounds.splice(lowerIndex, 0, bounds[bounds.length - 1]);
//bounds.length--;
bounds.Insert((int)upperIndex, bounds[bounds.Count - 1]);
bounds.RemoveAt(bounds.Count - 1);
bounds.Insert((int)lowerIndex, bounds[bounds.Count - 1]);
bounds.RemoveAt(bounds.Count - 1);
// The upper index has increased because of the lower bound insertion.
++upperIndex;
// Copy in the new bounds.
b2Bound tBound1 = bounds[(int)lowerIndex];
b2Bound tBound2 = bounds[(int)upperIndex];
tBound1.value = (uint)lowerValues[axis];
tBound1.proxy = proxy;
tBound2.value = (uint)upperValues[axis];
tBound2.proxy = proxy;
b2Bound tBoundAS3 = bounds[(int)(lowerIndex - 1)];
tBound1.stabbingCount = lowerIndex == 0 ? 0 : tBoundAS3.stabbingCount;
tBoundAS3 = bounds[(int)(upperIndex - 1)];
tBound2.stabbingCount = tBoundAS3.stabbingCount;
// Adjust the stabbing count between the new bounds.
for (index = lowerIndex; index < upperIndex; ++index)
{
tBoundAS3 = bounds[(int)index];
tBoundAS3.stabbingCount++;
}
// Adjust the all the affected bound indices.
for (index = lowerIndex; index < boundCount + 2; ++index)
{
tBound1 = bounds[(int)index];
b2Proxy proxy2 = tBound1.proxy;
if (tBound1.IsLower())
{
proxy2.lowerBounds[axis] = index;
}
else
{
proxy2.upperBounds[axis] = index;
}
}
}
++m_proxyCount;
//b2Settings.b2Assert(m_queryResultCount < b2Settings.b2_maxProxies);
for (i = 0; i < m_queryResultCount; ++i)
{
//b2Settings.b2Assert(m_queryResults[i] < b2_maxProxies);
//b2Settings.b2Assert(m_proxyPool[m_queryResults[i]].IsValid());
m_pairManager.AddBufferedPair(proxy, (b2Proxy)m_queryResults[i]);
}
// Prepare for next query.
m_queryResultCount = 0;
IncrementTimeStamp();
return(proxy);
}