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);
}
// Call MoveProxy as many times as you like, then when you are done
// call Commit to finalized the proxy pairs (for your time step).
public void MoveProxy(object proxy_, b2AABB aabb, b2Vec2 displacement)
{
b2Proxy proxy = proxy_ as b2Proxy;
List <uint> as3arr;
int as3int;
int axis;
uint index;
b2Bound bound;
b2Bound prevBound;
b2Bound nextBound;
uint nextProxyId;
b2Proxy nextProxy;
if (proxy == null)
{
//b2Settings.b2Assert(false);
return;
}
if (aabb.IsValid() == false)
{
//b2Settings.b2Assert(false);
return;
}
uint boundCount = (uint)(2 * m_proxyCount);
// Get new bound values
b2BoundValues newValues = new b2BoundValues();
ComputeBounds(newValues.lowerValues, newValues.upperValues, aabb);
// Get old bound values
b2BoundValues oldValues = new b2BoundValues();
for (axis = 0; axis < 2; ++axis)
{
bound = m_bounds[axis][(int)proxy.lowerBounds[axis]];
oldValues.lowerValues[axis] = bound.value;
bound = m_bounds[axis][(int)proxy.upperBounds[axis]];
oldValues.upperValues[axis] = bound.value;
}
for (axis = 0; axis < 2; ++axis)
{
List <b2Bound> bounds = m_bounds[axis];
uint lowerIndex = proxy.lowerBounds[axis];
uint upperIndex = proxy.upperBounds[axis];
uint lowerValue = (uint)newValues.lowerValues[axis];
uint upperValue = (uint)newValues.upperValues[axis];
bound = bounds[(int)lowerIndex];
int deltaLower = (int)(lowerValue - bound.value);
bound.value = lowerValue;
bound = bounds[(int)upperIndex];
int deltaUpper = (int)(upperValue - bound.value);
bound.value = upperValue;
//
// Expanding adds overlaps
//
// Should we move the lower bound down?
if (deltaLower < 0)
{
index = lowerIndex;
while (index > 0 && lowerValue < (bounds[(int)(index - 1)] as b2Bound).value)
{
bound = bounds[(int)index];
prevBound = bounds[(int)(index - 1)];
b2Proxy prevProxy = prevBound.proxy;
prevBound.stabbingCount++;
if (prevBound.IsUpper() == true)
{
if (TestOverlapBound(newValues, prevProxy))
{
m_pairManager.AddBufferedPair(proxy, prevProxy);
}
//prevProxy.upperBounds[axis]++;
as3arr = prevProxy.upperBounds;
as3int = (int)as3arr[axis];
as3int++;
as3arr[axis] = (uint)as3int;
bound.stabbingCount++;
}
else
{
//prevProxy.lowerBounds[axis]++;
as3arr = prevProxy.lowerBounds;
as3int = (int)as3arr[axis];
as3int++;
as3arr[axis] = (uint)as3int;
bound.stabbingCount--;
}
//proxy.lowerBounds[axis]--;
as3arr = proxy.lowerBounds;
as3int = (int)as3arr[axis];
as3int--;
as3arr[axis] = (uint)as3int;
// swap
//var temp:b2Bound = bound;
//bound = prevEdge;
//prevEdge = temp;
bound.Swap(prevBound);
//b2Math.Swap(bound, prevEdge);
--index;
}
}
// Should we move the upper bound up?
if (deltaUpper > 0)
{
index = upperIndex;
while (index < boundCount - 1 && (bounds[(int)(index + 1)] as b2Bound).value <= upperValue)
{
bound = bounds[(int)index];
nextBound = bounds[(int)(index + 1)];
nextProxy = nextBound.proxy;
nextBound.stabbingCount++;
if (nextBound.IsLower() == true)
{
if (TestOverlapBound(newValues, nextProxy))
{
m_pairManager.AddBufferedPair(proxy, nextProxy);
}
//nextProxy.lowerBounds[axis]--;
as3arr = nextProxy.lowerBounds;
as3int = (int)as3arr[axis];
as3int--;
as3arr[axis] = (uint)as3int;
bound.stabbingCount++;
}
else
{
//nextProxy.upperBounds[axis]--;
as3arr = nextProxy.upperBounds;
as3int = (int)as3arr[axis];
as3int--;
as3arr[axis] = (uint)as3int;
bound.stabbingCount--;
}
//proxy.upperBounds[axis]++;
as3arr = proxy.upperBounds;
as3int = (int)as3arr[axis];
as3int++;
as3arr[axis] = (uint)as3int;
// swap
//var temp:b2Bound = bound;
//bound = nextEdge;
//nextEdge = temp;
bound.Swap(nextBound);
//b2Math.Swap(bound, nextEdge);
index++;
}
}
//
// Shrinking removes overlaps
//
// Should we move the lower bound up?
if (deltaLower > 0)
{
index = lowerIndex;
while (index < boundCount - 1 && (bounds[(int)(index + 1)] as b2Bound).value <= lowerValue)
{
bound = bounds[(int)index];
nextBound = bounds[(int)(index + 1)];
nextProxy = nextBound.proxy;
nextBound.stabbingCount--;
if (nextBound.IsUpper())
{
if (TestOverlapBound(oldValues, nextProxy))
{
m_pairManager.RemoveBufferedPair(proxy, nextProxy);
}
//nextProxy.upperBounds[axis]--;
as3arr = nextProxy.upperBounds;
as3int = (int)as3arr[axis];
as3int--;
as3arr[axis] = (uint)as3int;
bound.stabbingCount--;
}
else
{
//nextProxy.lowerBounds[axis]--;
as3arr = nextProxy.lowerBounds;
as3int = (int)as3arr[axis];
as3int--;
as3arr[axis] = (uint)as3int;
bound.stabbingCount++;
}
//proxy.lowerBounds[axis]++;
as3arr = proxy.lowerBounds;
as3int = (int)as3arr[axis];
as3int++;
as3arr[axis] = (uint)as3int;
// swap
//var temp:b2Bound = bound;
//bound = nextEdge;
//nextEdge = temp;
bound.Swap(nextBound);
//b2Math.Swap(bound, nextEdge);
index++;
}
}
// Should we move the upper bound down?
if (deltaUpper < 0)
{
index = upperIndex;
while (index > 0 && upperValue < (bounds[(int)(index - 1)] as b2Bound).value)
{
bound = bounds[(int)index];
prevBound = bounds[(int)(index - 1)];
b2Proxy prevProxy = prevBound.proxy;
prevBound.stabbingCount--;
if (prevBound.IsLower() == true)
{
if (TestOverlapBound(oldValues, prevProxy))
{
m_pairManager.RemoveBufferedPair(proxy, prevProxy);
}
//prevProxy.lowerBounds[axis]++;
as3arr = prevProxy.lowerBounds;
as3int = (int)as3arr[axis];
as3int++;
as3arr[axis] = (uint)as3int;
bound.stabbingCount--;
}
else
{
//prevProxy.upperBounds[axis]++;
as3arr = prevProxy.upperBounds;
as3int = (int)as3arr[axis];
as3int++;
as3arr[axis] = (uint)as3int;
bound.stabbingCount++;
}
//proxy.upperBounds[axis]--;
as3arr = proxy.upperBounds;
as3int = (int)as3arr[axis];
as3int--;
as3arr[axis] = (uint)as3int;
// swap
//var temp:b2Bound = bound;
//bound = prevEdge;
//prevEdge = temp;
bound.Swap(prevBound);
//b2Math.Swap(bound, prevEdge);
index--;
}
}
}
}