home *** CD-ROM | disk | FTP | other *** search
/ 404 Jogos / CLJG.iso / Diversos / pup_idol.swf / scripts / Box2D / Collision / Shapes / b2PolyShape.as < prev    next >
Encoding:
Text File  |  2008-08-07  |  14.8 KB  |  331 lines
  1. package Box2D.Collision.Shapes
  2. {
  3.    import Box2D.Collision.*;
  4.    import Box2D.Common.*;
  5.    import Box2D.Common.Math.*;
  6.    import Box2D.Dynamics.*;
  7.    
  8.    public class b2PolyShape extends b2Shape
  9.    {
  10.       
  11.       private static var tempVec:b2Vec2 = new b2Vec2();
  12.       
  13.       private static var tAbsR:b2Mat22 = new b2Mat22();
  14.        
  15.       
  16.       public var m_vertexCount:int;
  17.       
  18.       private var syncMat:b2Mat22;
  19.       
  20.       public var m_vertices:Array;
  21.       
  22.       public var m_coreVertices:Array;
  23.       
  24.       public var m_localCentroid:b2Vec2;
  25.       
  26.       public var m_normals:Array;
  27.       
  28.       private var syncAABB:b2AABB;
  29.       
  30.       public var m_localOBB:b2OBB;
  31.       
  32.       public function b2PolyShape(param1:b2ShapeDef, param2:b2Body, param3:b2Vec2)
  33.       {
  34.          var _loc4_:int = 0;
  35.          var _loc5_:Number = NaN;
  36.          var _loc6_:Number = NaN;
  37.          var _loc7_:b2Vec2 = null;
  38.          var _loc8_:b2AABB = null;
  39.          var _loc9_:b2Mat22 = null;
  40.          var _loc14_:int = 0;
  41.          var _loc15_:int = 0;
  42.          var _loc19_:b2BoxDef = null;
  43.          var _loc20_:Number = NaN;
  44.          var _loc21_:Number = NaN;
  45.          var _loc22_:b2PolyDef = null;
  46.          var _loc23_:Number = NaN;
  47.          var _loc24_:Number = NaN;
  48.          var _loc25_:Number = NaN;
  49.          var _loc26_:Number = NaN;
  50.          var _loc27_:Number = NaN;
  51.          var _loc28_:b2Vec2 = null;
  52.          syncAABB = new b2AABB();
  53.          syncMat = new b2Mat22();
  54.          m_localCentroid = new b2Vec2();
  55.          m_localOBB = new b2OBB();
  56.          super(param1,param2);
  57.          _loc8_ = new b2AABB();
  58.          m_vertices = new Array(b2Settings.b2_maxPolyVertices);
  59.          m_coreVertices = new Array(b2Settings.b2_maxPolyVertices);
  60.          m_normals = new Array(b2Settings.b2_maxPolyVertices);
  61.          m_type = b2Shape.e_polyShape;
  62.          _loc9_ = new b2Mat22(param1.localRotation);
  63.          if(param1.type == b2Shape.e_boxShape)
  64.          {
  65.             m_localCentroid.x = param1.localPosition.x - param3.x;
  66.             m_localCentroid.y = param1.localPosition.y - param3.y;
  67.             _loc19_ = param1 as b2BoxDef;
  68.             m_vertexCount = 4;
  69.             _loc5_ = _loc19_.extents.x;
  70.             _loc6_ = _loc19_.extents.y;
  71.             _loc20_ = Math.max(0,_loc5_ - 2 * b2Settings.b2_linearSlop);
  72.             _loc21_ = Math.max(0,_loc6_ - 2 * b2Settings.b2_linearSlop);
  73.             (_loc7_ = m_vertices[0] = new b2Vec2()).x = _loc9_.col1.x * _loc5_ + _loc9_.col2.x * _loc6_;
  74.             _loc7_.y = _loc9_.col1.y * _loc5_ + _loc9_.col2.y * _loc6_;
  75.             (_loc7_ = m_vertices[1] = new b2Vec2()).x = _loc9_.col1.x * -_loc5_ + _loc9_.col2.x * _loc6_;
  76.             _loc7_.y = _loc9_.col1.y * -_loc5_ + _loc9_.col2.y * _loc6_;
  77.             (_loc7_ = m_vertices[2] = new b2Vec2()).x = _loc9_.col1.x * -_loc5_ + _loc9_.col2.x * -_loc6_;
  78.             _loc7_.y = _loc9_.col1.y * -_loc5_ + _loc9_.col2.y * -_loc6_;
  79.             (_loc7_ = m_vertices[3] = new b2Vec2()).x = _loc9_.col1.x * _loc5_ + _loc9_.col2.x * -_loc6_;
  80.             _loc7_.y = _loc9_.col1.y * _loc5_ + _loc9_.col2.y * -_loc6_;
  81.             (_loc7_ = m_coreVertices[0] = new b2Vec2()).x = _loc9_.col1.x * _loc20_ + _loc9_.col2.x * _loc21_;
  82.             _loc7_.y = _loc9_.col1.y * _loc20_ + _loc9_.col2.y * _loc21_;
  83.             (_loc7_ = m_coreVertices[1] = new b2Vec2()).x = _loc9_.col1.x * -_loc20_ + _loc9_.col2.x * _loc21_;
  84.             _loc7_.y = _loc9_.col1.y * -_loc20_ + _loc9_.col2.y * _loc21_;
  85.             (_loc7_ = m_coreVertices[2] = new b2Vec2()).x = _loc9_.col1.x * -_loc20_ + _loc9_.col2.x * -_loc21_;
  86.             _loc7_.y = _loc9_.col1.y * -_loc20_ + _loc9_.col2.y * -_loc21_;
  87.             (_loc7_ = m_coreVertices[3] = new b2Vec2()).x = _loc9_.col1.x * _loc20_ + _loc9_.col2.x * -_loc21_;
  88.             _loc7_.y = _loc9_.col1.y * _loc20_ + _loc9_.col2.y * -_loc21_;
  89.          }
  90.          else
  91.          {
  92.             _loc22_ = param1 as b2PolyDef;
  93.             m_vertexCount = _loc22_.vertexCount;
  94.             PolyCentroid(_loc22_.vertices,_loc22_.vertexCount,tempVec);
  95.             _loc23_ = tempVec.x;
  96.             _loc24_ = tempVec.y;
  97.             m_localCentroid.x = param1.localPosition.x + (_loc9_.col1.x * _loc23_ + _loc9_.col2.x * _loc24_) - param3.x;
  98.             m_localCentroid.y = param1.localPosition.y + (_loc9_.col1.y * _loc23_ + _loc9_.col2.y * _loc24_) - param3.y;
  99.             _loc4_ = 0;
  100.             while(_loc4_ < m_vertexCount)
  101.             {
  102.                m_vertices[_loc4_] = new b2Vec2();
  103.                m_coreVertices[_loc4_] = new b2Vec2();
  104.                _loc5_ = _loc22_.vertices[_loc4_].x - _loc23_;
  105.                _loc6_ = _loc22_.vertices[_loc4_].y - _loc24_;
  106.                m_vertices[_loc4_].x = _loc9_.col1.x * _loc5_ + _loc9_.col2.x * _loc6_;
  107.                m_vertices[_loc4_].y = _loc9_.col1.y * _loc5_ + _loc9_.col2.y * _loc6_;
  108.                _loc25_ = Number(m_vertices[_loc4_].x);
  109.                _loc26_ = Number(m_vertices[_loc4_].y);
  110.                if((_loc27_ = Math.sqrt(_loc25_ * _loc25_ + _loc26_ * _loc26_)) > Number.MIN_VALUE)
  111.                {
  112.                   _loc25_ *= 1 / _loc27_;
  113.                   _loc26_ *= 1 / _loc27_;
  114.                }
  115.                m_coreVertices[_loc4_].x = m_vertices[_loc4_].x - 2 * b2Settings.b2_linearSlop * _loc25_;
  116.                m_coreVertices[_loc4_].y = m_vertices[_loc4_].y - 2 * b2Settings.b2_linearSlop * _loc26_;
  117.                _loc4_++;
  118.             }
  119.          }
  120.          var _loc10_:Number = Number.MAX_VALUE;
  121.          var _loc11_:Number = Number.MAX_VALUE;
  122.          var _loc12_:Number = -Number.MAX_VALUE;
  123.          var _loc13_:Number = -Number.MAX_VALUE;
  124.          m_maxRadius = 0;
  125.          _loc4_ = 0;
  126.          while(_loc4_ < m_vertexCount)
  127.          {
  128.             _loc28_ = m_vertices[_loc4_];
  129.             _loc10_ = Math.min(_loc10_,_loc28_.x);
  130.             _loc11_ = Math.min(_loc11_,_loc28_.y);
  131.             _loc12_ = Math.max(_loc12_,_loc28_.x);
  132.             _loc13_ = Math.max(_loc13_,_loc28_.y);
  133.             m_maxRadius = Math.max(m_maxRadius,_loc28_.Length());
  134.             _loc4_++;
  135.          }
  136.          m_localOBB.R.SetIdentity();
  137.          m_localOBB.center.Set((_loc10_ + _loc12_) * 0.5,(_loc11_ + _loc13_) * 0.5);
  138.          m_localOBB.extents.Set((_loc12_ - _loc10_) * 0.5,(_loc13_ - _loc11_) * 0.5);
  139.          _loc4_ = 0;
  140.          while(_loc4_ < m_vertexCount)
  141.          {
  142.             m_normals[_loc4_] = new b2Vec2();
  143.             _loc14_ = _loc4_;
  144.             _loc15_ = _loc4_ + 1 < m_vertexCount ? _loc4_ + 1 : 0;
  145.             m_normals[_loc4_].x = m_vertices[_loc15_].y - m_vertices[_loc14_].y;
  146.             m_normals[_loc4_].y = -(m_vertices[_loc15_].x - m_vertices[_loc14_].x);
  147.             m_normals[_loc4_].Normalize();
  148.             _loc4_++;
  149.          }
  150.          _loc4_ = 0;
  151.          while(_loc4_ < m_vertexCount)
  152.          {
  153.             _loc14_ = _loc4_;
  154.             _loc15_ = _loc4_ + 1 < m_vertexCount ? _loc4_ + 1 : 0;
  155.             _loc4_++;
  156.          }
  157.          m_R.SetM(m_body.m_R);
  158.          m_position.x = m_body.m_position.x + (m_R.col1.x * m_localCentroid.x + m_R.col2.x * m_localCentroid.y);
  159.          m_position.y = m_body.m_position.y + (m_R.col1.y * m_localCentroid.x + m_R.col2.y * m_localCentroid.y);
  160.          tAbsR.col1.x = m_R.col1.x * m_localOBB.R.col1.x + m_R.col2.x * m_localOBB.R.col1.y;
  161.          tAbsR.col1.y = m_R.col1.y * m_localOBB.R.col1.x + m_R.col2.y * m_localOBB.R.col1.y;
  162.          tAbsR.col2.x = m_R.col1.x * m_localOBB.R.col2.x + m_R.col2.x * m_localOBB.R.col2.y;
  163.          tAbsR.col2.y = m_R.col1.y * m_localOBB.R.col2.x + m_R.col2.y * m_localOBB.R.col2.y;
  164.          tAbsR.Abs();
  165.          _loc5_ = tAbsR.col1.x * m_localOBB.extents.x + tAbsR.col2.x * m_localOBB.extents.y;
  166.          _loc6_ = tAbsR.col1.y * m_localOBB.extents.x + tAbsR.col2.y * m_localOBB.extents.y;
  167.          var _loc16_:Number = m_position.x + (m_R.col1.x * m_localOBB.center.x + m_R.col2.x * m_localOBB.center.y);
  168.          var _loc17_:Number = m_position.y + (m_R.col1.y * m_localOBB.center.x + m_R.col2.y * m_localOBB.center.y);
  169.          _loc8_.minVertex.x = _loc16_ - _loc5_;
  170.          _loc8_.minVertex.y = _loc17_ - _loc6_;
  171.          _loc8_.maxVertex.x = _loc16_ + _loc5_;
  172.          _loc8_.maxVertex.y = _loc17_ + _loc6_;
  173.          var _loc18_:b2BroadPhase;
  174.          if((_loc18_ = m_body.m_world.m_broadPhase).InRange(_loc8_))
  175.          {
  176.             m_proxyId = _loc18_.CreateProxy(_loc8_,this);
  177.          }
  178.          else
  179.          {
  180.             m_proxyId = b2Pair.b2_nullProxy;
  181.          }
  182.          if(m_proxyId == b2Pair.b2_nullProxy)
  183.          {
  184.             m_body.Freeze();
  185.          }
  186.       }
  187.       
  188.       override public function QuickSync(param1:b2Vec2, param2:b2Mat22) : void
  189.       {
  190.          m_R.SetM(param2);
  191.          m_position.x = param1.x + (param2.col1.x * m_localCentroid.x + param2.col2.x * m_localCentroid.y);
  192.          m_position.y = param1.y + (param2.col1.y * m_localCentroid.x + param2.col2.y * m_localCentroid.y);
  193.       }
  194.       
  195.       override public function Support(param1:Number, param2:Number, param3:b2Vec2) : void
  196.       {
  197.          var _loc9_:Number = NaN;
  198.          var _loc4_:Number = param1 * m_R.col1.x + param2 * m_R.col1.y;
  199.          var _loc5_:Number = param1 * m_R.col2.x + param2 * m_R.col2.y;
  200.          var _loc6_:int = 0;
  201.          var _loc7_:Number = m_coreVertices[0].x * _loc4_ + m_coreVertices[0].y * _loc5_;
  202.          var _loc8_:int = 1;
  203.          while(_loc8_ < m_vertexCount)
  204.          {
  205.             if((_loc9_ = m_coreVertices[_loc8_].x * _loc4_ + m_coreVertices[_loc8_].y * _loc5_) > _loc7_)
  206.             {
  207.                _loc6_ = _loc8_;
  208.                _loc7_ = _loc9_;
  209.             }
  210.             _loc8_++;
  211.          }
  212.          param3.Set(m_position.x + (m_R.col1.x * m_coreVertices[_loc6_].x + m_R.col2.x * m_coreVertices[_loc6_].y),m_position.y + (m_R.col1.y * m_coreVertices[_loc6_].x + m_R.col2.y * m_coreVertices[_loc6_].y));
  213.       }
  214.       
  215.       override public function Synchronize(param1:b2Vec2, param2:b2Mat22, param3:b2Vec2, param4:b2Mat22) : void
  216.       {
  217.          var _loc5_:Number = NaN;
  218.          var _loc6_:Number = NaN;
  219.          m_R.SetM(param4);
  220.          m_position.x = m_body.m_position.x + (param4.col1.x * m_localCentroid.x + param4.col2.x * m_localCentroid.y);
  221.          m_position.y = m_body.m_position.y + (param4.col1.y * m_localCentroid.x + param4.col2.y * m_localCentroid.y);
  222.          if(m_proxyId == b2Pair.b2_nullProxy)
  223.          {
  224.             return;
  225.          }
  226.          var _loc7_:b2Vec2 = param2.col1;
  227.          var _loc8_:b2Vec2 = param2.col2;
  228.          var _loc9_:b2Vec2 = m_localOBB.R.col1;
  229.          var _loc10_:b2Vec2 = m_localOBB.R.col2;
  230.          syncMat.col1.x = _loc7_.x * _loc9_.x + _loc8_.x * _loc9_.y;
  231.          syncMat.col1.y = _loc7_.y * _loc9_.x + _loc8_.y * _loc9_.y;
  232.          syncMat.col2.x = _loc7_.x * _loc10_.x + _loc8_.x * _loc10_.y;
  233.          syncMat.col2.y = _loc7_.y * _loc10_.x + _loc8_.y * _loc10_.y;
  234.          syncMat.Abs();
  235.          _loc5_ = m_localCentroid.x + m_localOBB.center.x;
  236.          _loc6_ = m_localCentroid.y + m_localOBB.center.y;
  237.          var _loc11_:Number = param1.x + (param2.col1.x * _loc5_ + param2.col2.x * _loc6_);
  238.          var _loc12_:Number = param1.y + (param2.col1.y * _loc5_ + param2.col2.y * _loc6_);
  239.          _loc5_ = syncMat.col1.x * m_localOBB.extents.x + syncMat.col2.x * m_localOBB.extents.y;
  240.          _loc6_ = syncMat.col1.y * m_localOBB.extents.x + syncMat.col2.y * m_localOBB.extents.y;
  241.          syncAABB.minVertex.x = _loc11_ - _loc5_;
  242.          syncAABB.minVertex.y = _loc12_ - _loc6_;
  243.          syncAABB.maxVertex.x = _loc11_ + _loc5_;
  244.          syncAABB.maxVertex.y = _loc12_ + _loc6_;
  245.          _loc7_ = param4.col1;
  246.          _loc8_ = param4.col2;
  247.          _loc9_ = m_localOBB.R.col1;
  248.          _loc10_ = m_localOBB.R.col2;
  249.          syncMat.col1.x = _loc7_.x * _loc9_.x + _loc8_.x * _loc9_.y;
  250.          syncMat.col1.y = _loc7_.y * _loc9_.x + _loc8_.y * _loc9_.y;
  251.          syncMat.col2.x = _loc7_.x * _loc10_.x + _loc8_.x * _loc10_.y;
  252.          syncMat.col2.y = _loc7_.y * _loc10_.x + _loc8_.y * _loc10_.y;
  253.          syncMat.Abs();
  254.          _loc5_ = m_localCentroid.x + m_localOBB.center.x;
  255.          _loc6_ = m_localCentroid.y + m_localOBB.center.y;
  256.          _loc11_ = param3.x + (param4.col1.x * _loc5_ + param4.col2.x * _loc6_);
  257.          _loc12_ = param3.y + (param4.col1.y * _loc5_ + param4.col2.y * _loc6_);
  258.          _loc5_ = syncMat.col1.x * m_localOBB.extents.x + syncMat.col2.x * m_localOBB.extents.y;
  259.          _loc6_ = syncMat.col1.y * m_localOBB.extents.x + syncMat.col2.y * m_localOBB.extents.y;
  260.          syncAABB.minVertex.x = Math.min(syncAABB.minVertex.x,_loc11_ - _loc5_);
  261.          syncAABB.minVertex.y = Math.min(syncAABB.minVertex.y,_loc12_ - _loc6_);
  262.          syncAABB.maxVertex.x = Math.max(syncAABB.maxVertex.x,_loc11_ + _loc5_);
  263.          syncAABB.maxVertex.y = Math.max(syncAABB.maxVertex.y,_loc12_ + _loc6_);
  264.          var _loc13_:b2BroadPhase;
  265.          if((_loc13_ = m_body.m_world.m_broadPhase).InRange(syncAABB))
  266.          {
  267.             _loc13_.MoveProxy(m_proxyId,syncAABB);
  268.          }
  269.          else
  270.          {
  271.             m_body.Freeze();
  272.          }
  273.       }
  274.       
  275.       override public function TestPoint(param1:b2Vec2) : Boolean
  276.       {
  277.          var _loc4_:b2Vec2 = null;
  278.          var _loc5_:Number = NaN;
  279.          var _loc2_:b2Vec2 = new b2Vec2();
  280.          _loc2_.SetV(param1);
  281.          _loc2_.Subtract(m_position);
  282.          _loc2_.MulTM(m_R);
  283.          var _loc3_:int = 0;
  284.          while(_loc3_ < m_vertexCount)
  285.          {
  286.             (_loc4_ = new b2Vec2()).SetV(_loc2_);
  287.             _loc4_.Subtract(m_vertices[_loc3_]);
  288.             if((_loc5_ = b2Math.b2Dot(m_normals[_loc3_],_loc4_)) > 0)
  289.             {
  290.                return false;
  291.             }
  292.             _loc3_++;
  293.          }
  294.          return true;
  295.       }
  296.       
  297.       override public function ResetProxy(param1:b2BroadPhase) : void
  298.       {
  299.          if(m_proxyId == b2Pair.b2_nullProxy)
  300.          {
  301.             return;
  302.          }
  303.          var _loc2_:b2Proxy = param1.GetProxy(m_proxyId);
  304.          param1.DestroyProxy(m_proxyId);
  305.          _loc2_ = null;
  306.          var _loc3_:b2Mat22 = b2Math.b2MulMM(m_R,m_localOBB.R);
  307.          var _loc4_:b2Mat22 = b2Math.b2AbsM(_loc3_);
  308.          var _loc5_:b2Vec2 = b2Math.b2MulMV(_loc4_,m_localOBB.extents);
  309.          var _loc6_:b2Vec2;
  310.          (_loc6_ = b2Math.b2MulMV(m_R,m_localOBB.center)).Add(m_position);
  311.          var _loc7_:b2AABB;
  312.          (_loc7_ = new b2AABB()).minVertex.SetV(_loc6_);
  313.          _loc7_.minVertex.Subtract(_loc5_);
  314.          _loc7_.maxVertex.SetV(_loc6_);
  315.          _loc7_.maxVertex.Add(_loc5_);
  316.          if(param1.InRange(_loc7_))
  317.          {
  318.             m_proxyId = param1.CreateProxy(_loc7_,this);
  319.          }
  320.          else
  321.          {
  322.             m_proxyId = b2Pair.b2_nullProxy;
  323.          }
  324.          if(m_proxyId == b2Pair.b2_nullProxy)
  325.          {
  326.             m_body.Freeze();
  327.          }
  328.       }
  329.    }
  330. }
  331.