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