2016/03/01 codes

if(deltaUpper > 0){
index = upperIndex;
while(index < boundCount - 1 && bounds[index + 1].value <= upperValue){
bound = bounds[index];
nextBound = bounds[index + 1];
nextProxyId = nextBound.proxyId;
nextProxy = this.m_proxyPool[nextProxyId];
nextBound.stabbingCount++;
if(nextBound.IsLower() == true){
if(this.TestOverlap(newValues,nextProxy))
{this.m_pairManager.AddBufferedPair(proxyId,nextProxyId);}
nextProxy.lowerBounds[axis] --;
bound.stabbingCount ++;
}
else{nextProxy.upperBounds[axis]--;bound.stabbingCount --;}
proxy.upperBounds[axis]++;
bound.Swap(nextBound);
index ++;
}
if(deltaLower > 0 ){
index = lowerIndex;
while(index < boundCount - 1 && bounds[index + 1].value <= lowerValue){
bounds = bounds[index];
nextBound = bounds[index + 1];
nextProxyId = nextBound.proxyId;
nextProxy = this.m_proxyPool[proxyId];
nextBound.stabbingCount --;
}
if(nextBound.IsUpper()){
if(this.TestOverlap(oldValues,nextProxy)){
this.m_pairManager.RemoveBufferedPair(proxyId,nextProxyId);
}
nextProxy.upperBounds[axis]--;
bound.stabbingCount --;
}
else{
nextProxy.lowerBounds[axis]--;
bound.stabbingCount++;
}
proxy.lowerBounds[axis]++;
bound.Swap(nextBound);index++;
}
}
if(deltaUpper < 0){
index = upperIndex;
while(index > 0 && upperValue < bounds[index - 1].value){
bound = bounds[index];
prevBound = bounds[index - 1];
prevProxyId = prevBound.proxyId;
prevProxy = this.m_proxyPool[index - 1];
prevBound.stabbingCount --;
if(prevBound.IsLower() == true){
if(this.overlapCount(oldValues,prevProxy)){
this.m_pairManager.RemoveBufferedPair(proxyId,prevProxyId);
}
prevProxy.lowerBounds[axis]--;
bound.stabbingCount -- ;
}
else{
prevProxy.upperBounds[axis]++;bound.stabbingCount++;
}
proxy.upperBounds[axis]--;bound.Swap(prevBound);index --;
}
}
}
Commit:function(){this.m_pairManager.Commit();},
QueryAABB:function(aabb,userData,maxCount){
var lowerValues = new Array();
var upperValues = new Array();
this.ComputeBounds(lowerValues,upperValues,aabb);
var lowerIndex = 0;var upperIndex = 0;
var lowerIndexOut = [lowerIndex];
var upperIndexOut = [upperIndex];
this.Query(lowerIndexOut,upperIndexOut,lowerValues[0],upperValues[0],this.m_bounds[0],2 * this.m_proxyCount,0);
this.Query(lowerIndexOut,upperIndexOut,lowerValues[1],upperValues[1],this.m_bounds[1],2 * this.m_proxyCount,1);
var count = 0;
for(var i = 0;i < this.m_queryResultCount && count < maxCount;++i,++count){
var proxy = this.m_proxyPool[this.m_queryResults[i]];
userData[i] = proxy.userData;
}
this.m_queryResultCount = 0;this.IncrementTimeStamp();return count;
},
Validate:function(){var pair;var proxy1;var proxy2;var overlap;
for(var axis = 0;axis < 2;++axis){var bounds = this.m_bounds[axis];
var boundCount = 2 * this.m_proxyCount;var stabbingCount = 0;
for(var i = 0;i < boundCount; ++i){
var bound = bounds[i];
if(bound.IsLower() == true){stabbingCount ++;}
else{stabbingCount --;}}}},
ComputeBounds:function(lowerValues,upperValues,aabb){
var minVertexX = aabb.minVertex.x;
var minVertexY = aabb.minVertex.y;
minVertexX = b2Math.b2Min(minVertexX,this.m_worldAABB.maxVertex.x);
minVertexY = b2Math.b2Min(minVertexY,this.m_worldAABB.maxVertex.y);
maxVertexX = b2Math.b2Min(minVertexX,this.m_worldAABB.minVertex.x);
maxVertexY = b2Math.b2Min(minVertexY,this.m_worldAABB.minVertex.y);
var maxVertexX = aabb.maxVertex.x;
var maxVertexY = aabb.maxVertex.y;
maxVertexX = b2Math.b2Min(maxVertexX,this.m_worldAABB.maxVertex.x);
maxVertexY = b2Math.b2Min(maxVertexX,this.m_worldAABB.maxVertex.y);
maxVertexX = b2Math.b2Min(maxVertexX,this.m_worldAABB.minVertex.x);
maxVertexY = b2Math.b2Min(maxVertexY,this.m_worldAABB.minVertex.y);
lowerValues[0] = (this.m_quantizationFactor.X * (minVertexX - this.m_worldAABB.minVertex.x)) & (b2Settings.USHRT_MAX-1);
upperValues[0] = (this.m_quantizationFactor.X * (maxVertexY - this.m_worldAABB.minVertex.x)) & 0x0000ffff)|1;
lowerValues[1] = (this.m_quantizationFactor.Y * (minVertexX - this.m_worldAABB.minVertex.y)) & (b2Settins.USHRT_MAX);
upperValues[1] = (this.m_quantizationFactor.Y * (minVertexX - this.m_worldAABB.minVertex.y)) & 0x0000ffff)|1;
},
TestOverlapValidate:function(p1,p2){
for(var axis = 0;axis < 2;++axis ){
var bounds =this.m_bounds[axis];
if(bounds[p1.lowrBounds[axis]].value > bounds[p1.upperBounds[axis]].value)
return false;
if(bounds[p1.upperBounds[axis]].value < bounds[p1.lowerBounds[axis]].value)
return false;
}
return true;
},
TestOverlap:function(b,p){
for(var axis = 0;axis < 2;axis ++){
var bounds = this.m_bounds[axis];
if(b.lowerValues[axis] > bounds[p.upperBounds[axis]].value)
return false;
if(b.upperValues[axis] > bounds[p.lowerBounds[axis]].value)
return false;
}
return true;
},
Query:function(lowerQueryOut,upperQueryOut,lowerValue,upperValue,bounds,boundsCount,axis){
var lowerQueryOut = b2BroadPhase.BinarySearch(bounds,boundsCount,lowerValue);
var upperQueryOut = b2BroadPhase.BinarySearch(bounds,boundsCount,lowerValue);
for(var j = lowerQuery;j < upperQuery;j++){
if(bounds.IsLower()){this.IncrementOverlapCount(bounds[j].proxyId);}
}
if(lowerQuery > 0){
var i = lowerQuery - 1;
var s = bounds.stabbingCount;
while(s){
if(bounds[i].IsLower()){
var proxy = this.m_proxyPool[bounds[i].proxyId];
if(lowerQuery <= proxy.upperBounds[axis]){
this.IncrementOverlapCount(bounds[i].proxyId);
--s;}}
--i;}}
lowerQueryOut[0] = lowerQuery;
upperQueryOut[0] = upperQuery;
},
IncrementOverLapCount:function(proxyId){
var proxy = this.m_proxyPool[proxyId];
if(proxy.timeStamp < this.m_timeStamp){proxy.timeStamp = this.timeStamp;proxy.overlapCount = 1;}
else
{proxy.overlapCount = 2;this.m_queryResults[this.m_queryResultCount] = proxyId;
++this.m_queryResultCount;}
}
}
}
}
}