home *** CD-ROM | disk | FTP | other *** search
/ 404 Jogos / CLJG.iso / Diversos / Beez.swf / scripts / Box2D / Collision / b2BroadPhase.as < prev    next >
Encoding:
Text File  |  2008-09-03  |  27.7 KB  |  779 lines
  1. package Box2D.Collision
  2. {
  3.    import Box2D.Common.Math.b2Math;
  4.    import Box2D.Common.Math.b2Vec2;
  5.    import Box2D.Common.b2Settings;
  6.    
  7.    public class b2BroadPhase
  8.    {
  9.       
  10.       public static var s_validate:Boolean = false;
  11.       
  12.       public static const b2_nullEdge:uint = b2Settings.USHRT_MAX;
  13.       
  14.       public static const b2_invalid:uint = b2Settings.USHRT_MAX;
  15.        
  16.       
  17.       public var m_bounds:Array;
  18.       
  19.       public var m_quantizationFactor:b2Vec2;
  20.       
  21.       public var m_worldAABB:b2AABB;
  22.       
  23.       public var m_freeProxy:uint;
  24.       
  25.       public var m_proxyCount:int;
  26.       
  27.       public var m_proxyPool:Array;
  28.       
  29.       public var m_queryResultCount:int;
  30.       
  31.       public var m_pairManager:b2PairManager;
  32.       
  33.       public var m_timeStamp:uint;
  34.       
  35.       public var m_queryResults:Array;
  36.       
  37.       public function b2BroadPhase(worldAABB:b2AABB, callback:b2PairCallback)
  38.       {
  39.          var i:int = 0;
  40.          var dY:Number = NaN;
  41.          var tProxy:b2Proxy = null;
  42.          var j:int = 0;
  43.          m_pairManager = new b2PairManager();
  44.          m_proxyPool = new Array(b2Settings.b2_maxPairs);
  45.          m_bounds = new Array(2 * b2Settings.b2_maxProxies);
  46.          m_queryResults = new Array(b2Settings.b2_maxProxies);
  47.          m_quantizationFactor = new b2Vec2();
  48.          super();
  49.          m_pairManager.Initialize(this,callback);
  50.          m_worldAABB = worldAABB;
  51.          m_proxyCount = 0;
  52.          for(i = 0; i < b2Settings.b2_maxProxies; i++)
  53.          {
  54.             m_queryResults[i] = 0;
  55.          }
  56.          m_bounds = new Array(2);
  57.          for(i = 0; i < 2; i++)
  58.          {
  59.             m_bounds[i] = new Array(2 * b2Settings.b2_maxProxies);
  60.             for(j = 0; j < 2 * b2Settings.b2_maxProxies; j++)
  61.             {
  62.                m_bounds[i][j] = new b2Bound();
  63.             }
  64.          }
  65.          var dX:Number = worldAABB.upperBound.x - worldAABB.lowerBound.x;
  66.          dY = worldAABB.upperBound.y - worldAABB.lowerBound.y;
  67.          m_quantizationFactor.x = b2Settings.USHRT_MAX / dX;
  68.          m_quantizationFactor.y = b2Settings.USHRT_MAX / dY;
  69.          for(i = 0; i < b2Settings.b2_maxProxies - 1; i++)
  70.          {
  71.             tProxy = new b2Proxy();
  72.             m_proxyPool[i] = tProxy;
  73.             tProxy.SetNext(i + 1);
  74.             tProxy.timeStamp = 0;
  75.             tProxy.overlapCount = b2_invalid;
  76.             tProxy.userData = null;
  77.          }
  78.          tProxy = new b2Proxy();
  79.          m_proxyPool[int(b2Settings.b2_maxProxies - 1)] = tProxy;
  80.          tProxy.SetNext(b2Pair.b2_nullProxy);
  81.          tProxy.timeStamp = 0;
  82.          tProxy.overlapCount = b2_invalid;
  83.          tProxy.userData = null;
  84.          m_freeProxy = 0;
  85.          m_timeStamp = 1;
  86.          m_queryResultCount = 0;
  87.       }
  88.       
  89.       public static function BinarySearch(bounds:Array, count:int, value:uint) : uint
  90.       {
  91.          var mid:int = 0;
  92.          var bound:b2Bound = null;
  93.          var low:int = 0;
  94.          var high:int = count - 1;
  95.          while(low <= high)
  96.          {
  97.             mid = (low + high) / 2;
  98.             bound = bounds[mid];
  99.             if(bound.value > value)
  100.             {
  101.                high = mid - 1;
  102.             }
  103.             else
  104.             {
  105.                if(bound.value >= value)
  106.                {
  107.                   return uint(mid);
  108.                }
  109.                low = mid + 1;
  110.             }
  111.          }
  112.          return uint(low);
  113.       }
  114.       
  115.       public function QueryAABB(aabb:b2AABB, userData:*, maxCount:int) : int
  116.       {
  117.          var lowerIndex:uint = 0;
  118.          var upperIndex:uint = 0;
  119.          var proxy:b2Proxy = null;
  120.          var lowerValues:Array = new Array();
  121.          var upperValues:Array = new Array();
  122.          ComputeBounds(lowerValues,upperValues,aabb);
  123.          var lowerIndexOut:Array = [lowerIndex];
  124.          var upperIndexOut:Array = [upperIndex];
  125.          Query(lowerIndexOut,upperIndexOut,lowerValues[0],upperValues[0],m_bounds[0],2 * m_proxyCount,0);
  126.          Query(lowerIndexOut,upperIndexOut,lowerValues[1],upperValues[1],m_bounds[1],2 * m_proxyCount,1);
  127.          var count:int = 0;
  128.          var i:int = 0;
  129.          while(i < m_queryResultCount && count < maxCount)
  130.          {
  131.             proxy = m_proxyPool[m_queryResults[i]];
  132.             userData[i] = proxy.userData;
  133.             i++;
  134.             count++;
  135.          }
  136.          m_queryResultCount = 0;
  137.          IncrementTimeStamp();
  138.          return count;
  139.       }
  140.       
  141.       public function Commit() : void
  142.       {
  143.          m_pairManager.Commit();
  144.       }
  145.       
  146.       public function GetProxy(proxyId:int) : b2Proxy
  147.       {
  148.          var proxy:b2Proxy = m_proxyPool[proxyId];
  149.          if(proxyId == b2Pair.b2_nullProxy || proxy.IsValid() == false)
  150.          {
  151.             return null;
  152.          }
  153.          return proxy;
  154.       }
  155.       
  156.       private function IncrementTimeStamp() : void
  157.       {
  158.          var i:uint = 0;
  159.          if(m_timeStamp == b2Settings.USHRT_MAX)
  160.          {
  161.             for(i = 0; i < b2Settings.b2_maxProxies; i++)
  162.             {
  163.                (m_proxyPool[i] as b2Proxy).timeStamp = 0;
  164.             }
  165.             m_timeStamp = 1;
  166.          }
  167.          else
  168.          {
  169.             ++m_timeStamp;
  170.          }
  171.       }
  172.       
  173.       private function Query(lowerQueryOut:Array, upperQueryOut:Array, lowerValue:uint, upperValue:uint, bounds:Array, boundCount:uint, axis:int) : void
  174.       {
  175.          var bound:b2Bound = null;
  176.          var i:int = 0;
  177.          var s:int = 0;
  178.          var proxy:b2Proxy = null;
  179.          var lowerQuery:uint = BinarySearch(bounds,boundCount,lowerValue);
  180.          var upperQuery:uint = BinarySearch(bounds,boundCount,upperValue);
  181.          for(var j:uint = lowerQuery; j < upperQuery; j++)
  182.          {
  183.             bound = bounds[j];
  184.             if(bound.IsLower())
  185.             {
  186.                IncrementOverlapCount(bound.proxyId);
  187.             }
  188.          }
  189.          if(lowerQuery > 0)
  190.          {
  191.             i = int(lowerQuery - 1);
  192.             bound = bounds[i];
  193.             s = int(bound.stabbingCount);
  194.             while(s)
  195.             {
  196.                bound = bounds[i];
  197.                if(bound.IsLower())
  198.                {
  199.                   proxy = m_proxyPool[bound.proxyId];
  200.                   if(lowerQuery <= proxy.upperBounds[axis])
  201.                   {
  202.                      IncrementOverlapCount(bound.proxyId);
  203.                      s--;
  204.                   }
  205.                }
  206.                i--;
  207.             }
  208.          }
  209.          lowerQueryOut[0] = lowerQuery;
  210.          upperQueryOut[0] = upperQuery;
  211.       }
  212.       
  213.       private function TestOverlapValidate(p1:b2Proxy, p2:b2Proxy) : Boolean
  214.       {
  215.          var bounds:Array = null;
  216.          var bound1:b2Bound = null;
  217.          var bound2:b2Bound = null;
  218.          for(var axis:int = 0; axis < 2; axis++)
  219.          {
  220.             bounds = m_bounds[axis];
  221.             bound1 = bounds[p1.lowerBounds[axis]];
  222.             bound2 = bounds[p2.upperBounds[axis]];
  223.             if(bound1.value > bound2.value)
  224.             {
  225.                return false;
  226.             }
  227.             bound1 = bounds[p1.upperBounds[axis]];
  228.             bound2 = bounds[p2.lowerBounds[axis]];
  229.             if(bound1.value < bound2.value)
  230.             {
  231.                return false;
  232.             }
  233.          }
  234.          return true;
  235.       }
  236.       
  237.       private function ComputeBounds(lowerValues:Array, upperValues:Array, aabb:b2AABB) : void
  238.       {
  239.          var minVertexX:Number = aabb.lowerBound.x;
  240.          var minVertexY:Number = aabb.lowerBound.y;
  241.          minVertexX = b2Math.b2Min(minVertexX,m_worldAABB.upperBound.x);
  242.          minVertexY = b2Math.b2Min(minVertexY,m_worldAABB.upperBound.y);
  243.          minVertexX = b2Math.b2Max(minVertexX,m_worldAABB.lowerBound.x);
  244.          minVertexY = b2Math.b2Max(minVertexY,m_worldAABB.lowerBound.y);
  245.          var maxVertexX:Number = aabb.upperBound.x;
  246.          var maxVertexY:Number = aabb.upperBound.y;
  247.          maxVertexX = b2Math.b2Min(maxVertexX,m_worldAABB.upperBound.x);
  248.          maxVertexY = b2Math.b2Min(maxVertexY,m_worldAABB.upperBound.y);
  249.          maxVertexX = b2Math.b2Max(maxVertexX,m_worldAABB.lowerBound.x);
  250.          maxVertexY = b2Math.b2Max(maxVertexY,m_worldAABB.lowerBound.y);
  251.          lowerValues[0] = uint(m_quantizationFactor.x * (minVertexX - m_worldAABB.lowerBound.x)) & b2Settings.USHRT_MAX - 1;
  252.          upperValues[0] = uint(m_quantizationFactor.x * (maxVertexX - m_worldAABB.lowerBound.x)) & 65535 | 1;
  253.          lowerValues[1] = uint(m_quantizationFactor.y * (minVertexY - m_worldAABB.lowerBound.y)) & b2Settings.USHRT_MAX - 1;
  254.          upperValues[1] = uint(m_quantizationFactor.y * (maxVertexY - m_worldAABB.lowerBound.y)) & 65535 | 1;
  255.       }
  256.       
  257.       public function CreateProxy(aabb:b2AABB, userData:*) : uint
  258.       {
  259.          var index:uint = 0;
  260.          var proxy:b2Proxy = null;
  261.          var bounds:Array = null;
  262.          var lowerIndex:uint = 0;
  263.          var upperIndex:uint = 0;
  264.          var lowerIndexOut:Array = null;
  265.          var upperIndexOut:Array = null;
  266.          var tArr:Array = null;
  267.          var j:int = 0;
  268.          var tEnd:int = 0;
  269.          var tBound1:b2Bound = null;
  270.          var tBound2:b2Bound = null;
  271.          var tBoundAS3:b2Bound = null;
  272.          var tIndex:int = 0;
  273.          var proxy2:b2Proxy = null;
  274.          var proxyId:uint = m_freeProxy;
  275.          proxy = m_proxyPool[proxyId];
  276.          m_freeProxy = proxy.GetNext();
  277.          proxy.overlapCount = 0;
  278.          proxy.userData = userData;
  279.          var boundCount:uint = uint(2 * m_proxyCount);
  280.          var lowerValues:Array = new Array();
  281.          var upperValues:Array = new Array();
  282.          ComputeBounds(lowerValues,upperValues,aabb);
  283.          for(var axis:int = 0; axis < 2; axis++)
  284.          {
  285.             bounds = m_bounds[axis];
  286.             lowerIndexOut = [lowerIndex];
  287.             upperIndexOut = [upperIndex];
  288.             Query(lowerIndexOut,upperIndexOut,lowerValues[axis],upperValues[axis],bounds,boundCount,axis);
  289.             lowerIndex = uint(lowerIndexOut[0]);
  290.             upperIndex = uint(upperIndexOut[0]);
  291.             tArr = new Array();
  292.             tEnd = boundCount - upperIndex;
  293.             for(j = 0; j < tEnd; j++)
  294.             {
  295.                tArr[j] = new b2Bound();
  296.                tBound1 = tArr[j];
  297.                tBound2 = bounds[int(upperIndex + j)];
  298.                tBound1.value = tBound2.value;
  299.                tBound1.proxyId = tBound2.proxyId;
  300.                tBound1.stabbingCount = tBound2.stabbingCount;
  301.             }
  302.             tEnd = int(tArr.length);
  303.             tIndex = upperIndex + 2;
  304.             for(j = 0; j < tEnd; j++)
  305.             {
  306.                tBound2 = tArr[j];
  307.                tBound1 = bounds[int(tIndex + j)];
  308.                tBound1.value = tBound2.value;
  309.                tBound1.proxyId = tBound2.proxyId;
  310.                tBound1.stabbingCount = tBound2.stabbingCount;
  311.             }
  312.             tArr = new Array();
  313.             tEnd = upperIndex - lowerIndex;
  314.             for(j = 0; j < tEnd; j++)
  315.             {
  316.                tArr[j] = new b2Bound();
  317.                tBound1 = tArr[j];
  318.                tBound2 = bounds[int(lowerIndex + j)];
  319.                tBound1.value = tBound2.value;
  320.                tBound1.proxyId = tBound2.proxyId;
  321.                tBound1.stabbingCount = tBound2.stabbingCount;
  322.             }
  323.             tEnd = int(tArr.length);
  324.             tIndex = lowerIndex + 1;
  325.             for(j = 0; j < tEnd; j++)
  326.             {
  327.                tBound2 = tArr[j];
  328.                tBound1 = bounds[int(tIndex + j)];
  329.                tBound1.value = tBound2.value;
  330.                tBound1.proxyId = tBound2.proxyId;
  331.                tBound1.stabbingCount = tBound2.stabbingCount;
  332.             }
  333.             upperIndex++;
  334.             tBound1 = bounds[lowerIndex];
  335.             tBound2 = bounds[upperIndex];
  336.             tBound1.value = lowerValues[axis];
  337.             tBound1.proxyId = proxyId;
  338.             tBound2.value = upperValues[axis];
  339.             tBound2.proxyId = proxyId;
  340.             tBoundAS3 = bounds[int(lowerIndex - 1)];
  341.             tBound1.stabbingCount = lowerIndex == 0 ? 0 : tBoundAS3.stabbingCount;
  342.             tBoundAS3 = bounds[int(upperIndex - 1)];
  343.             tBound2.stabbingCount = tBoundAS3.stabbingCount;
  344.             for(index = lowerIndex; index < upperIndex; index++)
  345.             {
  346.                tBoundAS3 = bounds[index];
  347.                ++tBoundAS3.stabbingCount;
  348.             }
  349.             for(index = lowerIndex; index < boundCount + 2; index++)
  350.             {
  351.                tBound1 = bounds[index];
  352.                proxy2 = m_proxyPool[tBound1.proxyId];
  353.                if(tBound1.IsLower())
  354.                {
  355.                   proxy2.lowerBounds[axis] = index;
  356.                }
  357.                else
  358.                {
  359.                   proxy2.upperBounds[axis] = index;
  360.                }
  361.             }
  362.          }
  363.          ++m_proxyCount;
  364.          for(var i:int = 0; i < m_queryResultCount; i++)
  365.          {
  366.             m_pairManager.AddBufferedPair(proxyId,m_queryResults[i]);
  367.          }
  368.          m_pairManager.Commit();
  369.          m_queryResultCount = 0;
  370.          IncrementTimeStamp();
  371.          return proxyId;
  372.       }
  373.       
  374.       public function DestroyProxy(proxyId:uint) : void
  375.       {
  376.          var tBound1:b2Bound = null;
  377.          var tBound2:b2Bound = null;
  378.          var bounds:Array = null;
  379.          var lowerIndex:uint = 0;
  380.          var upperIndex:uint = 0;
  381.          var lowerValue:uint = 0;
  382.          var upperValue:uint = 0;
  383.          var tArr:Array = null;
  384.          var j:int = 0;
  385.          var tEnd:int = 0;
  386.          var tIndex:int = 0;
  387.          var index:uint = 0;
  388.          var index2:int = 0;
  389.          var proxy2:b2Proxy = null;
  390.          var proxy:b2Proxy = m_proxyPool[proxyId];
  391.          var boundCount:int = 2 * m_proxyCount;
  392.          for(var axis:int = 0; axis < 2; axis++)
  393.          {
  394.             bounds = m_bounds[axis];
  395.             lowerIndex = uint(proxy.lowerBounds[axis]);
  396.             upperIndex = uint(proxy.upperBounds[axis]);
  397.             tBound1 = bounds[lowerIndex];
  398.             lowerValue = tBound1.value;
  399.             tBound2 = bounds[upperIndex];
  400.             upperValue = tBound2.value;
  401.             tArr = new Array();
  402.             tEnd = upperIndex - lowerIndex - 1;
  403.             for(j = 0; j < tEnd; j++)
  404.             {
  405.                tArr[j] = new b2Bound();
  406.                tBound1 = tArr[j];
  407.                tBound2 = bounds[int(lowerIndex + 1 + j)];
  408.                tBound1.value = tBound2.value;
  409.                tBound1.proxyId = tBound2.proxyId;
  410.                tBound1.stabbingCount = tBound2.stabbingCount;
  411.             }
  412.             tEnd = int(tArr.length);
  413.             tIndex = int(lowerIndex);
  414.             for(j = 0; j < tEnd; j++)
  415.             {
  416.                tBound2 = tArr[j];
  417.                tBound1 = bounds[int(tIndex + j)];
  418.                tBound1.value = tBound2.value;
  419.                tBound1.proxyId = tBound2.proxyId;
  420.                tBound1.stabbingCount = tBound2.stabbingCount;
  421.             }
  422.             tArr = new Array();
  423.             tEnd = boundCount - upperIndex - 1;
  424.             for(j = 0; j < tEnd; j++)
  425.             {
  426.                tArr[j] = new b2Bound();
  427.                tBound1 = tArr[j];
  428.                tBound2 = bounds[int(upperIndex + 1 + j)];
  429.                tBound1.value = tBound2.value;
  430.                tBound1.proxyId = tBound2.proxyId;
  431.                tBound1.stabbingCount = tBound2.stabbingCount;
  432.             }
  433.             tEnd = int(tArr.length);
  434.             tIndex = int(upperIndex - 1);
  435.             for(j = 0; j < tEnd; j++)
  436.             {
  437.                tBound2 = tArr[j];
  438.                tBound1 = bounds[int(tIndex + j)];
  439.                tBound1.value = tBound2.value;
  440.                tBound1.proxyId = tBound2.proxyId;
  441.                tBound1.stabbingCount = tBound2.stabbingCount;
  442.             }
  443.             tEnd = boundCount - 2;
  444.             for(index = lowerIndex; index < tEnd; index++)
  445.             {
  446.                tBound1 = bounds[index];
  447.                proxy2 = m_proxyPool[tBound1.proxyId];
  448.                if(tBound1.IsLower())
  449.                {
  450.                   proxy2.lowerBounds[axis] = index;
  451.                }
  452.                else
  453.                {
  454.                   proxy2.upperBounds[axis] = index;
  455.                }
  456.             }
  457.             tEnd = int(upperIndex - 1);
  458.             for(index2 = int(lowerIndex); index2 < tEnd; index2++)
  459.             {
  460.                tBound1 = bounds[index2];
  461.                --tBound1.stabbingCount;
  462.             }
  463.             Query([0],[0],lowerValue,upperValue,bounds,boundCount - 2,axis);
  464.          }
  465.          for(var i:int = 0; i < m_queryResultCount; i++)
  466.          {
  467.             m_pairManager.RemoveBufferedPair(proxyId,m_queryResults[i]);
  468.          }
  469.          m_pairManager.Commit();
  470.          m_queryResultCount = 0;
  471.          IncrementTimeStamp();
  472.          proxy.userData = null;
  473.          proxy.overlapCount = b2_invalid;
  474.          proxy.lowerBounds[0] = b2_invalid;
  475.          proxy.lowerBounds[1] = b2_invalid;
  476.          proxy.upperBounds[0] = b2_invalid;
  477.          proxy.upperBounds[1] = b2_invalid;
  478.          proxy.SetNext(m_freeProxy);
  479.          m_freeProxy = proxyId;
  480.          --m_proxyCount;
  481.       }
  482.       
  483.       public function TestOverlap(b:b2BoundValues, p:b2Proxy) : Boolean
  484.       {
  485.          var bounds:Array = null;
  486.          var bound:b2Bound = null;
  487.          for(var axis:int = 0; axis < 2; axis++)
  488.          {
  489.             bounds = m_bounds[axis];
  490.             bound = bounds[p.upperBounds[axis]];
  491.             if(b.lowerValues[axis] > bound.value)
  492.             {
  493.                return false;
  494.             }
  495.             bound = bounds[p.lowerBounds[axis]];
  496.             if(b.upperValues[axis] < bound.value)
  497.             {
  498.                return false;
  499.             }
  500.          }
  501.          return true;
  502.       }
  503.       
  504.       public function Validate() : void
  505.       {
  506.          var pair:b2Pair = null;
  507.          var proxy1:b2Proxy = null;
  508.          var proxy2:b2Proxy = null;
  509.          var overlap:Boolean = false;
  510.          var bounds:b2Bound = null;
  511.          var boundCount:uint = 0;
  512.          var stabbingCount:uint = 0;
  513.          var i:uint = 0;
  514.          var bound:b2Bound = null;
  515.          for(var axis:int = 0; axis < 2; axis++)
  516.          {
  517.             bounds = m_bounds[axis];
  518.             boundCount = uint(2 * m_proxyCount);
  519.             stabbingCount = 0;
  520.             for(i = 0; i < boundCount; i++)
  521.             {
  522.                bound = bounds[i];
  523.                if(bound.IsLower() == true)
  524.                {
  525.                   stabbingCount++;
  526.                }
  527.                else
  528.                {
  529.                   stabbingCount--;
  530.                }
  531.             }
  532.          }
  533.       }
  534.       
  535.       private function IncrementOverlapCount(proxyId:uint) : void
  536.       {
  537.          var proxy:b2Proxy = m_proxyPool[proxyId];
  538.          if(proxy.timeStamp < m_timeStamp)
  539.          {
  540.             proxy.timeStamp = m_timeStamp;
  541.             proxy.overlapCount = 1;
  542.          }
  543.          else
  544.          {
  545.             proxy.overlapCount = 2;
  546.             m_queryResults[m_queryResultCount] = proxyId;
  547.             ++m_queryResultCount;
  548.          }
  549.       }
  550.       
  551.       public function InRange(aabb:b2AABB) : Boolean
  552.       {
  553.          var dX:Number = NaN;
  554.          var dY:Number = NaN;
  555.          var d2X:Number = NaN;
  556.          var d2Y:Number = NaN;
  557.          dX = aabb.lowerBound.x;
  558.          dY = aabb.lowerBound.y;
  559.          dX -= m_worldAABB.upperBound.x;
  560.          dY -= m_worldAABB.upperBound.y;
  561.          d2X = m_worldAABB.lowerBound.x;
  562.          d2Y = m_worldAABB.lowerBound.y;
  563.          d2X -= aabb.upperBound.x;
  564.          d2Y -= aabb.upperBound.y;
  565.          dX = b2Math.b2Max(dX,d2X);
  566.          dY = b2Math.b2Max(dY,d2Y);
  567.          return b2Math.b2Max(dX,dY) < 0;
  568.       }
  569.       
  570.       public function MoveProxy(proxyId:uint, aabb:b2AABB) : void
  571.       {
  572.          var as3arr:Array = null;
  573.          var as3int:int = 0;
  574.          var axis:uint = 0;
  575.          var index:uint = 0;
  576.          var bound:b2Bound = null;
  577.          var prevBound:b2Bound = null;
  578.          var nextBound:b2Bound = null;
  579.          var nextProxyId:uint = 0;
  580.          var nextProxy:b2Proxy = null;
  581.          var bounds:Array = null;
  582.          var lowerIndex:uint = 0;
  583.          var upperIndex:uint = 0;
  584.          var lowerValue:uint = 0;
  585.          var upperValue:uint = 0;
  586.          var deltaLower:int = 0;
  587.          var deltaUpper:int = 0;
  588.          var prevProxyId:uint = 0;
  589.          var prevProxy:b2Proxy = null;
  590.          if(proxyId == b2Pair.b2_nullProxy || b2Settings.b2_maxProxies <= proxyId)
  591.          {
  592.             return;
  593.          }
  594.          if(aabb.IsValid() == false)
  595.          {
  596.             return;
  597.          }
  598.          var boundCount:uint = uint(2 * m_proxyCount);
  599.          var proxy:b2Proxy = m_proxyPool[proxyId];
  600.          var newValues:b2BoundValues = new b2BoundValues();
  601.          ComputeBounds(newValues.lowerValues,newValues.upperValues,aabb);
  602.          var oldValues:b2BoundValues = new b2BoundValues();
  603.          for(axis = 0; axis < 2; axis++)
  604.          {
  605.             bound = m_bounds[axis][proxy.lowerBounds[axis]];
  606.             oldValues.lowerValues[axis] = bound.value;
  607.             bound = m_bounds[axis][proxy.upperBounds[axis]];
  608.             oldValues.upperValues[axis] = bound.value;
  609.          }
  610.          for(axis = 0; axis < 2; axis++)
  611.          {
  612.             bounds = m_bounds[axis];
  613.             lowerIndex = uint(proxy.lowerBounds[axis]);
  614.             upperIndex = uint(proxy.upperBounds[axis]);
  615.             lowerValue = uint(newValues.lowerValues[axis]);
  616.             upperValue = uint(newValues.upperValues[axis]);
  617.             bound = bounds[lowerIndex];
  618.             deltaLower = lowerValue - bound.value;
  619.             bound.value = lowerValue;
  620.             bound = bounds[upperIndex];
  621.             deltaUpper = upperValue - bound.value;
  622.             bound.value = upperValue;
  623.             if(deltaLower < 0)
  624.             {
  625.                index = lowerIndex;
  626.                while(index > 0 && lowerValue < (bounds[int(index - 1)] as b2Bound).value)
  627.                {
  628.                   bound = bounds[index];
  629.                   prevBound = bounds[int(index - 1)];
  630.                   prevProxyId = prevBound.proxyId;
  631.                   prevProxy = m_proxyPool[prevBound.proxyId];
  632.                   ++prevBound.stabbingCount;
  633.                   if(prevBound.IsUpper() == true)
  634.                   {
  635.                      if(TestOverlap(newValues,prevProxy))
  636.                      {
  637.                         m_pairManager.AddBufferedPair(proxyId,prevProxyId);
  638.                      }
  639.                      as3arr = prevProxy.upperBounds;
  640.                      as3int = int(as3arr[axis]);
  641.                      as3int++;
  642.                      as3arr[axis] = as3int;
  643.                      ++bound.stabbingCount;
  644.                   }
  645.                   else
  646.                   {
  647.                      as3arr = prevProxy.lowerBounds;
  648.                      as3int = int(as3arr[axis]);
  649.                      as3int++;
  650.                      as3arr[axis] = as3int;
  651.                      --bound.stabbingCount;
  652.                   }
  653.                   as3arr = proxy.lowerBounds;
  654.                   as3int = int(as3arr[axis]);
  655.                   as3int--;
  656.                   as3arr[axis] = as3int;
  657.                   bound.Swap(prevBound);
  658.                   index--;
  659.                }
  660.             }
  661.             if(deltaUpper > 0)
  662.             {
  663.                index = upperIndex;
  664.                while(index < boundCount - 1 && (bounds[int(index + 1)] as b2Bound).value <= upperValue)
  665.                {
  666.                   bound = bounds[index];
  667.                   nextBound = bounds[int(index + 1)];
  668.                   nextProxyId = nextBound.proxyId;
  669.                   nextProxy = m_proxyPool[nextProxyId];
  670.                   ++nextBound.stabbingCount;
  671.                   if(nextBound.IsLower() == true)
  672.                   {
  673.                      if(TestOverlap(newValues,nextProxy))
  674.                      {
  675.                         m_pairManager.AddBufferedPair(proxyId,nextProxyId);
  676.                      }
  677.                      as3arr = nextProxy.lowerBounds;
  678.                      as3int = int(as3arr[axis]);
  679.                      as3int--;
  680.                      as3arr[axis] = as3int;
  681.                      ++bound.stabbingCount;
  682.                   }
  683.                   else
  684.                   {
  685.                      as3arr = nextProxy.upperBounds;
  686.                      as3int = int(as3arr[axis]);
  687.                      as3int--;
  688.                      as3arr[axis] = as3int;
  689.                      --bound.stabbingCount;
  690.                   }
  691.                   as3arr = proxy.upperBounds;
  692.                   as3int = int(as3arr[axis]);
  693.                   as3int++;
  694.                   as3arr[axis] = as3int;
  695.                   bound.Swap(nextBound);
  696.                   index++;
  697.                }
  698.             }
  699.             if(deltaLower > 0)
  700.             {
  701.                index = lowerIndex;
  702.                while(index < boundCount - 1 && (bounds[int(index + 1)] as b2Bound).value <= lowerValue)
  703.                {
  704.                   bound = bounds[index];
  705.                   nextBound = bounds[int(index + 1)];
  706.                   nextProxyId = nextBound.proxyId;
  707.                   nextProxy = m_proxyPool[nextProxyId];
  708.                   --nextBound.stabbingCount;
  709.                   if(nextBound.IsUpper())
  710.                   {
  711.                      if(TestOverlap(oldValues,nextProxy))
  712.                      {
  713.                         m_pairManager.RemoveBufferedPair(proxyId,nextProxyId);
  714.                      }
  715.                      as3arr = nextProxy.upperBounds;
  716.                      as3int = int(as3arr[axis]);
  717.                      as3int--;
  718.                      as3arr[axis] = as3int;
  719.                      --bound.stabbingCount;
  720.                   }
  721.                   else
  722.                   {
  723.                      as3arr = nextProxy.lowerBounds;
  724.                      as3int = int(as3arr[axis]);
  725.                      as3int--;
  726.                      as3arr[axis] = as3int;
  727.                      ++bound.stabbingCount;
  728.                   }
  729.                   as3arr = proxy.lowerBounds;
  730.                   as3int = int(as3arr[axis]);
  731.                   as3int++;
  732.                   as3arr[axis] = as3int;
  733.                   bound.Swap(nextBound);
  734.                   index++;
  735.                }
  736.             }
  737.             if(deltaUpper < 0)
  738.             {
  739.                index = upperIndex;
  740.                while(index > 0 && upperValue < (bounds[int(index - 1)] as b2Bound).value)
  741.                {
  742.                   bound = bounds[index];
  743.                   prevBound = bounds[int(index - 1)];
  744.                   prevProxyId = prevBound.proxyId;
  745.                   prevProxy = m_proxyPool[prevProxyId];
  746.                   --prevBound.stabbingCount;
  747.                   if(prevBound.IsLower() == true)
  748.                   {
  749.                      if(TestOverlap(oldValues,prevProxy))
  750.                      {
  751.                         m_pairManager.RemoveBufferedPair(proxyId,prevProxyId);
  752.                      }
  753.                      as3arr = prevProxy.lowerBounds;
  754.                      as3int = int(as3arr[axis]);
  755.                      as3int++;
  756.                      as3arr[axis] = as3int;
  757.                      --bound.stabbingCount;
  758.                   }
  759.                   else
  760.                   {
  761.                      as3arr = prevProxy.upperBounds;
  762.                      as3int = int(as3arr[axis]);
  763.                      as3int++;
  764.                      as3arr[axis] = as3int;
  765.                      ++bound.stabbingCount;
  766.                   }
  767.                   as3arr = proxy.upperBounds;
  768.                   as3int = int(as3arr[axis]);
  769.                   as3int--;
  770.                   as3arr[axis] = as3int;
  771.                   bound.Swap(prevBound);
  772.                   index--;
  773.                }
  774.             }
  775.          }
  776.       }
  777.    }
  778. }
  779.