mirror of
https://github.com/burrow-dev/burrow-server.git
synced 2026-11-20 17:37:50 -05:00
Brought up to date with the private repository (feea4c7)
This commit is contained in:
1 parent
1aa738d692
commit
1b1df1ae48
7925 files changed
+2617237
-20
No files matched your search
@@ -0,0 +1,18 @@
|
||||
package Box2D.Collision
|
||||
{
|
||||
import Box2D.Common.Math.b2Vec2;
|
||||
|
||||
public class ClipVertex
|
||||
{
|
||||
|
||||
public var v:b2Vec2 = new b2Vec2();
|
||||
|
||||
public var id:b2ContactID = new b2ContactID();
|
||||
|
||||
public function ClipVertex()
|
||||
{
|
||||
super();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,66 @@
|
||||
package Box2D.Collision
|
||||
{
|
||||
public class Features
|
||||
{
|
||||
|
||||
public var _referenceEdge:int;
|
||||
|
||||
public var _incidentEdge:int;
|
||||
|
||||
public var _incidentVertex:int;
|
||||
|
||||
public var _flip:int;
|
||||
|
||||
public var _m_id:b2ContactID;
|
||||
|
||||
public function Features()
|
||||
{
|
||||
super();
|
||||
}
|
||||
|
||||
public function set referenceEdge(param1:int) : void
|
||||
{
|
||||
_referenceEdge = param1;
|
||||
_m_id._key = _m_id._key & 0xFFFFFF00 | _referenceEdge & 0xFF;
|
||||
}
|
||||
|
||||
public function get referenceEdge() : int
|
||||
{
|
||||
return _referenceEdge;
|
||||
}
|
||||
|
||||
public function set incidentEdge(param1:int) : void
|
||||
{
|
||||
_incidentEdge = param1;
|
||||
_m_id._key = _m_id._key & 0xFFFF00FF | _incidentEdge << 8 & 0xFF00;
|
||||
}
|
||||
|
||||
public function get incidentEdge() : int
|
||||
{
|
||||
return _incidentEdge;
|
||||
}
|
||||
|
||||
public function set incidentVertex(param1:int) : void
|
||||
{
|
||||
_incidentVertex = param1;
|
||||
_m_id._key = _m_id._key & 0xFF00FFFF | _incidentVertex << 16 & 0xFF0000;
|
||||
}
|
||||
|
||||
public function get incidentVertex() : int
|
||||
{
|
||||
return _incidentVertex;
|
||||
}
|
||||
|
||||
public function set flip(param1:int) : void
|
||||
{
|
||||
_flip = param1;
|
||||
_m_id._key = _m_id._key & 0xFFFFFF | _flip << 24 & 0xFF000000;
|
||||
}
|
||||
|
||||
public function get flip() : int
|
||||
{
|
||||
return _flip;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,20 @@
|
||||
package Box2D.Collision.Shapes
|
||||
{
|
||||
import Box2D.Common.Math.b2Vec2;
|
||||
|
||||
public class b2CircleDef extends b2ShapeDef
|
||||
{
|
||||
|
||||
public var localPosition:b2Vec2 = new b2Vec2(0,0);
|
||||
|
||||
public var radius:Number;
|
||||
|
||||
public function b2CircleDef()
|
||||
{
|
||||
super();
|
||||
type = 0;
|
||||
radius = 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,116 @@
|
||||
package Box2D.Collision.Shapes
|
||||
{
|
||||
import Box2D.Collision.*;
|
||||
import Box2D.Common.*;
|
||||
import Box2D.Common.Math.*;
|
||||
import Box2D.Dynamics.*;
|
||||
|
||||
public class b2CircleShape extends b2Shape
|
||||
{
|
||||
|
||||
public var m_localPosition:b2Vec2 = new b2Vec2();
|
||||
|
||||
public var m_radius:Number;
|
||||
|
||||
public function b2CircleShape(param1:b2ShapeDef)
|
||||
{
|
||||
super(param1);
|
||||
var _loc2_:b2CircleDef = param1 as b2CircleDef;
|
||||
m_type = 0;
|
||||
m_localPosition.SetV(_loc2_.localPosition);
|
||||
m_radius = _loc2_.radius;
|
||||
}
|
||||
|
||||
override public function TestPoint(param1:b2XForm, param2:b2Vec2) : Boolean
|
||||
{
|
||||
var _loc3_:b2Mat22 = param1.R;
|
||||
var _loc5_:Number = param1.position.x + (_loc3_.col1.x * m_localPosition.x + _loc3_.col2.x * m_localPosition.y);
|
||||
var _loc4_:Number = param1.position.y + (_loc3_.col1.y * m_localPosition.x + _loc3_.col2.y * m_localPosition.y);
|
||||
_loc5_ = param2.x - _loc5_;
|
||||
_loc4_ = param2.y - _loc4_;
|
||||
return _loc5_ * _loc5_ + _loc4_ * _loc4_ <= m_radius * m_radius;
|
||||
}
|
||||
|
||||
override public function TestSegment(param1:b2XForm, param2:Array, param3:b2Vec2, param4:b2Segment, param5:Number) : Boolean
|
||||
{
|
||||
var _loc11_:b2Mat22 = param1.R;
|
||||
var _loc12_:Number = param1.position.x + (_loc11_.col1.x * m_localPosition.x + _loc11_.col2.x * m_localPosition.y);
|
||||
var _loc9_:Number = param1.position.y + (_loc11_.col1.y * m_localPosition.x + _loc11_.col2.y * m_localPosition.y);
|
||||
var _loc16_:Number = param4.p1.x - _loc12_;
|
||||
var _loc17_:Number = param4.p1.y - _loc9_;
|
||||
var _loc6_:Number = _loc16_ * _loc16_ + _loc17_ * _loc17_ - m_radius * m_radius;
|
||||
if(_loc6_ < 0)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
var _loc14_:Number = param4.p2.x - param4.p1.x;
|
||||
var _loc15_:Number = param4.p2.y - param4.p1.y;
|
||||
var _loc7_:Number = _loc16_ * _loc14_ + _loc17_ * _loc15_;
|
||||
var _loc13_:Number = _loc14_ * _loc14_ + _loc15_ * _loc15_;
|
||||
var _loc10_:Number = _loc7_ * _loc7_ - _loc13_ * _loc6_;
|
||||
if(_loc10_ < 0 || _loc13_ < Number.MIN_VALUE)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
var _loc8_:Number = -(_loc7_ + Math.sqrt(_loc10_));
|
||||
if(0 <= _loc8_ && _loc8_ <= param5 * _loc13_)
|
||||
{
|
||||
_loc8_ /= _loc13_;
|
||||
param2[0] = _loc8_;
|
||||
param3.x = _loc16_ + _loc8_ * _loc14_;
|
||||
param3.y = _loc17_ + _loc8_ * _loc15_;
|
||||
param3.Normalize();
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
override public function ComputeAABB(param1:b2AABB, param2:b2XForm) : void
|
||||
{
|
||||
var _loc3_:b2Mat22 = param2.R;
|
||||
var _loc5_:Number = param2.position.x + (_loc3_.col1.x * m_localPosition.x + _loc3_.col2.x * m_localPosition.y);
|
||||
var _loc4_:Number = param2.position.y + (_loc3_.col1.y * m_localPosition.x + _loc3_.col2.y * m_localPosition.y);
|
||||
param1.lowerBound.Set(_loc5_ - m_radius,_loc4_ - m_radius);
|
||||
param1.upperBound.Set(_loc5_ + m_radius,_loc4_ + m_radius);
|
||||
}
|
||||
|
||||
override public function ComputeSweptAABB(param1:b2AABB, param2:b2XForm, param3:b2XForm) : void
|
||||
{
|
||||
var _loc7_:b2Mat22 = null;
|
||||
_loc7_ = param2.R;
|
||||
var _loc4_:Number = param2.position.x + (_loc7_.col1.x * m_localPosition.x + _loc7_.col2.x * m_localPosition.y);
|
||||
var _loc8_:Number = param2.position.y + (_loc7_.col1.y * m_localPosition.x + _loc7_.col2.y * m_localPosition.y);
|
||||
_loc7_ = param3.R;
|
||||
var _loc6_:Number = param3.position.x + (_loc7_.col1.x * m_localPosition.x + _loc7_.col2.x * m_localPosition.y);
|
||||
var _loc5_:Number = param3.position.y + (_loc7_.col1.y * m_localPosition.x + _loc7_.col2.y * m_localPosition.y);
|
||||
param1.lowerBound.Set((_loc4_ < _loc6_ ? _loc4_ : _loc6_) - m_radius,(_loc8_ < _loc5_ ? _loc8_ : _loc5_) - m_radius);
|
||||
param1.upperBound.Set((_loc4_ > _loc6_ ? _loc4_ : _loc6_) + m_radius,(_loc8_ > _loc5_ ? _loc8_ : _loc5_) + m_radius);
|
||||
}
|
||||
|
||||
override public function ComputeMass(param1:b2MassData) : void
|
||||
{
|
||||
param1.mass = m_density * 3.141592653589793 * m_radius * m_radius;
|
||||
param1.center.SetV(m_localPosition);
|
||||
param1.I = param1.mass * (0.5 * m_radius * m_radius + (m_localPosition.x * m_localPosition.x + m_localPosition.y * m_localPosition.y));
|
||||
}
|
||||
|
||||
public function GetLocalPosition() : b2Vec2
|
||||
{
|
||||
return m_localPosition;
|
||||
}
|
||||
|
||||
public function GetRadius() : Number
|
||||
{
|
||||
return m_radius;
|
||||
}
|
||||
|
||||
override public function UpdateSweepRadius(param1:b2Vec2) : void
|
||||
{
|
||||
var _loc3_:Number = m_localPosition.x - param1.x;
|
||||
var _loc2_:Number = m_localPosition.y - param1.y;
|
||||
_loc3_ = Math.sqrt(_loc3_ * _loc3_ + _loc2_ * _loc2_);
|
||||
m_sweepRadius = _loc3_ + m_radius - 0.04;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,27 @@
|
||||
package Box2D.Collision.Shapes
|
||||
{
|
||||
public class b2FilterData
|
||||
{
|
||||
|
||||
public var categoryBits:uint = 1;
|
||||
|
||||
public var maskBits:uint = 65535;
|
||||
|
||||
public var groupIndex:int = 0;
|
||||
|
||||
public function b2FilterData()
|
||||
{
|
||||
super();
|
||||
}
|
||||
|
||||
public function Copy() : b2FilterData
|
||||
{
|
||||
var _loc1_:b2FilterData = new b2FilterData();
|
||||
_loc1_.categoryBits = categoryBits;
|
||||
_loc1_.maskBits = maskBits;
|
||||
_loc1_.groupIndex = groupIndex;
|
||||
return _loc1_;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,20 @@
|
||||
package Box2D.Collision.Shapes
|
||||
{
|
||||
import Box2D.Common.Math.b2Vec2;
|
||||
|
||||
public class b2MassData
|
||||
{
|
||||
|
||||
public var mass:Number = 0;
|
||||
|
||||
public var center:b2Vec2 = new b2Vec2(0,0);
|
||||
|
||||
public var I:Number = 0;
|
||||
|
||||
public function b2MassData()
|
||||
{
|
||||
super();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,66 @@
|
||||
package Box2D.Collision.Shapes
|
||||
{
|
||||
import Box2D.Common.*;
|
||||
import Box2D.Common.Math.*;
|
||||
|
||||
public class b2PolygonDef extends b2ShapeDef
|
||||
{
|
||||
|
||||
private static var s_mat:b2Mat22 = new b2Mat22();
|
||||
|
||||
public var vertices:Array = new Array(8);
|
||||
|
||||
public var vertexCount:int;
|
||||
|
||||
public function b2PolygonDef()
|
||||
{
|
||||
var _loc1_:int = 0;
|
||||
super();
|
||||
type = 1;
|
||||
vertexCount = 0;
|
||||
_loc1_ = 0;
|
||||
while(_loc1_ < 8)
|
||||
{
|
||||
vertices[_loc1_] = new b2Vec2();
|
||||
_loc1_++;
|
||||
}
|
||||
}
|
||||
|
||||
public function SetAsBox(param1:Number, param2:Number) : void
|
||||
{
|
||||
vertexCount = 4;
|
||||
vertices[0].Set(-param1,-param2);
|
||||
vertices[1].Set(param1,-param2);
|
||||
vertices[2].Set(param1,param2);
|
||||
vertices[3].Set(-param1,param2);
|
||||
}
|
||||
|
||||
public function SetAsOrientedBox(param1:Number, param2:Number, param3:b2Vec2 = null, param4:Number = 0) : void
|
||||
{
|
||||
var _loc6_:b2Vec2 = null;
|
||||
var _loc5_:b2Mat22 = null;
|
||||
var _loc7_:int = 0;
|
||||
vertexCount = 4;
|
||||
vertices[0].Set(-param1,-param2);
|
||||
vertices[1].Set(param1,-param2);
|
||||
vertices[2].Set(param1,param2);
|
||||
vertices[3].Set(-param1,param2);
|
||||
if(param3)
|
||||
{
|
||||
_loc6_ = param3;
|
||||
_loc5_ = s_mat;
|
||||
_loc5_.Set(param4);
|
||||
_loc7_ = 0;
|
||||
while(_loc7_ < vertexCount)
|
||||
{
|
||||
param3 = vertices[_loc7_];
|
||||
param1 = _loc6_.x + (_loc5_.col1.x * param3.x + _loc5_.col2.x * param3.y);
|
||||
param3.y = _loc6_.y + (_loc5_.col1.y * param3.x + _loc5_.col2.y * param3.y);
|
||||
param3.x = param1;
|
||||
_loc7_++;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,492 @@
|
||||
package Box2D.Collision.Shapes
|
||||
{
|
||||
import Box2D.Collision.*;
|
||||
import Box2D.Common.*;
|
||||
import Box2D.Common.Math.*;
|
||||
import Box2D.Dynamics.*;
|
||||
|
||||
public class b2PolygonShape extends b2Shape
|
||||
{
|
||||
|
||||
private static var s_computeMat:b2Mat22 = new b2Mat22();
|
||||
|
||||
private static var s_sweptAABB1:b2AABB = new b2AABB();
|
||||
|
||||
private static var s_sweptAABB2:b2AABB = new b2AABB();
|
||||
|
||||
private var s_supportVec:b2Vec2 = new b2Vec2();
|
||||
|
||||
public var m_centroid:b2Vec2;
|
||||
|
||||
public var m_obb:b2OBB = new b2OBB();
|
||||
|
||||
public var m_vertices:Array = new Array(8);
|
||||
|
||||
public var m_normals:Array = new Array(8);
|
||||
|
||||
public var m_coreVertices:Array = new Array(8);
|
||||
|
||||
public var m_vertexCount:int;
|
||||
|
||||
public function b2PolygonShape(param1:b2ShapeDef)
|
||||
{
|
||||
var _loc7_:int = 0;
|
||||
var _loc17_:Number = NaN;
|
||||
var _loc10_:Number = NaN;
|
||||
var _loc6_:Number = NaN;
|
||||
var _loc12_:Number = NaN;
|
||||
var _loc11_:Number = NaN;
|
||||
var _loc13_:Number = NaN;
|
||||
var _loc14_:Number = NaN;
|
||||
var _loc9_:Number = NaN;
|
||||
var _loc8_:Number = NaN;
|
||||
var _loc5_:Number = NaN;
|
||||
var _loc4_:Number = NaN;
|
||||
var _loc2_:Number = NaN;
|
||||
super(param1);
|
||||
m_type = 1;
|
||||
var _loc3_:b2PolygonDef = param1 as b2PolygonDef;
|
||||
m_vertexCount = _loc3_.vertexCount;
|
||||
var _loc16_:int = _loc7_;
|
||||
var _loc15_:int = _loc7_;
|
||||
_loc7_ = 0;
|
||||
while(_loc7_ < m_vertexCount)
|
||||
{
|
||||
m_vertices[_loc7_] = _loc3_.vertices[_loc7_].Copy();
|
||||
_loc7_++;
|
||||
}
|
||||
_loc7_ = 0;
|
||||
while(_loc7_ < m_vertexCount)
|
||||
{
|
||||
_loc16_ = _loc7_;
|
||||
_loc15_ = _loc7_ + 1 < m_vertexCount ? _loc7_ + 1 : 0;
|
||||
_loc17_ = m_vertices[_loc15_].x - m_vertices[_loc16_].x;
|
||||
_loc10_ = m_vertices[_loc15_].y - m_vertices[_loc16_].y;
|
||||
_loc6_ = Math.sqrt(_loc17_ * _loc17_ + _loc10_ * _loc10_);
|
||||
m_normals[_loc7_] = new b2Vec2(_loc10_ / _loc6_,-_loc17_ / _loc6_);
|
||||
_loc7_++;
|
||||
}
|
||||
m_centroid = ComputeCentroid(_loc3_.vertices,_loc3_.vertexCount);
|
||||
ComputeOBB(m_obb,m_vertices,m_vertexCount);
|
||||
_loc7_ = 0;
|
||||
while(_loc7_ < m_vertexCount)
|
||||
{
|
||||
_loc16_ = _loc7_ - 1 >= 0 ? _loc7_ - 1 : m_vertexCount - 1;
|
||||
_loc15_ = _loc7_;
|
||||
_loc12_ = Number(m_normals[_loc16_].x);
|
||||
_loc11_ = Number(m_normals[_loc16_].y);
|
||||
_loc13_ = Number(m_normals[_loc15_].x);
|
||||
_loc14_ = Number(m_normals[_loc15_].y);
|
||||
_loc9_ = m_vertices[_loc7_].x - m_centroid.x;
|
||||
_loc8_ = m_vertices[_loc7_].y - m_centroid.y;
|
||||
_loc5_ = _loc12_ * _loc9_ + _loc11_ * _loc8_ - 0.04;
|
||||
_loc4_ = _loc13_ * _loc9_ + _loc14_ * _loc8_ - 0.04;
|
||||
_loc2_ = 1 / (_loc12_ * _loc14_ - _loc11_ * _loc13_);
|
||||
m_coreVertices[_loc7_] = new b2Vec2(_loc2_ * (_loc14_ * _loc5_ - _loc11_ * _loc4_) + m_centroid.x,_loc2_ * (_loc12_ * _loc4_ - _loc13_ * _loc5_) + m_centroid.y);
|
||||
_loc7_++;
|
||||
}
|
||||
}
|
||||
|
||||
public static function ComputeCentroid(param1:Array, param2:int) : b2Vec2
|
||||
{
|
||||
var _loc12_:int = 0;
|
||||
var _loc8_:b2Vec2 = null;
|
||||
var _loc6_:b2Vec2 = null;
|
||||
var _loc5_:Number = NaN;
|
||||
var _loc4_:Number = NaN;
|
||||
var _loc9_:Number = NaN;
|
||||
var _loc11_:Number = NaN;
|
||||
var _loc3_:Number = NaN;
|
||||
var _loc15_:Number = NaN;
|
||||
var _loc7_:b2Vec2 = new b2Vec2();
|
||||
var _loc14_:Number = 0;
|
||||
var _loc13_:Number = 0;
|
||||
var _loc16_:Number = 0;
|
||||
var _loc10_:Number = 0.3333333333333333;
|
||||
_loc12_ = 0;
|
||||
while(_loc12_ < param2)
|
||||
{
|
||||
_loc8_ = param1[_loc12_];
|
||||
_loc6_ = _loc12_ + 1 < param2 ? param1[int(_loc12_ + 1)] : param1[0];
|
||||
_loc5_ = _loc8_.x - _loc13_;
|
||||
_loc4_ = _loc8_.y - _loc16_;
|
||||
_loc9_ = _loc6_.x - _loc13_;
|
||||
_loc11_ = _loc6_.y - _loc16_;
|
||||
_loc3_ = _loc5_ * _loc11_ - _loc4_ * _loc9_;
|
||||
_loc15_ = 0.5 * _loc3_;
|
||||
_loc14_ += _loc15_;
|
||||
_loc7_.x += _loc15_ * _loc10_ * (_loc13_ + _loc8_.x + _loc6_.x);
|
||||
_loc7_.y += _loc15_ * _loc10_ * (_loc16_ + _loc8_.y + _loc6_.y);
|
||||
_loc12_++;
|
||||
}
|
||||
_loc7_.x *= 1 / _loc14_;
|
||||
_loc7_.y *= 1 / _loc14_;
|
||||
return _loc7_;
|
||||
}
|
||||
|
||||
public static function ComputeOBB(param1:b2OBB, param2:Array, param3:int) : void
|
||||
{
|
||||
var _loc21_:int = 0;
|
||||
var _loc4_:b2Vec2 = null;
|
||||
var _loc16_:Number = NaN;
|
||||
var _loc17_:Number = NaN;
|
||||
var _loc13_:Number = NaN;
|
||||
var _loc5_:Number = NaN;
|
||||
var _loc6_:Number = NaN;
|
||||
var _loc22_:Number = NaN;
|
||||
var _loc25_:Number = NaN;
|
||||
var _loc12_:Number = NaN;
|
||||
var _loc10_:Number = NaN;
|
||||
var _loc20_:int = 0;
|
||||
var _loc19_:Number = NaN;
|
||||
var _loc18_:Number = NaN;
|
||||
var _loc14_:Number = NaN;
|
||||
var _loc15_:Number = NaN;
|
||||
var _loc7_:Number = NaN;
|
||||
var _loc9_:Number = NaN;
|
||||
var _loc8_:Number = NaN;
|
||||
var _loc23_:b2Mat22 = null;
|
||||
var _loc24_:Array = new Array(8 + 1);
|
||||
_loc21_ = 0;
|
||||
while(_loc21_ < param3)
|
||||
{
|
||||
_loc24_[_loc21_] = param2[_loc21_];
|
||||
_loc21_++;
|
||||
}
|
||||
_loc24_[param3] = _loc24_[0];
|
||||
var _loc11_:Number = 1.7976931348623157e+308;
|
||||
_loc21_ = 1;
|
||||
while(_loc21_ <= param3)
|
||||
{
|
||||
_loc4_ = _loc24_[int(_loc21_ - 1)];
|
||||
_loc16_ = _loc24_[_loc21_].x - _loc4_.x;
|
||||
_loc17_ = _loc24_[_loc21_].y - _loc4_.y;
|
||||
_loc13_ = Math.sqrt(_loc16_ * _loc16_ + _loc17_ * _loc17_);
|
||||
_loc16_ /= _loc13_;
|
||||
_loc17_ /= _loc13_;
|
||||
_loc5_ = -_loc17_;
|
||||
_loc6_ = _loc16_;
|
||||
_loc22_ = 1.7976931348623157e+308;
|
||||
_loc25_ = 1.7976931348623157e+308;
|
||||
_loc12_ = -1.7976931348623157e+308;
|
||||
_loc10_ = -1.7976931348623157e+308;
|
||||
_loc20_ = 0;
|
||||
while(_loc20_ < param3)
|
||||
{
|
||||
_loc19_ = _loc24_[_loc20_].x - _loc4_.x;
|
||||
_loc18_ = _loc24_[_loc20_].y - _loc4_.y;
|
||||
_loc14_ = _loc16_ * _loc19_ + _loc17_ * _loc18_;
|
||||
_loc15_ = _loc5_ * _loc19_ + _loc6_ * _loc18_;
|
||||
if(_loc14_ < _loc22_)
|
||||
{
|
||||
_loc22_ = _loc14_;
|
||||
}
|
||||
if(_loc15_ < _loc25_)
|
||||
{
|
||||
_loc25_ = _loc15_;
|
||||
}
|
||||
if(_loc14_ > _loc12_)
|
||||
{
|
||||
_loc12_ = _loc14_;
|
||||
}
|
||||
if(_loc15_ > _loc10_)
|
||||
{
|
||||
_loc10_ = _loc15_;
|
||||
}
|
||||
_loc20_++;
|
||||
}
|
||||
_loc7_ = (_loc12_ - _loc22_) * (_loc10_ - _loc25_);
|
||||
if(_loc7_ < 0.95 * _loc11_)
|
||||
{
|
||||
_loc11_ = _loc7_;
|
||||
param1.R.col1.x = _loc16_;
|
||||
param1.R.col1.y = _loc17_;
|
||||
param1.R.col2.x = _loc5_;
|
||||
param1.R.col2.y = _loc6_;
|
||||
_loc9_ = 0.5 * (_loc22_ + _loc12_);
|
||||
_loc8_ = 0.5 * (_loc25_ + _loc10_);
|
||||
_loc23_ = param1.R;
|
||||
param1.center.x = _loc4_.x + (_loc23_.col1.x * _loc9_ + _loc23_.col2.x * _loc8_);
|
||||
param1.center.y = _loc4_.y + (_loc23_.col1.y * _loc9_ + _loc23_.col2.y * _loc8_);
|
||||
param1.extents.x = 0.5 * (_loc12_ - _loc22_);
|
||||
param1.extents.y = 0.5 * (_loc10_ - _loc25_);
|
||||
}
|
||||
_loc21_++;
|
||||
}
|
||||
}
|
||||
|
||||
override public function TestPoint(param1:b2XForm, param2:b2Vec2) : Boolean
|
||||
{
|
||||
var _loc8_:b2Vec2 = null;
|
||||
var _loc9_:int = 0;
|
||||
var _loc6_:Number = NaN;
|
||||
var _loc5_:b2Mat22 = param1.R;
|
||||
var _loc7_:Number = param2.x - param1.position.x;
|
||||
var _loc10_:Number = param2.y - param1.position.y;
|
||||
var _loc4_:Number = _loc7_ * _loc5_.col1.x + _loc10_ * _loc5_.col1.y;
|
||||
var _loc3_:Number = _loc7_ * _loc5_.col2.x + _loc10_ * _loc5_.col2.y;
|
||||
_loc9_ = 0;
|
||||
while(_loc9_ < m_vertexCount)
|
||||
{
|
||||
_loc8_ = m_vertices[_loc9_];
|
||||
_loc7_ = _loc4_ - _loc8_.x;
|
||||
_loc10_ = _loc3_ - _loc8_.y;
|
||||
_loc8_ = m_normals[_loc9_];
|
||||
_loc6_ = _loc8_.x * _loc7_ + _loc8_.y * _loc10_;
|
||||
if(_loc6_ > 0)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
_loc9_++;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
override public function TestSegment(param1:b2XForm, param2:Array, param3:b2Vec2, param4:b2Segment, param5:Number) : Boolean
|
||||
{
|
||||
var _loc20_:Number = NaN;
|
||||
var _loc21_:Number = NaN;
|
||||
var _loc18_:b2Mat22 = null;
|
||||
var _loc12_:b2Vec2 = null;
|
||||
var _loc13_:int = 0;
|
||||
var _loc9_:Number = NaN;
|
||||
var _loc8_:Number = NaN;
|
||||
var _loc7_:Number = 0;
|
||||
var _loc14_:Number = param5;
|
||||
_loc20_ = param4.p1.x - param1.position.x;
|
||||
_loc21_ = param4.p1.y - param1.position.y;
|
||||
_loc18_ = param1.R;
|
||||
var _loc15_:Number = _loc20_ * _loc18_.col1.x + _loc21_ * _loc18_.col1.y;
|
||||
var _loc19_:Number = _loc20_ * _loc18_.col2.x + _loc21_ * _loc18_.col2.y;
|
||||
_loc20_ = param4.p2.x - param1.position.x;
|
||||
_loc21_ = param4.p2.y - param1.position.y;
|
||||
_loc18_ = param1.R;
|
||||
var _loc17_:Number = _loc20_ * _loc18_.col1.x + _loc21_ * _loc18_.col1.y;
|
||||
var _loc16_:Number = _loc20_ * _loc18_.col2.x + _loc21_ * _loc18_.col2.y;
|
||||
var _loc11_:Number = _loc17_ - _loc15_;
|
||||
var _loc10_:Number = _loc16_ - _loc19_;
|
||||
var _loc6_:* = -1;
|
||||
_loc13_ = 0;
|
||||
while(_loc13_ < m_vertexCount)
|
||||
{
|
||||
_loc12_ = m_vertices[_loc13_];
|
||||
_loc20_ = _loc12_.x - _loc15_;
|
||||
_loc21_ = _loc12_.y - _loc19_;
|
||||
_loc12_ = m_normals[_loc13_];
|
||||
_loc9_ = _loc12_.x * _loc20_ + _loc12_.y * _loc21_;
|
||||
_loc8_ = _loc12_.x * _loc11_ + _loc12_.y * _loc10_;
|
||||
if(_loc8_ < 0 && _loc9_ < _loc7_ * _loc8_)
|
||||
{
|
||||
_loc7_ = _loc9_ / _loc8_;
|
||||
_loc6_ = _loc13_;
|
||||
}
|
||||
else if(_loc8_ > 0 && _loc9_ < _loc14_ * _loc8_)
|
||||
{
|
||||
_loc14_ = _loc9_ / _loc8_;
|
||||
}
|
||||
if(_loc14_ < _loc7_)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
_loc13_++;
|
||||
}
|
||||
if(_loc6_ >= 0)
|
||||
{
|
||||
param2[0] = _loc7_;
|
||||
_loc18_ = param1.R;
|
||||
_loc12_ = m_normals[_loc6_];
|
||||
param3.x = _loc18_.col1.x * _loc12_.x + _loc18_.col2.x * _loc12_.y;
|
||||
param3.y = _loc18_.col1.y * _loc12_.x + _loc18_.col2.y * _loc12_.y;
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
override public function ComputeAABB(param1:b2AABB, param2:b2XForm) : void
|
||||
{
|
||||
var _loc5_:b2Mat22 = null;
|
||||
var _loc10_:b2Vec2 = null;
|
||||
var _loc7_:b2Mat22 = s_computeMat;
|
||||
_loc5_ = param2.R;
|
||||
_loc10_ = m_obb.R.col1;
|
||||
_loc7_.col1.x = _loc5_.col1.x * _loc10_.x + _loc5_.col2.x * _loc10_.y;
|
||||
_loc7_.col1.y = _loc5_.col1.y * _loc10_.x + _loc5_.col2.y * _loc10_.y;
|
||||
_loc10_ = m_obb.R.col2;
|
||||
_loc7_.col2.x = _loc5_.col1.x * _loc10_.x + _loc5_.col2.x * _loc10_.y;
|
||||
_loc7_.col2.y = _loc5_.col1.y * _loc10_.x + _loc5_.col2.y * _loc10_.y;
|
||||
_loc7_.Abs();
|
||||
var _loc9_:b2Mat22 = _loc7_;
|
||||
_loc10_ = m_obb.extents;
|
||||
var _loc4_:Number = _loc9_.col1.x * _loc10_.x + _loc9_.col2.x * _loc10_.y;
|
||||
var _loc6_:Number = _loc9_.col1.y * _loc10_.x + _loc9_.col2.y * _loc10_.y;
|
||||
_loc5_ = param2.R;
|
||||
_loc10_ = m_obb.center;
|
||||
var _loc3_:Number = param2.position.x + (_loc5_.col1.x * _loc10_.x + _loc5_.col2.x * _loc10_.y);
|
||||
var _loc8_:Number = param2.position.y + (_loc5_.col1.y * _loc10_.x + _loc5_.col2.y * _loc10_.y);
|
||||
param1.lowerBound.Set(_loc3_ - _loc4_,_loc8_ - _loc6_);
|
||||
param1.upperBound.Set(_loc3_ + _loc4_,_loc8_ + _loc6_);
|
||||
}
|
||||
|
||||
override public function ComputeSweptAABB(param1:b2AABB, param2:b2XForm, param3:b2XForm) : void
|
||||
{
|
||||
var _loc4_:b2AABB = s_sweptAABB1;
|
||||
var _loc5_:b2AABB = s_sweptAABB2;
|
||||
ComputeAABB(_loc4_,param2);
|
||||
ComputeAABB(_loc5_,param3);
|
||||
param1.lowerBound.Set(_loc4_.lowerBound.x < _loc5_.lowerBound.x ? _loc4_.lowerBound.x : _loc5_.lowerBound.x,_loc4_.lowerBound.y < _loc5_.lowerBound.y ? _loc4_.lowerBound.y : _loc5_.lowerBound.y);
|
||||
param1.upperBound.Set(_loc4_.upperBound.x > _loc5_.upperBound.x ? _loc4_.upperBound.x : _loc5_.upperBound.x,_loc4_.upperBound.y > _loc5_.upperBound.y ? _loc4_.upperBound.y : _loc5_.upperBound.y);
|
||||
}
|
||||
|
||||
override public function ComputeMass(param1:b2MassData) : void
|
||||
{
|
||||
var _loc15_:int = 0;
|
||||
var _loc7_:b2Vec2 = null;
|
||||
var _loc6_:b2Vec2 = null;
|
||||
var _loc4_:Number = NaN;
|
||||
var _loc3_:Number = NaN;
|
||||
var _loc11_:Number = NaN;
|
||||
var _loc14_:Number = NaN;
|
||||
var _loc2_:Number = NaN;
|
||||
var _loc22_:Number = NaN;
|
||||
var _loc19_:Number = NaN;
|
||||
var _loc21_:Number = NaN;
|
||||
var _loc10_:Number = NaN;
|
||||
var _loc9_:Number = NaN;
|
||||
var _loc8_:Number = NaN;
|
||||
var _loc12_:Number = NaN;
|
||||
var _loc5_:Number = NaN;
|
||||
var _loc25_:Number = NaN;
|
||||
var _loc20_:Number = 0;
|
||||
var _loc17_:Number = 0;
|
||||
var _loc18_:Number = 0;
|
||||
var _loc13_:Number = 0;
|
||||
var _loc16_:Number = 0;
|
||||
var _loc23_:Number = 0;
|
||||
var _loc24_:Number = 0.3333333333333333;
|
||||
_loc15_ = 0;
|
||||
while(_loc15_ < m_vertexCount)
|
||||
{
|
||||
_loc7_ = m_vertices[_loc15_];
|
||||
_loc6_ = _loc15_ + 1 < m_vertexCount ? m_vertices[int(_loc15_ + 1)] : m_vertices[0];
|
||||
_loc4_ = _loc7_.x - _loc16_;
|
||||
_loc3_ = _loc7_.y - _loc23_;
|
||||
_loc11_ = _loc6_.x - _loc16_;
|
||||
_loc14_ = _loc6_.y - _loc23_;
|
||||
_loc2_ = _loc4_ * _loc14_ - _loc3_ * _loc11_;
|
||||
_loc22_ = 0.5 * _loc2_;
|
||||
_loc18_ += _loc22_;
|
||||
_loc20_ += _loc22_ * _loc24_ * (_loc16_ + _loc7_.x + _loc6_.x);
|
||||
_loc17_ += _loc22_ * _loc24_ * (_loc23_ + _loc7_.y + _loc6_.y);
|
||||
_loc19_ = _loc16_;
|
||||
_loc21_ = _loc23_;
|
||||
_loc10_ = _loc4_;
|
||||
_loc9_ = _loc3_;
|
||||
_loc8_ = _loc11_;
|
||||
_loc12_ = _loc14_;
|
||||
_loc5_ = _loc24_ * (0.25 * (_loc10_ * _loc10_ + _loc8_ * _loc10_ + _loc8_ * _loc8_) + (_loc19_ * _loc10_ + _loc19_ * _loc8_)) + 0.5 * _loc19_ * _loc19_;
|
||||
_loc25_ = _loc24_ * (0.25 * (_loc9_ * _loc9_ + _loc12_ * _loc9_ + _loc12_ * _loc12_) + (_loc21_ * _loc9_ + _loc21_ * _loc12_)) + 0.5 * _loc21_ * _loc21_;
|
||||
_loc13_ += _loc2_ * (_loc5_ + _loc25_);
|
||||
_loc15_++;
|
||||
}
|
||||
param1.mass = m_density * _loc18_;
|
||||
_loc20_ *= 1 / _loc18_;
|
||||
_loc17_ *= 1 / _loc18_;
|
||||
param1.center.Set(_loc20_,_loc17_);
|
||||
param1.I = m_density * _loc13_;
|
||||
}
|
||||
|
||||
public function GetOBB() : b2OBB
|
||||
{
|
||||
return m_obb;
|
||||
}
|
||||
|
||||
public function GetCentroid() : b2Vec2
|
||||
{
|
||||
return m_centroid;
|
||||
}
|
||||
|
||||
public function GetVertexCount() : int
|
||||
{
|
||||
return m_vertexCount;
|
||||
}
|
||||
|
||||
public function GetVertices() : Array
|
||||
{
|
||||
return m_vertices;
|
||||
}
|
||||
|
||||
public function GetCoreVertices() : Array
|
||||
{
|
||||
return m_coreVertices;
|
||||
}
|
||||
|
||||
public function GetNormals() : Array
|
||||
{
|
||||
return m_normals;
|
||||
}
|
||||
|
||||
public function GetFirstVertex(param1:b2XForm) : b2Vec2
|
||||
{
|
||||
return b2Math.b2MulX(param1,m_coreVertices[0]);
|
||||
}
|
||||
|
||||
public function Centroid(param1:b2XForm) : b2Vec2
|
||||
{
|
||||
return b2Math.b2MulX(param1,m_centroid);
|
||||
}
|
||||
|
||||
public function Support(param1:b2XForm, param2:Number, param3:Number) : b2Vec2
|
||||
{
|
||||
var _loc9_:b2Vec2 = null;
|
||||
var _loc5_:b2Mat22 = null;
|
||||
var _loc10_:int = 0;
|
||||
var _loc7_:Number = NaN;
|
||||
_loc5_ = param1.R;
|
||||
var _loc8_:Number = param2 * _loc5_.col1.x + param3 * _loc5_.col1.y;
|
||||
var _loc11_:Number = param2 * _loc5_.col2.x + param3 * _loc5_.col2.y;
|
||||
var _loc6_:int = 0;
|
||||
_loc9_ = m_coreVertices[0];
|
||||
var _loc4_:Number = _loc9_.x * _loc8_ + _loc9_.y * _loc11_;
|
||||
_loc10_ = 1;
|
||||
while(_loc10_ < m_vertexCount)
|
||||
{
|
||||
_loc9_ = m_coreVertices[_loc10_];
|
||||
_loc7_ = _loc9_.x * _loc8_ + _loc9_.y * _loc11_;
|
||||
if(_loc7_ > _loc4_)
|
||||
{
|
||||
_loc6_ = _loc10_;
|
||||
_loc4_ = _loc7_;
|
||||
}
|
||||
_loc10_++;
|
||||
}
|
||||
_loc5_ = param1.R;
|
||||
_loc9_ = m_coreVertices[_loc6_];
|
||||
s_supportVec.x = param1.position.x + (_loc5_.col1.x * _loc9_.x + _loc5_.col2.x * _loc9_.y);
|
||||
s_supportVec.y = param1.position.y + (_loc5_.col1.y * _loc9_.x + _loc5_.col2.y * _loc9_.y);
|
||||
return s_supportVec;
|
||||
}
|
||||
|
||||
override public function UpdateSweepRadius(param1:b2Vec2) : void
|
||||
{
|
||||
var _loc4_:b2Vec2 = null;
|
||||
var _loc5_:int = 0;
|
||||
var _loc3_:Number = NaN;
|
||||
var _loc2_:Number = NaN;
|
||||
m_sweepRadius = 0;
|
||||
_loc5_ = 0;
|
||||
while(_loc5_ < m_vertexCount)
|
||||
{
|
||||
_loc4_ = m_coreVertices[_loc5_];
|
||||
_loc3_ = _loc4_.x - param1.x;
|
||||
_loc2_ = _loc4_.y - param1.y;
|
||||
_loc3_ = Math.sqrt(_loc3_ * _loc3_ + _loc2_ * _loc2_);
|
||||
if(_loc3_ > m_sweepRadius)
|
||||
{
|
||||
m_sweepRadius = _loc3_;
|
||||
}
|
||||
_loc5_++;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,224 @@
|
||||
package Box2D.Collision.Shapes
|
||||
{
|
||||
import Box2D.Collision.b2AABB;
|
||||
import Box2D.Collision.b2BroadPhase;
|
||||
import Box2D.Collision.b2Pair;
|
||||
import Box2D.Collision.b2Segment;
|
||||
import Box2D.Common.Math.b2Vec2;
|
||||
import Box2D.Common.Math.b2XForm;
|
||||
import Box2D.Dynamics.b2Body;
|
||||
|
||||
public class b2Shape
|
||||
{
|
||||
|
||||
public static const e_unknownShape:int = -1;
|
||||
|
||||
public static const e_circleShape:int = 0;
|
||||
|
||||
public static const e_polygonShape:int = 1;
|
||||
|
||||
public static const e_shapeTypeCount:int = 2;
|
||||
|
||||
private static var s_proxyAABB:b2AABB = new b2AABB();
|
||||
|
||||
private static var s_syncAABB:b2AABB = new b2AABB();
|
||||
|
||||
private static var s_resetAABB:b2AABB = new b2AABB();
|
||||
|
||||
public var m_type:int;
|
||||
|
||||
public var m_next:b2Shape;
|
||||
|
||||
public var m_body:b2Body;
|
||||
|
||||
public var m_sweepRadius:Number;
|
||||
|
||||
public var m_density:Number;
|
||||
|
||||
public var m_friction:Number;
|
||||
|
||||
public var m_restitution:Number;
|
||||
|
||||
public var m_proxyId:uint;
|
||||
|
||||
public var m_filter:b2FilterData;
|
||||
|
||||
public var m_isSensor:Boolean;
|
||||
|
||||
public var m_userData:*;
|
||||
|
||||
public function b2Shape(param1:b2ShapeDef)
|
||||
{
|
||||
super();
|
||||
m_userData = param1.userData;
|
||||
m_friction = param1.friction;
|
||||
m_restitution = param1.restitution;
|
||||
m_density = param1.density;
|
||||
m_body = null;
|
||||
m_sweepRadius = 0;
|
||||
m_next = null;
|
||||
m_proxyId = b2Pair.b2_nullProxy;
|
||||
m_filter = param1.filter.Copy();
|
||||
m_isSensor = param1.isSensor;
|
||||
}
|
||||
|
||||
public static function Create(param1:b2ShapeDef, param2:*) : b2Shape
|
||||
{
|
||||
switch(param1.type)
|
||||
{
|
||||
case e_circleShape:
|
||||
return new b2CircleShape(param1);
|
||||
case 1:
|
||||
return new b2PolygonShape(param1);
|
||||
default:
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
public static function Destroy(param1:b2Shape, param2:*) : void
|
||||
{
|
||||
}
|
||||
|
||||
public function GetType() : int
|
||||
{
|
||||
return m_type;
|
||||
}
|
||||
|
||||
public function IsSensor() : Boolean
|
||||
{
|
||||
return m_isSensor;
|
||||
}
|
||||
|
||||
public function SetFilterData(param1:b2FilterData) : void
|
||||
{
|
||||
m_filter = param1.Copy();
|
||||
}
|
||||
|
||||
public function GetFilterData() : b2FilterData
|
||||
{
|
||||
return m_filter.Copy();
|
||||
}
|
||||
|
||||
public function GetBody() : b2Body
|
||||
{
|
||||
return m_body;
|
||||
}
|
||||
|
||||
public function GetNext() : b2Shape
|
||||
{
|
||||
return m_next;
|
||||
}
|
||||
|
||||
public function GetUserData() : *
|
||||
{
|
||||
return m_userData;
|
||||
}
|
||||
|
||||
public function SetUserData(param1:*) : void
|
||||
{
|
||||
m_userData = param1;
|
||||
}
|
||||
|
||||
public function TestPoint(param1:b2XForm, param2:b2Vec2) : Boolean
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
public function TestSegment(param1:b2XForm, param2:Array, param3:b2Vec2, param4:b2Segment, param5:Number) : Boolean
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
public function ComputeAABB(param1:b2AABB, param2:b2XForm) : void
|
||||
{
|
||||
}
|
||||
|
||||
public function ComputeSweptAABB(param1:b2AABB, param2:b2XForm, param3:b2XForm) : void
|
||||
{
|
||||
}
|
||||
|
||||
public function ComputeMass(param1:b2MassData) : void
|
||||
{
|
||||
}
|
||||
|
||||
public function GetSweepRadius() : Number
|
||||
{
|
||||
return m_sweepRadius;
|
||||
}
|
||||
|
||||
public function GetFriction() : Number
|
||||
{
|
||||
return m_friction;
|
||||
}
|
||||
|
||||
public function GetRestitution() : Number
|
||||
{
|
||||
return m_restitution;
|
||||
}
|
||||
|
||||
public function CreateProxy(param1:b2BroadPhase, param2:b2XForm) : void
|
||||
{
|
||||
var _loc3_:b2AABB = s_proxyAABB;
|
||||
ComputeAABB(_loc3_,param2);
|
||||
var _loc4_:Boolean = param1.InRange(_loc3_);
|
||||
if(_loc4_)
|
||||
{
|
||||
m_proxyId = param1.CreateProxy(_loc3_,this);
|
||||
}
|
||||
else
|
||||
{
|
||||
m_proxyId = b2Pair.b2_nullProxy;
|
||||
}
|
||||
}
|
||||
|
||||
public function DestroyProxy(param1:b2BroadPhase) : void
|
||||
{
|
||||
if(m_proxyId != b2Pair.b2_nullProxy)
|
||||
{
|
||||
param1.DestroyProxy(m_proxyId);
|
||||
m_proxyId = b2Pair.b2_nullProxy;
|
||||
}
|
||||
}
|
||||
|
||||
public function Synchronize(param1:b2BroadPhase, param2:b2XForm, param3:b2XForm) : Boolean
|
||||
{
|
||||
if(m_proxyId == b2Pair.b2_nullProxy)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
var _loc4_:b2AABB = s_syncAABB;
|
||||
ComputeSweptAABB(_loc4_,param2,param3);
|
||||
if(param1.InRange(_loc4_))
|
||||
{
|
||||
param1.MoveProxy(m_proxyId,_loc4_);
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
public function RefilterProxy(param1:b2BroadPhase, param2:b2XForm) : void
|
||||
{
|
||||
if(m_proxyId == b2Pair.b2_nullProxy)
|
||||
{
|
||||
return;
|
||||
}
|
||||
param1.DestroyProxy(m_proxyId);
|
||||
var _loc3_:b2AABB = s_resetAABB;
|
||||
ComputeAABB(_loc3_,param2);
|
||||
var _loc4_:Boolean = param1.InRange(_loc3_);
|
||||
if(_loc4_)
|
||||
{
|
||||
m_proxyId = param1.CreateProxy(_loc3_,this);
|
||||
}
|
||||
else
|
||||
{
|
||||
m_proxyId = b2Pair.b2_nullProxy;
|
||||
}
|
||||
}
|
||||
|
||||
public function UpdateSweepRadius(param1:b2Vec2) : void
|
||||
{
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,26 @@
|
||||
package Box2D.Collision.Shapes
|
||||
{
|
||||
public class b2ShapeDef
|
||||
{
|
||||
|
||||
public var type:int = -1;
|
||||
|
||||
public var userData:* = null;
|
||||
|
||||
public var friction:Number = 0.2;
|
||||
|
||||
public var restitution:Number = 0;
|
||||
|
||||
public var density:Number = 0;
|
||||
|
||||
public var isSensor:Boolean = false;
|
||||
|
||||
public var filter:b2FilterData = new b2FilterData();
|
||||
|
||||
public function b2ShapeDef()
|
||||
{
|
||||
super();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,26 @@
|
||||
package Box2D.Collision
|
||||
{
|
||||
import Box2D.Common.Math.b2Vec2;
|
||||
|
||||
public class b2AABB
|
||||
{
|
||||
|
||||
public var lowerBound:b2Vec2 = new b2Vec2();
|
||||
|
||||
public var upperBound:b2Vec2 = new b2Vec2();
|
||||
|
||||
public function b2AABB()
|
||||
{
|
||||
super();
|
||||
}
|
||||
|
||||
public function IsValid() : Boolean
|
||||
{
|
||||
var _loc3_:Number = upperBound.x - lowerBound.x;
|
||||
var _loc2_:Number = upperBound.y - lowerBound.y;
|
||||
var _loc1_:Boolean = _loc3_ >= 0 && _loc2_ >= 0;
|
||||
return _loc1_ && lowerBound.IsValid() && upperBound.IsValid();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,41 @@
|
||||
package Box2D.Collision
|
||||
{
|
||||
public class b2Bound
|
||||
{
|
||||
|
||||
public var value:uint;
|
||||
|
||||
public var proxyId:uint;
|
||||
|
||||
public var stabbingCount:uint;
|
||||
|
||||
public function b2Bound()
|
||||
{
|
||||
super();
|
||||
}
|
||||
|
||||
public function IsLower() : Boolean
|
||||
{
|
||||
return (value & 1) == 0;
|
||||
}
|
||||
|
||||
public function IsUpper() : Boolean
|
||||
{
|
||||
return (value & 1) == 1;
|
||||
}
|
||||
|
||||
public function Swap(param1:b2Bound) : void
|
||||
{
|
||||
var _loc3_:uint = value;
|
||||
var _loc4_:uint = proxyId;
|
||||
var _loc2_:uint = stabbingCount;
|
||||
value = param1.value;
|
||||
proxyId = param1.proxyId;
|
||||
stabbingCount = param1.stabbingCount;
|
||||
param1.value = _loc3_;
|
||||
param1.proxyId = _loc4_;
|
||||
param1.stabbingCount = _loc2_;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,16 @@
|
||||
package Box2D.Collision
|
||||
{
|
||||
public class b2BoundValues
|
||||
{
|
||||
|
||||
public var lowerValues:Array = [0,0];
|
||||
|
||||
public var upperValues:Array = [0,0];
|
||||
|
||||
public function b2BoundValues()
|
||||
{
|
||||
super();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,836 @@
|
||||
package Box2D.Collision
|
||||
{
|
||||
import Box2D.Common.*;
|
||||
import Box2D.Common.Math.*;
|
||||
|
||||
public class b2BroadPhase
|
||||
{
|
||||
|
||||
public static var s_validate:Boolean = false;
|
||||
|
||||
public static const b2_invalid:uint = 65535;
|
||||
|
||||
public static const b2_nullEdge:uint = 65535;
|
||||
|
||||
public var m_pairManager:b2PairManager = new b2PairManager();
|
||||
|
||||
public var m_proxyPool:Array = new Array(4096);
|
||||
|
||||
public var m_freeProxy:uint;
|
||||
|
||||
public var m_bounds:Array = new Array(2 * 512);
|
||||
|
||||
public var m_queryResults:Array = new Array(512);
|
||||
|
||||
public var m_queryResultCount:int;
|
||||
|
||||
public var m_worldAABB:b2AABB;
|
||||
|
||||
public var m_quantizationFactor:b2Vec2 = new b2Vec2();
|
||||
|
||||
public var m_proxyCount:int;
|
||||
|
||||
public var m_timeStamp:uint;
|
||||
|
||||
public function b2BroadPhase(param1:b2AABB, param2:b2PairCallback)
|
||||
{
|
||||
var _loc7_:int = 0;
|
||||
var _loc5_:int = 0;
|
||||
var _loc6_:b2Proxy = null;
|
||||
super();
|
||||
m_pairManager.Initialize(this,param2);
|
||||
m_worldAABB = param1;
|
||||
m_proxyCount = 0;
|
||||
_loc7_ = 0;
|
||||
while(_loc7_ < 512)
|
||||
{
|
||||
m_queryResults[_loc7_] = 0;
|
||||
_loc7_++;
|
||||
}
|
||||
m_bounds = new Array(2);
|
||||
_loc7_ = 0;
|
||||
while(_loc7_ < 2)
|
||||
{
|
||||
m_bounds[_loc7_] = new Array(2 * 512);
|
||||
_loc5_ = 0;
|
||||
while(_loc5_ < 2 * 512)
|
||||
{
|
||||
m_bounds[_loc7_][_loc5_] = new b2Bound();
|
||||
_loc5_++;
|
||||
}
|
||||
_loc7_++;
|
||||
}
|
||||
var _loc4_:Number = param1.upperBound.x - param1.lowerBound.x;
|
||||
var _loc3_:Number = param1.upperBound.y - param1.lowerBound.y;
|
||||
m_quantizationFactor.x = 65535 / _loc4_;
|
||||
m_quantizationFactor.y = 65535 / _loc3_;
|
||||
_loc7_ = 0;
|
||||
while(_loc7_ < 512 - 1)
|
||||
{
|
||||
_loc6_ = new b2Proxy();
|
||||
m_proxyPool[_loc7_] = _loc6_;
|
||||
_loc6_.SetNext(_loc7_ + 1);
|
||||
_loc6_.timeStamp = 0;
|
||||
_loc6_.overlapCount = 65535;
|
||||
_loc6_.userData = null;
|
||||
_loc7_++;
|
||||
}
|
||||
_loc6_ = new b2Proxy();
|
||||
m_proxyPool[511] = _loc6_;
|
||||
_loc6_.SetNext(b2Pair.b2_nullProxy);
|
||||
_loc6_.timeStamp = 0;
|
||||
_loc6_.overlapCount = 65535;
|
||||
_loc6_.userData = null;
|
||||
m_freeProxy = 0;
|
||||
m_timeStamp = 1;
|
||||
m_queryResultCount = 0;
|
||||
}
|
||||
|
||||
public static function BinarySearch(param1:Array, param2:int, param3:uint) : uint
|
||||
{
|
||||
var _loc4_:int = 0;
|
||||
var _loc7_:b2Bound = null;
|
||||
var _loc6_:int = 0;
|
||||
var _loc5_:int = param2 - 1;
|
||||
while(_loc6_ <= _loc5_)
|
||||
{
|
||||
_loc4_ = (_loc6_ + _loc5_) / 2;
|
||||
_loc7_ = param1[_loc4_];
|
||||
if(_loc7_.value > param3)
|
||||
{
|
||||
_loc5_ = _loc4_ - 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
if(_loc7_.value >= param3)
|
||||
{
|
||||
return uint(_loc4_);
|
||||
}
|
||||
_loc6_ = _loc4_ + 1;
|
||||
}
|
||||
}
|
||||
return uint(_loc6_);
|
||||
}
|
||||
|
||||
public function InRange(param1:b2AABB) : Boolean
|
||||
{
|
||||
var _loc5_:Number = NaN;
|
||||
var _loc3_:Number = NaN;
|
||||
var _loc4_:Number = NaN;
|
||||
var _loc2_:Number = NaN;
|
||||
_loc5_ = param1.lowerBound.x;
|
||||
_loc3_ = param1.lowerBound.y;
|
||||
_loc5_ -= m_worldAABB.upperBound.x;
|
||||
_loc3_ -= m_worldAABB.upperBound.y;
|
||||
_loc4_ = m_worldAABB.lowerBound.x;
|
||||
_loc2_ = m_worldAABB.lowerBound.y;
|
||||
_loc4_ -= param1.upperBound.x;
|
||||
_loc2_ -= param1.upperBound.y;
|
||||
_loc5_ = b2Math.b2Max(_loc5_,_loc4_);
|
||||
_loc3_ = b2Math.b2Max(_loc3_,_loc2_);
|
||||
return b2Math.b2Max(_loc5_,_loc3_) < 0;
|
||||
}
|
||||
|
||||
public function GetProxy(param1:int) : b2Proxy
|
||||
{
|
||||
var _loc2_:b2Proxy = m_proxyPool[param1];
|
||||
if(param1 == b2Pair.b2_nullProxy || _loc2_.IsValid() == false)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
return _loc2_;
|
||||
}
|
||||
|
||||
public function CreateProxy(param1:b2AABB, param2:*) : uint
|
||||
{
|
||||
var _loc6_:* = 0;
|
||||
var _loc20_:b2Proxy = null;
|
||||
var _loc4_:int = 0;
|
||||
var _loc17_:Array = null;
|
||||
var _loc5_:* = 0;
|
||||
var _loc21_:* = 0;
|
||||
var _loc22_:Array = null;
|
||||
var _loc19_:Array = null;
|
||||
var _loc9_:Array = null;
|
||||
var _loc12_:int = 0;
|
||||
var _loc3_:int = 0;
|
||||
var _loc23_:b2Bound = null;
|
||||
var _loc16_:b2Bound = null;
|
||||
var _loc8_:b2Bound = null;
|
||||
var _loc11_:int = 0;
|
||||
var _loc13_:b2Proxy = null;
|
||||
var _loc14_:int = 0;
|
||||
var _loc10_:uint = m_freeProxy;
|
||||
_loc20_ = m_proxyPool[_loc10_];
|
||||
m_freeProxy = _loc20_.GetNext();
|
||||
_loc20_.overlapCount = 0;
|
||||
_loc20_.userData = param2;
|
||||
var _loc18_:uint = 2 * m_proxyCount;
|
||||
var _loc7_:Array = [];
|
||||
var _loc15_:Array = [];
|
||||
ComputeBounds(_loc7_,_loc15_,param1);
|
||||
_loc4_ = 0;
|
||||
while(_loc4_ < 2)
|
||||
{
|
||||
_loc17_ = m_bounds[_loc4_];
|
||||
_loc22_ = [_loc5_];
|
||||
_loc19_ = [_loc21_];
|
||||
Query(_loc22_,_loc19_,_loc7_[_loc4_],_loc15_[_loc4_],_loc17_,_loc18_,_loc4_);
|
||||
_loc5_ = uint(_loc22_[0]);
|
||||
_loc21_ = uint(_loc19_[0]);
|
||||
_loc9_ = [];
|
||||
_loc3_ = _loc18_ - _loc21_;
|
||||
_loc12_ = 0;
|
||||
while(_loc12_ < _loc3_)
|
||||
{
|
||||
_loc9_[_loc12_] = new b2Bound();
|
||||
_loc23_ = _loc9_[_loc12_];
|
||||
_loc16_ = _loc17_[int(_loc21_ + _loc12_)];
|
||||
_loc23_.value = _loc16_.value;
|
||||
_loc23_.proxyId = _loc16_.proxyId;
|
||||
_loc23_.stabbingCount = _loc16_.stabbingCount;
|
||||
_loc12_++;
|
||||
}
|
||||
_loc3_ = int(_loc9_.length);
|
||||
_loc11_ = _loc21_ + 2;
|
||||
_loc12_ = 0;
|
||||
while(_loc12_ < _loc3_)
|
||||
{
|
||||
_loc16_ = _loc9_[_loc12_];
|
||||
_loc23_ = _loc17_[int(_loc11_ + _loc12_)];
|
||||
_loc23_.value = _loc16_.value;
|
||||
_loc23_.proxyId = _loc16_.proxyId;
|
||||
_loc23_.stabbingCount = _loc16_.stabbingCount;
|
||||
_loc12_++;
|
||||
}
|
||||
_loc9_ = [];
|
||||
_loc3_ = _loc21_ - _loc5_;
|
||||
_loc12_ = 0;
|
||||
while(_loc12_ < _loc3_)
|
||||
{
|
||||
_loc9_[_loc12_] = new b2Bound();
|
||||
_loc23_ = _loc9_[_loc12_];
|
||||
_loc16_ = _loc17_[int(_loc5_ + _loc12_)];
|
||||
_loc23_.value = _loc16_.value;
|
||||
_loc23_.proxyId = _loc16_.proxyId;
|
||||
_loc23_.stabbingCount = _loc16_.stabbingCount;
|
||||
_loc12_++;
|
||||
}
|
||||
_loc3_ = int(_loc9_.length);
|
||||
_loc11_ = _loc5_ + 1;
|
||||
_loc12_ = 0;
|
||||
while(_loc12_ < _loc3_)
|
||||
{
|
||||
_loc16_ = _loc9_[_loc12_];
|
||||
_loc23_ = _loc17_[int(_loc11_ + _loc12_)];
|
||||
_loc23_.value = _loc16_.value;
|
||||
_loc23_.proxyId = _loc16_.proxyId;
|
||||
_loc23_.stabbingCount = _loc16_.stabbingCount;
|
||||
_loc12_++;
|
||||
}
|
||||
_loc21_++;
|
||||
_loc23_ = _loc17_[_loc5_];
|
||||
_loc16_ = _loc17_[_loc21_];
|
||||
_loc23_.value = _loc7_[_loc4_];
|
||||
_loc23_.proxyId = _loc10_;
|
||||
_loc16_.value = _loc15_[_loc4_];
|
||||
_loc16_.proxyId = _loc10_;
|
||||
_loc8_ = _loc17_[int(_loc5_ - 1)];
|
||||
_loc23_.stabbingCount = _loc5_ == 0 ? 0 : _loc8_.stabbingCount;
|
||||
_loc8_ = _loc17_[int(_loc21_ - 1)];
|
||||
_loc16_.stabbingCount = _loc8_.stabbingCount;
|
||||
_loc6_ = _loc5_;
|
||||
while(_loc6_ < _loc21_)
|
||||
{
|
||||
_loc8_ = _loc17_[_loc6_];
|
||||
_loc8_.stabbingCount++;
|
||||
_loc6_++;
|
||||
}
|
||||
_loc6_ = _loc5_;
|
||||
while(_loc6_ < _loc18_ + 2)
|
||||
{
|
||||
_loc23_ = _loc17_[_loc6_];
|
||||
_loc13_ = m_proxyPool[_loc23_.proxyId];
|
||||
if(_loc23_.IsLower())
|
||||
{
|
||||
_loc13_.lowerBounds[_loc4_] = _loc6_;
|
||||
}
|
||||
else
|
||||
{
|
||||
_loc13_.upperBounds[_loc4_] = _loc6_;
|
||||
}
|
||||
_loc6_++;
|
||||
}
|
||||
_loc4_++;
|
||||
}
|
||||
m_proxyCount = m_proxyCount + 1;
|
||||
_loc14_ = 0;
|
||||
while(_loc14_ < m_queryResultCount)
|
||||
{
|
||||
m_pairManager.AddBufferedPair(_loc10_,m_queryResults[_loc14_]);
|
||||
_loc14_++;
|
||||
}
|
||||
m_pairManager.Commit();
|
||||
m_queryResultCount = 0;
|
||||
IncrementTimeStamp();
|
||||
return _loc10_;
|
||||
}
|
||||
|
||||
public function DestroyProxy(param1:uint) : void
|
||||
{
|
||||
var _loc19_:b2Bound = null;
|
||||
var _loc12_:b2Bound = null;
|
||||
var _loc3_:int = 0;
|
||||
var _loc13_:Array = null;
|
||||
var _loc4_:* = 0;
|
||||
var _loc17_:* = 0;
|
||||
var _loc14_:* = 0;
|
||||
var _loc5_:* = 0;
|
||||
var _loc7_:Array = null;
|
||||
var _loc9_:int = 0;
|
||||
var _loc2_:int = 0;
|
||||
var _loc8_:int = 0;
|
||||
var _loc6_:* = 0;
|
||||
var _loc10_:b2Proxy = null;
|
||||
var _loc18_:int = 0;
|
||||
var _loc11_:int = 0;
|
||||
var _loc16_:b2Proxy = m_proxyPool[param1];
|
||||
var _loc15_:int = 2 * m_proxyCount;
|
||||
_loc3_ = 0;
|
||||
while(_loc3_ < 2)
|
||||
{
|
||||
_loc13_ = m_bounds[_loc3_];
|
||||
_loc4_ = uint(_loc16_.lowerBounds[_loc3_]);
|
||||
_loc17_ = uint(_loc16_.upperBounds[_loc3_]);
|
||||
_loc19_ = _loc13_[_loc4_];
|
||||
_loc14_ = _loc19_.value;
|
||||
_loc12_ = _loc13_[_loc17_];
|
||||
_loc5_ = _loc12_.value;
|
||||
_loc7_ = [];
|
||||
_loc2_ = _loc17_ - _loc4_ - 1;
|
||||
_loc9_ = 0;
|
||||
while(_loc9_ < _loc2_)
|
||||
{
|
||||
_loc7_[_loc9_] = new b2Bound();
|
||||
_loc19_ = _loc7_[_loc9_];
|
||||
_loc12_ = _loc13_[int(_loc4_ + 1 + _loc9_)];
|
||||
_loc19_.value = _loc12_.value;
|
||||
_loc19_.proxyId = _loc12_.proxyId;
|
||||
_loc19_.stabbingCount = _loc12_.stabbingCount;
|
||||
_loc9_++;
|
||||
}
|
||||
_loc2_ = int(_loc7_.length);
|
||||
_loc8_ = _loc4_;
|
||||
_loc9_ = 0;
|
||||
while(_loc9_ < _loc2_)
|
||||
{
|
||||
_loc12_ = _loc7_[_loc9_];
|
||||
_loc19_ = _loc13_[int(_loc8_ + _loc9_)];
|
||||
_loc19_.value = _loc12_.value;
|
||||
_loc19_.proxyId = _loc12_.proxyId;
|
||||
_loc19_.stabbingCount = _loc12_.stabbingCount;
|
||||
_loc9_++;
|
||||
}
|
||||
_loc7_ = [];
|
||||
_loc2_ = _loc15_ - _loc17_ - 1;
|
||||
_loc9_ = 0;
|
||||
while(_loc9_ < _loc2_)
|
||||
{
|
||||
_loc7_[_loc9_] = new b2Bound();
|
||||
_loc19_ = _loc7_[_loc9_];
|
||||
_loc12_ = _loc13_[int(_loc17_ + 1 + _loc9_)];
|
||||
_loc19_.value = _loc12_.value;
|
||||
_loc19_.proxyId = _loc12_.proxyId;
|
||||
_loc19_.stabbingCount = _loc12_.stabbingCount;
|
||||
_loc9_++;
|
||||
}
|
||||
_loc2_ = int(_loc7_.length);
|
||||
_loc8_ = _loc17_ - 1;
|
||||
_loc9_ = 0;
|
||||
while(_loc9_ < _loc2_)
|
||||
{
|
||||
_loc12_ = _loc7_[_loc9_];
|
||||
_loc19_ = _loc13_[int(_loc8_ + _loc9_)];
|
||||
_loc19_.value = _loc12_.value;
|
||||
_loc19_.proxyId = _loc12_.proxyId;
|
||||
_loc19_.stabbingCount = _loc12_.stabbingCount;
|
||||
_loc9_++;
|
||||
}
|
||||
_loc2_ = _loc15_ - 2;
|
||||
_loc6_ = _loc4_;
|
||||
while(_loc6_ < _loc2_)
|
||||
{
|
||||
_loc19_ = _loc13_[_loc6_];
|
||||
_loc10_ = m_proxyPool[_loc19_.proxyId];
|
||||
if(_loc19_.IsLower())
|
||||
{
|
||||
_loc10_.lowerBounds[_loc3_] = _loc6_;
|
||||
}
|
||||
else
|
||||
{
|
||||
_loc10_.upperBounds[_loc3_] = _loc6_;
|
||||
}
|
||||
_loc6_++;
|
||||
}
|
||||
_loc2_ = _loc17_ - 1;
|
||||
_loc18_ = _loc4_;
|
||||
while(_loc18_ < _loc2_)
|
||||
{
|
||||
_loc19_ = _loc13_[_loc18_];
|
||||
_loc19_.stabbingCount--;
|
||||
_loc18_++;
|
||||
}
|
||||
Query([0],[0],_loc14_,_loc5_,_loc13_,_loc15_ - 2,_loc3_);
|
||||
_loc3_++;
|
||||
}
|
||||
_loc11_ = 0;
|
||||
while(_loc11_ < m_queryResultCount)
|
||||
{
|
||||
m_pairManager.RemoveBufferedPair(param1,m_queryResults[_loc11_]);
|
||||
_loc11_++;
|
||||
}
|
||||
m_pairManager.Commit();
|
||||
m_queryResultCount = 0;
|
||||
IncrementTimeStamp();
|
||||
_loc16_.userData = null;
|
||||
_loc16_.overlapCount = 65535;
|
||||
_loc16_.lowerBounds[0] = 65535;
|
||||
_loc16_.lowerBounds[1] = 65535;
|
||||
_loc16_.upperBounds[0] = 65535;
|
||||
_loc16_.upperBounds[1] = 65535;
|
||||
_loc16_.SetNext(m_freeProxy);
|
||||
m_freeProxy = param1;
|
||||
m_proxyCount = m_proxyCount - 1;
|
||||
}
|
||||
|
||||
public function MoveProxy(param1:uint, param2:b2AABB) : void
|
||||
{
|
||||
var _loc8_:Array = null;
|
||||
var _loc3_:int = 0;
|
||||
var _loc4_:* = 0;
|
||||
var _loc7_:* = 0;
|
||||
var _loc22_:b2Bound = null;
|
||||
var _loc10_:b2Bound = null;
|
||||
var _loc19_:b2Bound = null;
|
||||
var _loc20_:* = 0;
|
||||
var _loc23_:b2Proxy = null;
|
||||
var _loc13_:Array = null;
|
||||
var _loc6_:* = 0;
|
||||
var _loc21_:* = 0;
|
||||
var _loc12_:* = 0;
|
||||
var _loc5_:* = 0;
|
||||
var _loc9_:int = 0;
|
||||
var _loc17_:int = 0;
|
||||
var _loc11_:* = 0;
|
||||
var _loc15_:b2Proxy = null;
|
||||
if(param1 == b2Pair.b2_nullProxy || 512 <= param1)
|
||||
{
|
||||
return;
|
||||
}
|
||||
if(param2.IsValid() == false)
|
||||
{
|
||||
return;
|
||||
}
|
||||
var _loc14_:uint = 2 * m_proxyCount;
|
||||
var _loc18_:b2Proxy = m_proxyPool[param1];
|
||||
var _loc16_:b2BoundValues = new b2BoundValues();
|
||||
ComputeBounds(_loc16_.lowerValues,_loc16_.upperValues,param2);
|
||||
var _loc24_:b2BoundValues = new b2BoundValues();
|
||||
_loc4_ = 0;
|
||||
while(_loc4_ < 2)
|
||||
{
|
||||
_loc22_ = m_bounds[_loc4_][_loc18_.lowerBounds[_loc4_]];
|
||||
_loc24_.lowerValues[_loc4_] = _loc22_.value;
|
||||
_loc22_ = m_bounds[_loc4_][_loc18_.upperBounds[_loc4_]];
|
||||
_loc24_.upperValues[_loc4_] = _loc22_.value;
|
||||
_loc4_++;
|
||||
}
|
||||
_loc4_ = 0;
|
||||
while(_loc4_ < 2)
|
||||
{
|
||||
_loc13_ = m_bounds[_loc4_];
|
||||
_loc6_ = uint(_loc18_.lowerBounds[_loc4_]);
|
||||
_loc21_ = uint(_loc18_.upperBounds[_loc4_]);
|
||||
_loc12_ = uint(_loc16_.lowerValues[_loc4_]);
|
||||
_loc5_ = uint(_loc16_.upperValues[_loc4_]);
|
||||
_loc22_ = _loc13_[_loc6_];
|
||||
_loc9_ = _loc12_ - _loc22_.value;
|
||||
_loc22_.value = _loc12_;
|
||||
_loc22_ = _loc13_[_loc21_];
|
||||
_loc17_ = _loc5_ - _loc22_.value;
|
||||
_loc22_.value = _loc5_;
|
||||
if(_loc9_ < 0)
|
||||
{
|
||||
_loc7_ = _loc6_;
|
||||
while(_loc7_ > 0 && _loc12_ < (_loc13_[int(_loc7_ - 1)] as b2Bound).value)
|
||||
{
|
||||
_loc22_ = _loc13_[_loc7_];
|
||||
_loc10_ = _loc13_[int(_loc7_ - 1)];
|
||||
_loc11_ = _loc10_.proxyId;
|
||||
_loc15_ = m_proxyPool[_loc10_.proxyId];
|
||||
_loc10_.stabbingCount++;
|
||||
if(_loc10_.IsUpper() == true)
|
||||
{
|
||||
if(TestOverlap(_loc16_,_loc15_))
|
||||
{
|
||||
m_pairManager.AddBufferedPair(param1,_loc11_);
|
||||
}
|
||||
_loc8_ = _loc15_.upperBounds;
|
||||
_loc3_ = int(_loc8_[_loc4_]);
|
||||
_loc3_++;
|
||||
_loc8_[_loc4_] = _loc3_;
|
||||
_loc22_.stabbingCount++;
|
||||
}
|
||||
else
|
||||
{
|
||||
_loc8_ = _loc15_.lowerBounds;
|
||||
_loc3_ = int(_loc8_[_loc4_]);
|
||||
_loc3_++;
|
||||
_loc8_[_loc4_] = _loc3_;
|
||||
_loc22_.stabbingCount--;
|
||||
}
|
||||
_loc8_ = _loc18_.lowerBounds;
|
||||
_loc3_ = int(_loc8_[_loc4_]);
|
||||
_loc3_--;
|
||||
_loc8_[_loc4_] = _loc3_;
|
||||
_loc22_.Swap(_loc10_);
|
||||
_loc7_--;
|
||||
}
|
||||
}
|
||||
if(_loc17_ > 0)
|
||||
{
|
||||
_loc7_ = _loc21_;
|
||||
while(_loc7_ < _loc14_ - 1 && (_loc13_[int(_loc7_ + 1)] as b2Bound).value <= _loc5_)
|
||||
{
|
||||
_loc22_ = _loc13_[_loc7_];
|
||||
_loc19_ = _loc13_[int(_loc7_ + 1)];
|
||||
_loc20_ = _loc19_.proxyId;
|
||||
_loc23_ = m_proxyPool[_loc20_];
|
||||
_loc19_.stabbingCount++;
|
||||
if(_loc19_.IsLower() == true)
|
||||
{
|
||||
if(TestOverlap(_loc16_,_loc23_))
|
||||
{
|
||||
m_pairManager.AddBufferedPair(param1,_loc20_);
|
||||
}
|
||||
_loc8_ = _loc23_.lowerBounds;
|
||||
_loc3_ = int(_loc8_[_loc4_]);
|
||||
_loc3_--;
|
||||
_loc8_[_loc4_] = _loc3_;
|
||||
_loc22_.stabbingCount++;
|
||||
}
|
||||
else
|
||||
{
|
||||
_loc8_ = _loc23_.upperBounds;
|
||||
_loc3_ = int(_loc8_[_loc4_]);
|
||||
_loc3_--;
|
||||
_loc8_[_loc4_] = _loc3_;
|
||||
_loc22_.stabbingCount--;
|
||||
}
|
||||
_loc8_ = _loc18_.upperBounds;
|
||||
_loc3_ = int(_loc8_[_loc4_]);
|
||||
_loc3_++;
|
||||
_loc8_[_loc4_] = _loc3_;
|
||||
_loc22_.Swap(_loc19_);
|
||||
_loc7_++;
|
||||
}
|
||||
}
|
||||
if(_loc9_ > 0)
|
||||
{
|
||||
_loc7_ = _loc6_;
|
||||
while(_loc7_ < _loc14_ - 1 && (_loc13_[int(_loc7_ + 1)] as b2Bound).value <= _loc12_)
|
||||
{
|
||||
_loc22_ = _loc13_[_loc7_];
|
||||
_loc19_ = _loc13_[int(_loc7_ + 1)];
|
||||
_loc20_ = _loc19_.proxyId;
|
||||
_loc23_ = m_proxyPool[_loc20_];
|
||||
_loc19_.stabbingCount--;
|
||||
if(_loc19_.IsUpper())
|
||||
{
|
||||
if(TestOverlap(_loc24_,_loc23_))
|
||||
{
|
||||
m_pairManager.RemoveBufferedPair(param1,_loc20_);
|
||||
}
|
||||
_loc8_ = _loc23_.upperBounds;
|
||||
_loc3_ = int(_loc8_[_loc4_]);
|
||||
_loc3_--;
|
||||
_loc8_[_loc4_] = _loc3_;
|
||||
_loc22_.stabbingCount--;
|
||||
}
|
||||
else
|
||||
{
|
||||
_loc8_ = _loc23_.lowerBounds;
|
||||
_loc3_ = int(_loc8_[_loc4_]);
|
||||
_loc3_--;
|
||||
_loc8_[_loc4_] = _loc3_;
|
||||
_loc22_.stabbingCount++;
|
||||
}
|
||||
_loc8_ = _loc18_.lowerBounds;
|
||||
_loc3_ = int(_loc8_[_loc4_]);
|
||||
_loc3_++;
|
||||
_loc8_[_loc4_] = _loc3_;
|
||||
_loc22_.Swap(_loc19_);
|
||||
_loc7_++;
|
||||
}
|
||||
}
|
||||
if(_loc17_ < 0)
|
||||
{
|
||||
_loc7_ = _loc21_;
|
||||
while(_loc7_ > 0 && _loc5_ < (_loc13_[int(_loc7_ - 1)] as b2Bound).value)
|
||||
{
|
||||
_loc22_ = _loc13_[_loc7_];
|
||||
_loc10_ = _loc13_[int(_loc7_ - 1)];
|
||||
_loc11_ = _loc10_.proxyId;
|
||||
_loc15_ = m_proxyPool[_loc11_];
|
||||
_loc10_.stabbingCount--;
|
||||
if(_loc10_.IsLower() == true)
|
||||
{
|
||||
if(TestOverlap(_loc24_,_loc15_))
|
||||
{
|
||||
m_pairManager.RemoveBufferedPair(param1,_loc11_);
|
||||
}
|
||||
_loc8_ = _loc15_.lowerBounds;
|
||||
_loc3_ = int(_loc8_[_loc4_]);
|
||||
_loc3_++;
|
||||
_loc8_[_loc4_] = _loc3_;
|
||||
_loc22_.stabbingCount--;
|
||||
}
|
||||
else
|
||||
{
|
||||
_loc8_ = _loc15_.upperBounds;
|
||||
_loc3_ = int(_loc8_[_loc4_]);
|
||||
_loc3_++;
|
||||
_loc8_[_loc4_] = _loc3_;
|
||||
_loc22_.stabbingCount++;
|
||||
}
|
||||
_loc8_ = _loc18_.upperBounds;
|
||||
_loc3_ = int(_loc8_[_loc4_]);
|
||||
_loc3_--;
|
||||
_loc8_[_loc4_] = _loc3_;
|
||||
_loc22_.Swap(_loc10_);
|
||||
_loc7_--;
|
||||
}
|
||||
}
|
||||
_loc4_++;
|
||||
}
|
||||
}
|
||||
|
||||
public function Commit() : void
|
||||
{
|
||||
m_pairManager.Commit();
|
||||
}
|
||||
|
||||
public function QueryAABB(param1:b2AABB, param2:*, param3:int) : int
|
||||
{
|
||||
var _loc4_:int = 0;
|
||||
var _loc9_:int = 0;
|
||||
var _loc11_:int = 0;
|
||||
var _loc8_:b2Proxy = null;
|
||||
var _loc5_:Array = [];
|
||||
var _loc12_:Array = [];
|
||||
ComputeBounds(_loc5_,_loc12_,param1);
|
||||
var _loc10_:Array = [_loc4_];
|
||||
var _loc7_:Array = [_loc9_];
|
||||
Query(_loc10_,_loc7_,_loc5_[0],_loc12_[0],m_bounds[0],2 * m_proxyCount,0);
|
||||
Query(_loc10_,_loc7_,_loc5_[1],_loc12_[1],m_bounds[1],2 * m_proxyCount,1);
|
||||
var _loc6_:int = 0;
|
||||
_loc11_ = 0;
|
||||
while(_loc11_ < m_queryResultCount && _loc6_ < param3)
|
||||
{
|
||||
_loc8_ = m_proxyPool[m_queryResults[_loc11_]];
|
||||
param2[_loc11_] = _loc8_.userData;
|
||||
_loc11_++;
|
||||
++_loc6_;
|
||||
}
|
||||
m_queryResultCount = 0;
|
||||
IncrementTimeStamp();
|
||||
return _loc6_;
|
||||
}
|
||||
|
||||
public function Validate() : void
|
||||
{
|
||||
var _loc6_:* = null;
|
||||
var _loc7_:* = null;
|
||||
var _loc8_:* = null;
|
||||
var _loc5_:Boolean = false;
|
||||
var _loc2_:int = 0;
|
||||
var _loc1_:b2Bound = null;
|
||||
var _loc3_:* = 0;
|
||||
var _loc4_:* = 0;
|
||||
var _loc10_:* = 0;
|
||||
var _loc9_:b2Bound = null;
|
||||
_loc2_ = 0;
|
||||
while(_loc2_ < 2)
|
||||
{
|
||||
_loc1_ = m_bounds[_loc2_];
|
||||
_loc3_ = uint(2 * m_proxyCount);
|
||||
_loc4_ = 0;
|
||||
_loc10_ = 0;
|
||||
while(_loc10_ < _loc3_)
|
||||
{
|
||||
_loc9_ = _loc1_[_loc10_];
|
||||
if(_loc9_.IsLower() == true)
|
||||
{
|
||||
_loc4_++;
|
||||
}
|
||||
else
|
||||
{
|
||||
_loc4_--;
|
||||
}
|
||||
_loc10_++;
|
||||
}
|
||||
_loc2_++;
|
||||
}
|
||||
}
|
||||
|
||||
private function ComputeBounds(param1:Array, param2:Array, param3:b2AABB) : void
|
||||
{
|
||||
var _loc7_:Number = param3.lowerBound.x;
|
||||
var _loc6_:Number = param3.lowerBound.y;
|
||||
_loc7_ = b2Math.b2Min(_loc7_,m_worldAABB.upperBound.x);
|
||||
_loc6_ = b2Math.b2Min(_loc6_,m_worldAABB.upperBound.y);
|
||||
_loc7_ = b2Math.b2Max(_loc7_,m_worldAABB.lowerBound.x);
|
||||
_loc6_ = b2Math.b2Max(_loc6_,m_worldAABB.lowerBound.y);
|
||||
var _loc4_:Number = param3.upperBound.x;
|
||||
var _loc5_:Number = param3.upperBound.y;
|
||||
_loc4_ = b2Math.b2Min(_loc4_,m_worldAABB.upperBound.x);
|
||||
_loc5_ = b2Math.b2Min(_loc5_,m_worldAABB.upperBound.y);
|
||||
_loc4_ = b2Math.b2Max(_loc4_,m_worldAABB.lowerBound.x);
|
||||
_loc5_ = b2Math.b2Max(_loc5_,m_worldAABB.lowerBound.y);
|
||||
param1[0] = uint(m_quantizationFactor.x * (_loc7_ - m_worldAABB.lowerBound.x)) & 65535 - 1;
|
||||
param2[0] = uint(m_quantizationFactor.x * (_loc4_ - m_worldAABB.lowerBound.x)) & 0xFFFF | 1;
|
||||
param1[1] = uint(m_quantizationFactor.y * (_loc6_ - m_worldAABB.lowerBound.y)) & 65535 - 1;
|
||||
param2[1] = uint(m_quantizationFactor.y * (_loc5_ - m_worldAABB.lowerBound.y)) & 0xFFFF | 1;
|
||||
}
|
||||
|
||||
private function TestOverlapValidate(param1:b2Proxy, param2:b2Proxy) : Boolean
|
||||
{
|
||||
var _loc4_:int = 0;
|
||||
var _loc3_:Array = null;
|
||||
var _loc5_:b2Bound = null;
|
||||
var _loc6_:b2Bound = null;
|
||||
_loc4_ = 0;
|
||||
while(_loc4_ < 2)
|
||||
{
|
||||
_loc3_ = m_bounds[_loc4_];
|
||||
_loc5_ = _loc3_[param1.lowerBounds[_loc4_]];
|
||||
_loc6_ = _loc3_[param2.upperBounds[_loc4_]];
|
||||
if(_loc5_.value > _loc6_.value)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
_loc5_ = _loc3_[param1.upperBounds[_loc4_]];
|
||||
_loc6_ = _loc3_[param2.lowerBounds[_loc4_]];
|
||||
if(_loc5_.value < _loc6_.value)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
_loc4_++;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
public function TestOverlap(param1:b2BoundValues, param2:b2Proxy) : Boolean
|
||||
{
|
||||
var _loc4_:int = 0;
|
||||
var _loc3_:Array = null;
|
||||
var _loc5_:b2Bound = null;
|
||||
_loc4_ = 0;
|
||||
while(_loc4_ < 2)
|
||||
{
|
||||
_loc3_ = m_bounds[_loc4_];
|
||||
_loc5_ = _loc3_[param2.upperBounds[_loc4_]];
|
||||
if(param1.lowerValues[_loc4_] > _loc5_.value)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
_loc5_ = _loc3_[param2.lowerBounds[_loc4_]];
|
||||
if(param1.upperValues[_loc4_] < _loc5_.value)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
_loc4_++;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
private function Query(param1:Array, param2:Array, param3:uint, param4:uint, param5:Array, param6:uint, param7:int) : void
|
||||
{
|
||||
var _loc13_:b2Bound = null;
|
||||
var _loc12_:* = 0;
|
||||
var _loc14_:int = 0;
|
||||
var _loc8_:int = 0;
|
||||
var _loc11_:b2Proxy = null;
|
||||
var _loc10_:uint = BinarySearch(param5,param6,param3);
|
||||
var _loc9_:uint = BinarySearch(param5,param6,param4);
|
||||
_loc12_ = _loc10_;
|
||||
while(_loc12_ < _loc9_)
|
||||
{
|
||||
_loc13_ = param5[_loc12_];
|
||||
if(_loc13_.IsLower())
|
||||
{
|
||||
IncrementOverlapCount(_loc13_.proxyId);
|
||||
}
|
||||
_loc12_++;
|
||||
}
|
||||
if(_loc10_ > 0)
|
||||
{
|
||||
_loc14_ = _loc10_ - 1;
|
||||
_loc13_ = param5[_loc14_];
|
||||
_loc8_ = int(_loc13_.stabbingCount);
|
||||
while(_loc8_)
|
||||
{
|
||||
_loc13_ = param5[_loc14_];
|
||||
if(_loc13_.IsLower())
|
||||
{
|
||||
_loc11_ = m_proxyPool[_loc13_.proxyId];
|
||||
if(_loc10_ <= _loc11_.upperBounds[param7])
|
||||
{
|
||||
IncrementOverlapCount(_loc13_.proxyId);
|
||||
_loc8_--;
|
||||
}
|
||||
}
|
||||
_loc14_--;
|
||||
}
|
||||
}
|
||||
param1[0] = _loc10_;
|
||||
param2[0] = _loc9_;
|
||||
}
|
||||
|
||||
private function IncrementOverlapCount(param1:uint) : void
|
||||
{
|
||||
var _loc2_:b2Proxy = m_proxyPool[param1];
|
||||
if(_loc2_.timeStamp < m_timeStamp)
|
||||
{
|
||||
_loc2_.timeStamp = m_timeStamp;
|
||||
_loc2_.overlapCount = 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
_loc2_.overlapCount = 2;
|
||||
m_queryResults[m_queryResultCount] = param1;
|
||||
m_queryResultCount = m_queryResultCount + 1;
|
||||
}
|
||||
}
|
||||
|
||||
private function IncrementTimeStamp() : void
|
||||
{
|
||||
var _loc1_:* = 0;
|
||||
if(m_timeStamp == 65535)
|
||||
{
|
||||
_loc1_ = 0;
|
||||
while(_loc1_ < 512)
|
||||
{
|
||||
(m_proxyPool[_loc1_] as b2Proxy).timeStamp = 0;
|
||||
_loc1_++;
|
||||
}
|
||||
m_timeStamp = 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
m_timeStamp = m_timeStamp + 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,16 @@
|
||||
package Box2D.Collision
|
||||
{
|
||||
public class b2BufferedPair
|
||||
{
|
||||
|
||||
public var proxyId1:uint;
|
||||
|
||||
public var proxyId2:uint;
|
||||
|
||||
public function b2BufferedPair()
|
||||
{
|
||||
super();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,590 @@
|
||||
package Box2D.Collision
|
||||
{
|
||||
import Box2D.Collision.Shapes.*;
|
||||
import Box2D.Common.*;
|
||||
import Box2D.Common.Math.*;
|
||||
|
||||
public class b2Collision
|
||||
{
|
||||
|
||||
public static const b2_nullFeature:uint = 255;
|
||||
|
||||
private static var b2CollidePolyTempVec:b2Vec2 = new b2Vec2();
|
||||
|
||||
public function b2Collision()
|
||||
{
|
||||
super();
|
||||
}
|
||||
|
||||
public static function ClipSegmentToLine(param1:Array, param2:Array, param3:b2Vec2, param4:Number) : int
|
||||
{
|
||||
var _loc11_:ClipVertex = null;
|
||||
var _loc13_:Number = NaN;
|
||||
var _loc12_:b2Vec2 = null;
|
||||
var _loc6_:ClipVertex = null;
|
||||
var _loc8_:int = 0;
|
||||
_loc11_ = param2[0];
|
||||
var _loc9_:b2Vec2 = _loc11_.v;
|
||||
_loc11_ = param2[1];
|
||||
var _loc10_:b2Vec2 = _loc11_.v;
|
||||
var _loc7_:Number = b2Math.b2Dot(param3,_loc9_) - param4;
|
||||
var _loc5_:Number = b2Math.b2Dot(param3,_loc10_) - param4;
|
||||
if(_loc7_ <= 0)
|
||||
{
|
||||
param1[_loc8_++] = param2[0];
|
||||
}
|
||||
if(_loc5_ <= 0)
|
||||
{
|
||||
param1[_loc8_++] = param2[1];
|
||||
}
|
||||
if(_loc7_ * _loc5_ < 0)
|
||||
{
|
||||
_loc13_ = _loc7_ / (_loc7_ - _loc5_);
|
||||
_loc11_ = param1[_loc8_];
|
||||
_loc12_ = _loc11_.v;
|
||||
_loc12_.x = _loc9_.x + _loc13_ * (_loc10_.x - _loc9_.x);
|
||||
_loc12_.y = _loc9_.y + _loc13_ * (_loc10_.y - _loc9_.y);
|
||||
_loc11_ = param1[_loc8_];
|
||||
if(_loc7_ > 0)
|
||||
{
|
||||
_loc6_ = param2[0];
|
||||
_loc11_.id = _loc6_.id;
|
||||
}
|
||||
else
|
||||
{
|
||||
_loc6_ = param2[1];
|
||||
_loc11_.id = _loc6_.id;
|
||||
}
|
||||
_loc8_++;
|
||||
}
|
||||
return _loc8_;
|
||||
}
|
||||
|
||||
public static function EdgeSeparation(param1:b2PolygonShape, param2:b2XForm, param3:int, param4:b2PolygonShape, param5:b2XForm) : Number
|
||||
{
|
||||
var _loc22_:b2Mat22 = null;
|
||||
var _loc18_:b2Vec2 = null;
|
||||
var _loc19_:int = 0;
|
||||
var _loc10_:Number = NaN;
|
||||
var _loc24_:int = param1.m_vertexCount;
|
||||
var _loc7_:Array = param1.m_vertices;
|
||||
var _loc25_:Array = param1.m_normals;
|
||||
var _loc23_:int = param4.m_vertexCount;
|
||||
var _loc6_:Array = param4.m_vertices;
|
||||
_loc22_ = param2.R;
|
||||
_loc18_ = _loc25_[param3];
|
||||
var _loc15_:Number = _loc22_.col1.x * _loc18_.x + _loc22_.col2.x * _loc18_.y;
|
||||
var _loc13_:Number = _loc22_.col1.y * _loc18_.x + _loc22_.col2.y * _loc18_.y;
|
||||
_loc22_ = param5.R;
|
||||
var _loc8_:Number = _loc22_.col1.x * _loc15_ + _loc22_.col1.y * _loc13_;
|
||||
var _loc9_:Number = _loc22_.col2.x * _loc15_ + _loc22_.col2.y * _loc13_;
|
||||
var _loc14_:int = 0;
|
||||
var _loc17_:Number = 1.7976931348623157e+308;
|
||||
_loc19_ = 0;
|
||||
while(_loc19_ < _loc23_)
|
||||
{
|
||||
_loc18_ = _loc6_[_loc19_];
|
||||
_loc10_ = _loc18_.x * _loc8_ + _loc18_.y * _loc9_;
|
||||
if(_loc10_ < _loc17_)
|
||||
{
|
||||
_loc17_ = _loc10_;
|
||||
_loc14_ = _loc19_;
|
||||
}
|
||||
_loc19_++;
|
||||
}
|
||||
_loc18_ = _loc7_[param3];
|
||||
_loc22_ = param2.R;
|
||||
var _loc20_:Number = param2.position.x + (_loc22_.col1.x * _loc18_.x + _loc22_.col2.x * _loc18_.y);
|
||||
var _loc21_:Number = param2.position.y + (_loc22_.col1.y * _loc18_.x + _loc22_.col2.y * _loc18_.y);
|
||||
_loc18_ = _loc6_[_loc14_];
|
||||
_loc22_ = param5.R;
|
||||
var _loc11_:Number = param5.position.x + (_loc22_.col1.x * _loc18_.x + _loc22_.col2.x * _loc18_.y);
|
||||
var _loc12_:Number = param5.position.y + (_loc22_.col1.y * _loc18_.x + _loc22_.col2.y * _loc18_.y);
|
||||
_loc11_ -= _loc20_;
|
||||
_loc12_ -= _loc21_;
|
||||
return _loc11_ * _loc15_ + _loc12_ * _loc13_;
|
||||
}
|
||||
|
||||
public static function FindMaxSeparation(param1:Array, param2:b2PolygonShape, param3:b2XForm, param4:b2PolygonShape, param5:b2XForm) : Number
|
||||
{
|
||||
var _loc17_:b2Vec2 = null;
|
||||
var _loc22_:b2Mat22 = null;
|
||||
var _loc18_:int = 0;
|
||||
var _loc16_:Number = NaN;
|
||||
var _loc14_:int = 0;
|
||||
var _loc7_:Number = NaN;
|
||||
var _loc6_:int = 0;
|
||||
var _loc23_:int = param2.m_vertexCount;
|
||||
var _loc25_:Array = param2.m_normals;
|
||||
_loc22_ = param5.R;
|
||||
_loc17_ = param4.m_centroid;
|
||||
var _loc12_:Number = param5.position.x + (_loc22_.col1.x * _loc17_.x + _loc22_.col2.x * _loc17_.y);
|
||||
var _loc11_:Number = param5.position.y + (_loc22_.col1.y * _loc17_.x + _loc22_.col2.y * _loc17_.y);
|
||||
_loc22_ = param3.R;
|
||||
_loc17_ = param2.m_centroid;
|
||||
_loc12_ -= param3.position.x + (_loc22_.col1.x * _loc17_.x + _loc22_.col2.x * _loc17_.y);
|
||||
_loc11_ -= param3.position.y + (_loc22_.col1.y * _loc17_.x + _loc22_.col2.y * _loc17_.y);
|
||||
var _loc13_:Number = _loc12_ * param3.R.col1.x + _loc11_ * param3.R.col1.y;
|
||||
var _loc10_:Number = _loc12_ * param3.R.col2.x + _loc11_ * param3.R.col2.y;
|
||||
var _loc8_:int = 0;
|
||||
var _loc19_:Number = -1.7976931348623157e+308;
|
||||
_loc18_ = 0;
|
||||
while(_loc18_ < _loc23_)
|
||||
{
|
||||
_loc17_ = _loc25_[_loc18_];
|
||||
_loc16_ = _loc17_.x * _loc13_ + _loc17_.y * _loc10_;
|
||||
if(_loc16_ > _loc19_)
|
||||
{
|
||||
_loc19_ = _loc16_;
|
||||
_loc8_ = _loc18_;
|
||||
}
|
||||
_loc18_++;
|
||||
}
|
||||
var _loc20_:Number = EdgeSeparation(param2,param3,_loc8_,param4,param5);
|
||||
if(_loc20_ > 0)
|
||||
{
|
||||
return _loc20_;
|
||||
}
|
||||
var _loc15_:int = _loc8_ - 1 >= 0 ? _loc8_ - 1 : _loc23_ - 1;
|
||||
var _loc9_:Number = EdgeSeparation(param2,param3,_loc15_,param4,param5);
|
||||
if(_loc9_ > 0)
|
||||
{
|
||||
return _loc9_;
|
||||
}
|
||||
var _loc24_:int = _loc8_ + 1 < _loc23_ ? _loc8_ + 1 : 0;
|
||||
var _loc21_:Number = EdgeSeparation(param2,param3,_loc24_,param4,param5);
|
||||
if(_loc21_ > 0)
|
||||
{
|
||||
return _loc21_;
|
||||
}
|
||||
if(_loc9_ > _loc20_ && _loc9_ > _loc21_)
|
||||
{
|
||||
_loc6_ = -1;
|
||||
_loc14_ = _loc15_;
|
||||
_loc7_ = _loc9_;
|
||||
}
|
||||
else
|
||||
{
|
||||
if(_loc21_ <= _loc20_)
|
||||
{
|
||||
param1[0] = _loc8_;
|
||||
return _loc20_;
|
||||
}
|
||||
_loc6_ = 1;
|
||||
_loc14_ = _loc24_;
|
||||
_loc7_ = _loc21_;
|
||||
}
|
||||
while(true)
|
||||
{
|
||||
if(_loc6_ == -1)
|
||||
{
|
||||
_loc8_ = _loc14_ - 1 >= 0 ? _loc14_ - 1 : _loc23_ - 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
_loc8_ = _loc14_ + 1 < _loc23_ ? _loc14_ + 1 : 0;
|
||||
}
|
||||
_loc20_ = EdgeSeparation(param2,param3,_loc8_,param4,param5);
|
||||
if(_loc20_ > 0)
|
||||
{
|
||||
break;
|
||||
}
|
||||
if(_loc20_ <= _loc7_)
|
||||
{
|
||||
param1[0] = _loc14_;
|
||||
return _loc7_;
|
||||
}
|
||||
_loc14_ = _loc8_;
|
||||
_loc7_ = _loc20_;
|
||||
}
|
||||
return _loc20_;
|
||||
}
|
||||
|
||||
public static function FindIncidentEdge(param1:Array, param2:b2PolygonShape, param3:b2XForm, param4:int, param5:b2PolygonShape, param6:b2XForm) : void
|
||||
{
|
||||
var _loc16_:b2Mat22 = null;
|
||||
var _loc13_:b2Vec2 = null;
|
||||
var _loc14_:int = 0;
|
||||
var _loc12_:Number = NaN;
|
||||
var _loc15_:ClipVertex = null;
|
||||
var _loc18_:int = param2.m_vertexCount;
|
||||
var _loc23_:Array = param2.m_normals;
|
||||
var _loc17_:int = param5.m_vertexCount;
|
||||
var _loc8_:Array = param5.m_vertices;
|
||||
var _loc19_:Array = param5.m_normals;
|
||||
_loc16_ = param3.R;
|
||||
_loc13_ = _loc23_[param4];
|
||||
var _loc9_:Number = _loc16_.col1.x * _loc13_.x + _loc16_.col2.x * _loc13_.y;
|
||||
var _loc10_:Number = _loc16_.col1.y * _loc13_.x + _loc16_.col2.y * _loc13_.y;
|
||||
_loc16_ = param6.R;
|
||||
var _loc21_:Number = _loc16_.col1.x * _loc9_ + _loc16_.col1.y * _loc10_;
|
||||
_loc10_ = _loc16_.col2.x * _loc9_ + _loc16_.col2.y * _loc10_;
|
||||
_loc9_ = _loc21_;
|
||||
var _loc7_:int = 0;
|
||||
var _loc11_:Number = 1.7976931348623157e+308;
|
||||
_loc14_ = 0;
|
||||
while(_loc14_ < _loc17_)
|
||||
{
|
||||
_loc13_ = _loc19_[_loc14_];
|
||||
_loc12_ = _loc9_ * _loc13_.x + _loc10_ * _loc13_.y;
|
||||
if(_loc12_ < _loc11_)
|
||||
{
|
||||
_loc11_ = _loc12_;
|
||||
_loc7_ = _loc14_;
|
||||
}
|
||||
_loc14_++;
|
||||
}
|
||||
var _loc22_:int = _loc7_;
|
||||
var _loc20_:int = _loc22_ + 1 < _loc17_ ? _loc22_ + 1 : 0;
|
||||
_loc15_ = param1[0];
|
||||
_loc13_ = _loc8_[_loc22_];
|
||||
_loc16_ = param6.R;
|
||||
_loc15_.v.x = param6.position.x + (_loc16_.col1.x * _loc13_.x + _loc16_.col2.x * _loc13_.y);
|
||||
_loc15_.v.y = param6.position.y + (_loc16_.col1.y * _loc13_.x + _loc16_.col2.y * _loc13_.y);
|
||||
_loc15_.id.features.referenceEdge = param4;
|
||||
_loc15_.id.features.incidentEdge = _loc22_;
|
||||
_loc15_.id.features.incidentVertex = 0;
|
||||
_loc15_ = param1[1];
|
||||
_loc13_ = _loc8_[_loc20_];
|
||||
_loc16_ = param6.R;
|
||||
_loc15_.v.x = param6.position.x + (_loc16_.col1.x * _loc13_.x + _loc16_.col2.x * _loc13_.y);
|
||||
_loc15_.v.y = param6.position.y + (_loc16_.col1.y * _loc13_.x + _loc16_.col2.y * _loc13_.y);
|
||||
_loc15_.id.features.referenceEdge = param4;
|
||||
_loc15_.id.features.incidentEdge = _loc20_;
|
||||
_loc15_.id.features.incidentVertex = 1;
|
||||
}
|
||||
|
||||
public static function b2CollidePolygons(param1:b2Manifold, param2:b2PolygonShape, param3:b2XForm, param4:b2PolygonShape, param5:b2XForm) : void
|
||||
{
|
||||
var _loc30_:ClipVertex = null;
|
||||
var _loc28_:b2PolygonShape = null;
|
||||
var _loc29_:b2PolygonShape = null;
|
||||
var _loc13_:int = 0;
|
||||
var _loc20_:* = 0;
|
||||
var _loc10_:Number = NaN;
|
||||
_loc10_ = 0.98;
|
||||
var _loc11_:Number = NaN;
|
||||
_loc11_ = 0.001;
|
||||
var _loc17_:b2Vec2 = null;
|
||||
var _loc8_:int = 0;
|
||||
var _loc32_:int = 0;
|
||||
var _loc27_:Number = NaN;
|
||||
var _loc34_:b2ManifoldPoint = null;
|
||||
param1.pointCount = 0;
|
||||
var _loc22_:int = 0;
|
||||
var _loc14_:Array = [_loc22_];
|
||||
var _loc15_:Number = FindMaxSeparation(_loc14_,param2,param3,param4,param5);
|
||||
_loc22_ = int(_loc14_[0]);
|
||||
if(_loc15_ > 0)
|
||||
{
|
||||
return;
|
||||
}
|
||||
var _loc21_:int = 0;
|
||||
var _loc36_:Array = [_loc21_];
|
||||
var _loc12_:Number = FindMaxSeparation(_loc36_,param4,param5,param2,param3);
|
||||
_loc21_ = int(_loc36_[0]);
|
||||
if(_loc12_ > 0)
|
||||
{
|
||||
return;
|
||||
}
|
||||
var _loc33_:b2XForm = new b2XForm();
|
||||
var _loc37_:b2XForm = new b2XForm();
|
||||
if(_loc12_ > 0.98 * _loc15_ + 0.001)
|
||||
{
|
||||
_loc28_ = param4;
|
||||
_loc29_ = param2;
|
||||
_loc33_.Set(param5);
|
||||
_loc37_.Set(param3);
|
||||
_loc13_ = _loc21_;
|
||||
_loc20_ = 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
_loc28_ = param2;
|
||||
_loc29_ = param4;
|
||||
_loc33_.Set(param3);
|
||||
_loc37_.Set(param5);
|
||||
_loc13_ = _loc22_;
|
||||
_loc20_ = 0;
|
||||
}
|
||||
var _loc24_:Array = [new ClipVertex(),new ClipVertex()];
|
||||
FindIncidentEdge(_loc24_,_loc28_,_loc33_,_loc13_,_loc29_,_loc37_);
|
||||
var _loc38_:int = _loc28_.m_vertexCount;
|
||||
var _loc9_:Array = _loc28_.m_vertices;
|
||||
var _loc31_:b2Vec2 = _loc9_[_loc13_];
|
||||
var _loc16_:b2Vec2 = _loc31_.Copy();
|
||||
if(_loc13_ + 1 < _loc38_)
|
||||
{
|
||||
_loc31_ = _loc9_[int(_loc13_ + 1)];
|
||||
_loc17_ = _loc31_.Copy();
|
||||
}
|
||||
else
|
||||
{
|
||||
_loc31_ = _loc9_[0];
|
||||
_loc17_ = _loc31_.Copy();
|
||||
}
|
||||
var _loc7_:b2Vec2 = b2Math.SubtractVV(_loc17_,_loc16_);
|
||||
var _loc6_:b2Vec2 = b2Math.b2MulMV(_loc33_.R,b2Math.SubtractVV(_loc17_,_loc16_));
|
||||
_loc6_.Normalize();
|
||||
var _loc23_:b2Vec2 = b2Math.b2CrossVF(_loc6_,1);
|
||||
_loc16_ = b2Math.b2MulX(_loc33_,_loc16_);
|
||||
_loc17_ = b2Math.b2MulX(_loc33_,_loc17_);
|
||||
var _loc19_:Number = b2Math.b2Dot(_loc23_,_loc16_);
|
||||
var _loc35_:Number = -b2Math.b2Dot(_loc6_,_loc16_);
|
||||
var _loc39_:Number = b2Math.b2Dot(_loc6_,_loc17_);
|
||||
var _loc25_:Array = [new ClipVertex(),new ClipVertex()];
|
||||
var _loc26_:Array = [new ClipVertex(),new ClipVertex()];
|
||||
_loc8_ = ClipSegmentToLine(_loc25_,_loc24_,_loc6_.Negative(),_loc35_);
|
||||
if(_loc8_ < 2)
|
||||
{
|
||||
return;
|
||||
}
|
||||
_loc8_ = ClipSegmentToLine(_loc26_,_loc25_,_loc6_,_loc39_);
|
||||
if(_loc8_ < 2)
|
||||
{
|
||||
return;
|
||||
}
|
||||
param1.normal = _loc20_ ? _loc23_.Negative() : _loc23_.Copy();
|
||||
var _loc18_:int = 0;
|
||||
_loc32_ = 0;
|
||||
while(_loc32_ < 2)
|
||||
{
|
||||
_loc30_ = _loc26_[_loc32_];
|
||||
_loc27_ = b2Math.b2Dot(_loc23_,_loc30_.v) - _loc19_;
|
||||
if(_loc27_ <= 0)
|
||||
{
|
||||
_loc34_ = param1.points[_loc18_];
|
||||
_loc34_.separation = _loc27_;
|
||||
_loc34_.localPoint1 = b2Math.b2MulXT(param3,_loc30_.v);
|
||||
_loc34_.localPoint2 = b2Math.b2MulXT(param5,_loc30_.v);
|
||||
_loc34_.id.key = _loc30_.id._key;
|
||||
_loc34_.id.features.flip = _loc20_;
|
||||
_loc18_++;
|
||||
}
|
||||
_loc32_++;
|
||||
}
|
||||
param1.pointCount = _loc18_;
|
||||
}
|
||||
|
||||
public static function b2CollideCircles(param1:b2Manifold, param2:b2CircleShape, param3:b2XForm, param4:b2CircleShape, param5:b2XForm) : void
|
||||
{
|
||||
var _loc22_:b2Mat22 = null;
|
||||
var _loc19_:b2Vec2 = null;
|
||||
var _loc13_:Number = NaN;
|
||||
var _loc25_:Number = NaN;
|
||||
var _loc14_:Number = NaN;
|
||||
param1.pointCount = 0;
|
||||
_loc22_ = param3.R;
|
||||
_loc19_ = param2.m_localPosition;
|
||||
var _loc7_:Number = param3.position.x + (_loc22_.col1.x * _loc19_.x + _loc22_.col2.x * _loc19_.y);
|
||||
var _loc9_:Number = param3.position.y + (_loc22_.col1.y * _loc19_.x + _loc22_.col2.y * _loc19_.y);
|
||||
_loc22_ = param5.R;
|
||||
_loc19_ = param4.m_localPosition;
|
||||
var _loc21_:Number = param5.position.x + (_loc22_.col1.x * _loc19_.x + _loc22_.col2.x * _loc19_.y);
|
||||
var _loc20_:Number = param5.position.y + (_loc22_.col1.y * _loc19_.x + _loc22_.col2.y * _loc19_.y);
|
||||
var _loc16_:Number = _loc21_ - _loc7_;
|
||||
var _loc15_:Number = _loc20_ - _loc9_;
|
||||
var _loc8_:Number = _loc16_ * _loc16_ + _loc15_ * _loc15_;
|
||||
var _loc23_:Number = param2.m_radius;
|
||||
var _loc24_:Number = param4.m_radius;
|
||||
var _loc10_:Number = _loc23_ + _loc24_;
|
||||
if(_loc8_ > _loc10_ * _loc10_)
|
||||
{
|
||||
return;
|
||||
}
|
||||
if(_loc8_ < Number.MIN_VALUE)
|
||||
{
|
||||
_loc13_ = -_loc10_;
|
||||
param1.normal.Set(0,1);
|
||||
}
|
||||
else
|
||||
{
|
||||
_loc25_ = Math.sqrt(_loc8_);
|
||||
_loc13_ = _loc25_ - _loc10_;
|
||||
_loc14_ = 1 / _loc25_;
|
||||
param1.normal.x = _loc14_ * _loc16_;
|
||||
param1.normal.y = _loc14_ * _loc15_;
|
||||
}
|
||||
param1.pointCount = 1;
|
||||
var _loc6_:b2ManifoldPoint = param1.points[0];
|
||||
_loc6_.id.key = 0;
|
||||
_loc6_.separation = _loc13_;
|
||||
_loc7_ += _loc23_ * param1.normal.x;
|
||||
_loc9_ += _loc23_ * param1.normal.y;
|
||||
_loc21_ -= _loc24_ * param1.normal.x;
|
||||
_loc20_ -= _loc24_ * param1.normal.y;
|
||||
var _loc18_:Number = 0.5 * (_loc7_ + _loc21_);
|
||||
var _loc17_:Number = 0.5 * (_loc9_ + _loc20_);
|
||||
var _loc11_:Number = _loc18_ - param3.position.x;
|
||||
var _loc12_:Number = _loc17_ - param3.position.y;
|
||||
_loc6_.localPoint1.x = _loc11_ * param3.R.col1.x + _loc12_ * param3.R.col1.y;
|
||||
_loc6_.localPoint1.y = _loc11_ * param3.R.col2.x + _loc12_ * param3.R.col2.y;
|
||||
_loc11_ = _loc18_ - param5.position.x;
|
||||
_loc12_ = _loc17_ - param5.position.y;
|
||||
_loc6_.localPoint2.x = _loc11_ * param5.R.col1.x + _loc12_ * param5.R.col1.y;
|
||||
_loc6_.localPoint2.y = _loc11_ * param5.R.col2.x + _loc12_ * param5.R.col2.y;
|
||||
}
|
||||
|
||||
public static function b2CollidePolygonAndCircle(param1:b2Manifold, param2:b2PolygonShape, param3:b2XForm, param4:b2CircleShape, param5:b2XForm) : void
|
||||
{
|
||||
var _loc12_:b2ManifoldPoint = null;
|
||||
var _loc18_:Number = NaN;
|
||||
var _loc17_:Number = NaN;
|
||||
var _loc13_:Number = NaN;
|
||||
var _loc9_:Number = NaN;
|
||||
var _loc23_:b2Vec2 = null;
|
||||
var _loc29_:b2Mat22 = null;
|
||||
var _loc34_:Number = NaN;
|
||||
var _loc24_:int = 0;
|
||||
var _loc28_:Number = NaN;
|
||||
var _loc19_:Number = NaN;
|
||||
var _loc21_:Number = NaN;
|
||||
param1.pointCount = 0;
|
||||
_loc29_ = param5.R;
|
||||
_loc23_ = param4.m_localPosition;
|
||||
var _loc10_:Number = param5.position.x + (_loc29_.col1.x * _loc23_.x + _loc29_.col2.x * _loc23_.y);
|
||||
var _loc11_:Number = param5.position.y + (_loc29_.col1.y * _loc23_.x + _loc29_.col2.y * _loc23_.y);
|
||||
_loc18_ = _loc10_ - param3.position.x;
|
||||
_loc17_ = _loc11_ - param3.position.y;
|
||||
_loc29_ = param3.R;
|
||||
var _loc33_:Number = _loc18_ * _loc29_.col1.x + _loc17_ * _loc29_.col1.y;
|
||||
var _loc32_:Number = _loc18_ * _loc29_.col2.x + _loc17_ * _loc29_.col2.y;
|
||||
var _loc30_:* = 0;
|
||||
var _loc16_:Number = -1.7976931348623157e+308;
|
||||
var _loc31_:Number = param4.m_radius;
|
||||
var _loc25_:int = param2.m_vertexCount;
|
||||
var _loc8_:Array = param2.m_vertices;
|
||||
var _loc27_:Array = param2.m_normals;
|
||||
_loc24_ = 0;
|
||||
while(_loc24_ < _loc25_)
|
||||
{
|
||||
_loc23_ = _loc8_[_loc24_];
|
||||
_loc18_ = _loc33_ - _loc23_.x;
|
||||
_loc17_ = _loc32_ - _loc23_.y;
|
||||
_loc23_ = _loc27_[_loc24_];
|
||||
_loc28_ = _loc23_.x * _loc18_ + _loc23_.y * _loc17_;
|
||||
if(_loc28_ > _loc31_)
|
||||
{
|
||||
return;
|
||||
}
|
||||
if(_loc28_ > _loc16_)
|
||||
{
|
||||
_loc16_ = _loc28_;
|
||||
_loc30_ = _loc24_;
|
||||
}
|
||||
_loc24_++;
|
||||
}
|
||||
if(_loc16_ < Number.MIN_VALUE)
|
||||
{
|
||||
param1.pointCount = 1;
|
||||
_loc23_ = _loc27_[_loc30_];
|
||||
_loc29_ = param3.R;
|
||||
param1.normal.x = _loc29_.col1.x * _loc23_.x + _loc29_.col2.x * _loc23_.y;
|
||||
param1.normal.y = _loc29_.col1.y * _loc23_.x + _loc29_.col2.y * _loc23_.y;
|
||||
_loc12_ = param1.points[0];
|
||||
_loc12_.id.features.incidentEdge = _loc30_;
|
||||
_loc12_.id.features.incidentVertex = 255;
|
||||
_loc12_.id.features.referenceEdge = 0;
|
||||
_loc12_.id.features.flip = 0;
|
||||
_loc13_ = _loc10_ - _loc31_ * param1.normal.x;
|
||||
_loc9_ = _loc11_ - _loc31_ * param1.normal.y;
|
||||
_loc18_ = _loc13_ - param3.position.x;
|
||||
_loc17_ = _loc9_ - param3.position.y;
|
||||
_loc29_ = param3.R;
|
||||
_loc12_.localPoint1.x = _loc18_ * _loc29_.col1.x + _loc17_ * _loc29_.col1.y;
|
||||
_loc12_.localPoint1.y = _loc18_ * _loc29_.col2.x + _loc17_ * _loc29_.col2.y;
|
||||
_loc18_ = _loc13_ - param5.position.x;
|
||||
_loc17_ = _loc9_ - param5.position.y;
|
||||
_loc29_ = param5.R;
|
||||
_loc12_.localPoint2.x = _loc18_ * _loc29_.col1.x + _loc17_ * _loc29_.col1.y;
|
||||
_loc12_.localPoint2.y = _loc18_ * _loc29_.col2.x + _loc17_ * _loc29_.col2.y;
|
||||
_loc12_.separation = _loc16_ - _loc31_;
|
||||
return;
|
||||
}
|
||||
var _loc20_:Number = _loc30_;
|
||||
var _loc22_:int = _loc20_ + 1 < _loc25_ ? _loc20_ + 1 : 0;
|
||||
_loc23_ = _loc8_[_loc20_];
|
||||
var _loc15_:b2Vec2 = _loc8_[_loc22_];
|
||||
var _loc6_:Number = _loc15_.x - _loc23_.x;
|
||||
var _loc7_:Number = _loc15_.y - _loc23_.y;
|
||||
var _loc14_:Number = Math.sqrt(_loc6_ * _loc6_ + _loc7_ * _loc7_);
|
||||
_loc6_ /= _loc14_;
|
||||
_loc7_ /= _loc14_;
|
||||
_loc18_ = _loc33_ - _loc23_.x;
|
||||
_loc17_ = _loc32_ - _loc23_.y;
|
||||
var _loc26_:Number = _loc18_ * _loc6_ + _loc17_ * _loc7_;
|
||||
_loc12_ = param1.points[0];
|
||||
if(_loc26_ <= 0)
|
||||
{
|
||||
_loc21_ = _loc23_.x;
|
||||
_loc19_ = _loc23_.y;
|
||||
_loc12_.id.features.incidentEdge = 255;
|
||||
_loc12_.id.features.incidentVertex = _loc20_;
|
||||
}
|
||||
else if(_loc26_ >= _loc14_)
|
||||
{
|
||||
_loc21_ = _loc15_.x;
|
||||
_loc19_ = _loc15_.y;
|
||||
_loc12_.id.features.incidentEdge = 255;
|
||||
_loc12_.id.features.incidentVertex = _loc22_;
|
||||
}
|
||||
else
|
||||
{
|
||||
_loc21_ = _loc6_ * _loc26_ + _loc23_.x;
|
||||
_loc19_ = _loc7_ * _loc26_ + _loc23_.y;
|
||||
_loc12_.id.features.incidentEdge = _loc30_;
|
||||
_loc12_.id.features.incidentVertex = 255;
|
||||
}
|
||||
_loc18_ = _loc33_ - _loc21_;
|
||||
_loc17_ = _loc32_ - _loc19_;
|
||||
_loc34_ = Math.sqrt(_loc18_ * _loc18_ + _loc17_ * _loc17_);
|
||||
_loc18_ /= _loc34_;
|
||||
_loc17_ /= _loc34_;
|
||||
if(_loc34_ > _loc31_)
|
||||
{
|
||||
return;
|
||||
}
|
||||
param1.pointCount = 1;
|
||||
_loc29_ = param3.R;
|
||||
param1.normal.x = _loc29_.col1.x * _loc18_ + _loc29_.col2.x * _loc17_;
|
||||
param1.normal.y = _loc29_.col1.y * _loc18_ + _loc29_.col2.y * _loc17_;
|
||||
_loc13_ = _loc10_ - _loc31_ * param1.normal.x;
|
||||
_loc9_ = _loc11_ - _loc31_ * param1.normal.y;
|
||||
_loc18_ = _loc13_ - param3.position.x;
|
||||
_loc17_ = _loc9_ - param3.position.y;
|
||||
_loc29_ = param3.R;
|
||||
_loc12_.localPoint1.x = _loc18_ * _loc29_.col1.x + _loc17_ * _loc29_.col1.y;
|
||||
_loc12_.localPoint1.y = _loc18_ * _loc29_.col2.x + _loc17_ * _loc29_.col2.y;
|
||||
_loc18_ = _loc13_ - param5.position.x;
|
||||
_loc17_ = _loc9_ - param5.position.y;
|
||||
_loc29_ = param5.R;
|
||||
_loc12_.localPoint2.x = _loc18_ * _loc29_.col1.x + _loc17_ * _loc29_.col1.y;
|
||||
_loc12_.localPoint2.y = _loc18_ * _loc29_.col2.x + _loc17_ * _loc29_.col2.y;
|
||||
_loc12_.separation = _loc34_ - _loc31_;
|
||||
_loc12_.id.features.referenceEdge = 0;
|
||||
_loc12_.id.features.flip = 0;
|
||||
}
|
||||
|
||||
public static function b2TestOverlap(param1:b2AABB, param2:b2AABB) : Boolean
|
||||
{
|
||||
var _loc4_:b2Vec2 = param2.lowerBound;
|
||||
var _loc3_:b2Vec2 = param1.upperBound;
|
||||
var _loc8_:Number = _loc4_.x - _loc3_.x;
|
||||
var _loc7_:Number = _loc4_.y - _loc3_.y;
|
||||
_loc4_ = param1.lowerBound;
|
||||
_loc3_ = param2.upperBound;
|
||||
var _loc6_:Number = _loc4_.x - _loc3_.x;
|
||||
var _loc5_:Number = _loc4_.y - _loc3_.y;
|
||||
if(_loc8_ > 0 || _loc7_ > 0)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
if(_loc6_ > 0 || _loc5_ > 0)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,43 @@
|
||||
package Box2D.Collision
|
||||
{
|
||||
public class b2ContactID
|
||||
{
|
||||
|
||||
public var features:Features = new Features();
|
||||
|
||||
public var _key:uint;
|
||||
|
||||
public function b2ContactID()
|
||||
{
|
||||
super();
|
||||
features._m_id = this;
|
||||
}
|
||||
|
||||
public function Set(param1:b2ContactID) : void
|
||||
{
|
||||
key = param1._key;
|
||||
}
|
||||
|
||||
public function Copy() : b2ContactID
|
||||
{
|
||||
var _loc1_:b2ContactID = new b2ContactID();
|
||||
_loc1_.key = key;
|
||||
return _loc1_;
|
||||
}
|
||||
|
||||
public function get key() : uint
|
||||
{
|
||||
return _key;
|
||||
}
|
||||
|
||||
public function set key(param1:uint) : void
|
||||
{
|
||||
_key = param1;
|
||||
features._referenceEdge = _key & 0xFF;
|
||||
features._incidentEdge = (_key & 0xFF00) >> 8 & 0xFF;
|
||||
features._incidentVertex = (_key & 0xFF0000) >> 16 & 0xFF;
|
||||
features._flip = (_key & 0xFF000000) >> 24 & 0xFF;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,33 @@
|
||||
package Box2D.Collision
|
||||
{
|
||||
import Box2D.Collision.Shapes.b2Shape;
|
||||
import Box2D.Common.Math.b2Vec2;
|
||||
|
||||
public class b2ContactPoint
|
||||
{
|
||||
|
||||
public var shape1:b2Shape;
|
||||
|
||||
public var shape2:b2Shape;
|
||||
|
||||
public var position:b2Vec2 = new b2Vec2();
|
||||
|
||||
public var velocity:b2Vec2 = new b2Vec2();
|
||||
|
||||
public var normal:b2Vec2 = new b2Vec2();
|
||||
|
||||
public var separation:Number;
|
||||
|
||||
public var friction:Number;
|
||||
|
||||
public var restitution:Number;
|
||||
|
||||
public var id:b2ContactID = new b2ContactID();
|
||||
|
||||
public function b2ContactPoint()
|
||||
{
|
||||
super();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,375 @@
|
||||
package Box2D.Collision
|
||||
{
|
||||
import Box2D.Collision.Shapes.*;
|
||||
import Box2D.Common.*;
|
||||
import Box2D.Common.Math.*;
|
||||
|
||||
public class b2Distance
|
||||
{
|
||||
|
||||
public static var g_GJK_Iterations:int = 0;
|
||||
|
||||
private static var s_p1s:Array = [new b2Vec2(),new b2Vec2(),new b2Vec2()];
|
||||
|
||||
private static var s_p2s:Array = [new b2Vec2(),new b2Vec2(),new b2Vec2()];
|
||||
|
||||
private static var s_points:Array = [new b2Vec2(),new b2Vec2(),new b2Vec2()];
|
||||
|
||||
private static var gPoint:b2Point = new b2Point();
|
||||
|
||||
public function b2Distance()
|
||||
{
|
||||
super();
|
||||
}
|
||||
|
||||
public static function ProcessTwo(param1:b2Vec2, param2:b2Vec2, param3:Array, param4:Array, param5:Array) : int
|
||||
{
|
||||
var _loc6_:b2Vec2 = param5[0];
|
||||
var _loc7_:b2Vec2 = param5[1];
|
||||
var _loc15_:b2Vec2 = param3[0];
|
||||
var _loc17_:b2Vec2 = param3[1];
|
||||
var _loc16_:b2Vec2 = param4[0];
|
||||
var _loc14_:b2Vec2 = param4[1];
|
||||
var _loc12_:Number = -_loc7_.x;
|
||||
var _loc13_:Number = -_loc7_.y;
|
||||
var _loc9_:Number = _loc6_.x - _loc7_.x;
|
||||
var _loc8_:Number = _loc6_.y - _loc7_.y;
|
||||
var _loc11_:Number = Math.sqrt(_loc9_ * _loc9_ + _loc8_ * _loc8_);
|
||||
_loc9_ /= _loc11_;
|
||||
_loc8_ /= _loc11_;
|
||||
var _loc10_:Number = _loc12_ * _loc9_ + _loc13_ * _loc8_;
|
||||
if(_loc10_ <= 0 || _loc11_ < Number.MIN_VALUE)
|
||||
{
|
||||
param1.SetV(_loc17_);
|
||||
param2.SetV(_loc14_);
|
||||
_loc15_.SetV(_loc17_);
|
||||
_loc16_.SetV(_loc14_);
|
||||
_loc6_.SetV(_loc7_);
|
||||
return 1;
|
||||
}
|
||||
_loc10_ /= _loc11_;
|
||||
param1.x = _loc17_.x + _loc10_ * (_loc15_.x - _loc17_.x);
|
||||
param1.y = _loc17_.y + _loc10_ * (_loc15_.y - _loc17_.y);
|
||||
param2.x = _loc14_.x + _loc10_ * (_loc16_.x - _loc14_.x);
|
||||
param2.y = _loc14_.y + _loc10_ * (_loc16_.y - _loc14_.y);
|
||||
return 2;
|
||||
}
|
||||
|
||||
public static function ProcessThree(param1:b2Vec2, param2:b2Vec2, param3:Array, param4:Array, param5:Array) : int
|
||||
{
|
||||
var _loc16_:Number = NaN;
|
||||
var _loc6_:b2Vec2 = param5[0];
|
||||
var _loc8_:b2Vec2 = param5[1];
|
||||
var _loc10_:b2Vec2 = param5[2];
|
||||
var _loc37_:b2Vec2 = param3[0];
|
||||
var _loc39_:b2Vec2 = param3[1];
|
||||
var _loc40_:b2Vec2 = param3[2];
|
||||
var _loc36_:b2Vec2 = param4[0];
|
||||
var _loc35_:b2Vec2 = param4[1];
|
||||
var _loc41_:b2Vec2 = param4[2];
|
||||
var _loc14_:Number = _loc6_.x;
|
||||
var _loc9_:Number = _loc6_.y;
|
||||
var _loc29_:Number = _loc8_.x;
|
||||
var _loc27_:Number = _loc8_.y;
|
||||
var _loc11_:Number = _loc10_.x;
|
||||
var _loc13_:Number = _loc10_.y;
|
||||
var _loc33_:Number = _loc29_ - _loc14_;
|
||||
var _loc38_:Number = _loc27_ - _loc9_;
|
||||
var _loc19_:Number = _loc11_ - _loc14_;
|
||||
var _loc18_:Number = _loc13_ - _loc9_;
|
||||
var _loc21_:Number = _loc11_ - _loc29_;
|
||||
var _loc17_:Number = _loc13_ - _loc27_;
|
||||
var _loc24_:Number = -(_loc14_ * _loc33_ + _loc9_ * _loc38_);
|
||||
var _loc26_:Number = _loc29_ * _loc33_ + _loc27_ * _loc38_;
|
||||
var _loc7_:Number = -(_loc14_ * _loc19_ + _loc9_ * _loc18_);
|
||||
var _loc12_:Number = _loc11_ * _loc19_ + _loc13_ * _loc18_;
|
||||
var _loc28_:Number = -(_loc29_ * _loc21_ + _loc27_ * _loc17_);
|
||||
var _loc34_:Number = _loc11_ * _loc21_ + _loc13_ * _loc17_;
|
||||
if(_loc12_ <= 0 && _loc34_ <= 0)
|
||||
{
|
||||
param1.SetV(_loc40_);
|
||||
param2.SetV(_loc41_);
|
||||
_loc37_.SetV(_loc40_);
|
||||
_loc36_.SetV(_loc41_);
|
||||
_loc6_.SetV(_loc10_);
|
||||
return 1;
|
||||
}
|
||||
var _loc25_:Number = _loc33_ * _loc18_ - _loc38_ * _loc19_;
|
||||
var _loc20_:Number = _loc25_ * (_loc14_ * _loc27_ - _loc9_ * _loc29_);
|
||||
var _loc23_:Number = _loc25_ * (_loc29_ * _loc13_ - _loc27_ * _loc11_);
|
||||
if(_loc23_ <= 0 && _loc28_ >= 0 && _loc34_ >= 0 && _loc28_ + _loc34_ > 0)
|
||||
{
|
||||
_loc16_ = _loc28_ / (_loc28_ + _loc34_);
|
||||
param1.x = _loc39_.x + _loc16_ * (_loc40_.x - _loc39_.x);
|
||||
param1.y = _loc39_.y + _loc16_ * (_loc40_.y - _loc39_.y);
|
||||
param2.x = _loc35_.x + _loc16_ * (_loc41_.x - _loc35_.x);
|
||||
param2.y = _loc35_.y + _loc16_ * (_loc41_.y - _loc35_.y);
|
||||
_loc37_.SetV(_loc40_);
|
||||
_loc36_.SetV(_loc41_);
|
||||
_loc6_.SetV(_loc10_);
|
||||
return 2;
|
||||
}
|
||||
var _loc22_:Number = _loc25_ * (_loc11_ * _loc9_ - _loc13_ * _loc14_);
|
||||
if(_loc22_ <= 0 && _loc7_ >= 0 && _loc12_ >= 0 && _loc7_ + _loc12_ > 0)
|
||||
{
|
||||
_loc16_ = _loc7_ / (_loc7_ + _loc12_);
|
||||
param1.x = _loc37_.x + _loc16_ * (_loc40_.x - _loc37_.x);
|
||||
param1.y = _loc37_.y + _loc16_ * (_loc40_.y - _loc37_.y);
|
||||
param2.x = _loc36_.x + _loc16_ * (_loc41_.x - _loc36_.x);
|
||||
param2.y = _loc36_.y + _loc16_ * (_loc41_.y - _loc36_.y);
|
||||
_loc39_.SetV(_loc40_);
|
||||
_loc35_.SetV(_loc41_);
|
||||
_loc8_.SetV(_loc10_);
|
||||
return 2;
|
||||
}
|
||||
var _loc15_:Number = _loc23_ + _loc22_ + _loc20_;
|
||||
_loc15_ = 1 / _loc15_;
|
||||
var _loc32_:Number = _loc23_ * _loc15_;
|
||||
var _loc31_:Number = _loc22_ * _loc15_;
|
||||
var _loc30_:Number = 1 - _loc32_ - _loc31_;
|
||||
param1.x = _loc32_ * _loc37_.x + _loc31_ * _loc39_.x + _loc30_ * _loc40_.x;
|
||||
param1.y = _loc32_ * _loc37_.y + _loc31_ * _loc39_.y + _loc30_ * _loc40_.y;
|
||||
param2.x = _loc32_ * _loc36_.x + _loc31_ * _loc35_.x + _loc30_ * _loc41_.x;
|
||||
param2.y = _loc32_ * _loc36_.y + _loc31_ * _loc35_.y + _loc30_ * _loc41_.y;
|
||||
return 3;
|
||||
}
|
||||
|
||||
public static function InPoints(param1:b2Vec2, param2:Array, param3:int) : Boolean
|
||||
{
|
||||
var _loc10_:int = 0;
|
||||
var _loc7_:b2Vec2 = null;
|
||||
var _loc6_:Number = NaN;
|
||||
var _loc5_:Number = NaN;
|
||||
var _loc4_:Number = NaN;
|
||||
var _loc9_:Number = NaN;
|
||||
var _loc8_:Number = 100 * Number.MIN_VALUE;
|
||||
_loc10_ = 0;
|
||||
while(_loc10_ < param3)
|
||||
{
|
||||
_loc7_ = param2[_loc10_];
|
||||
_loc6_ = Math.abs(param1.x - _loc7_.x);
|
||||
_loc5_ = Math.abs(param1.y - _loc7_.y);
|
||||
_loc4_ = Math.max(Math.abs(param1.x),Math.abs(_loc7_.x));
|
||||
_loc9_ = Math.max(Math.abs(param1.y),Math.abs(_loc7_.y));
|
||||
if(_loc6_ < _loc8_ * (_loc4_ + 1) && _loc5_ < _loc8_ * (_loc9_ + 1))
|
||||
{
|
||||
return true;
|
||||
}
|
||||
_loc10_++;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
public static function DistanceGeneric(param1:b2Vec2, param2:b2Vec2, param3:*, param4:b2XForm, param5:*, param6:b2XForm) : Number
|
||||
{
|
||||
var _loc11_:b2Vec2 = null;
|
||||
var _loc9_:int = 0;
|
||||
_loc9_ = 20;
|
||||
var _loc22_:int = 0;
|
||||
var _loc20_:Number = NaN;
|
||||
var _loc19_:Number = NaN;
|
||||
var _loc10_:b2Vec2 = null;
|
||||
var _loc13_:b2Vec2 = null;
|
||||
var _loc15_:Number = NaN;
|
||||
var _loc18_:Number = NaN;
|
||||
var _loc14_:Number = NaN;
|
||||
var _loc7_:Number = NaN;
|
||||
var _loc12_:int = 0;
|
||||
var _loc17_:Array = s_p1s;
|
||||
var _loc16_:Array = s_p2s;
|
||||
var _loc21_:Array = s_points;
|
||||
var _loc23_:int = 0;
|
||||
param1.SetV(param3.GetFirstVertex(param4));
|
||||
param2.SetV(param5.GetFirstVertex(param6));
|
||||
var _loc8_:Number = 0;
|
||||
_loc22_ = 0;
|
||||
while(_loc22_ < 20)
|
||||
{
|
||||
_loc20_ = param2.x - param1.x;
|
||||
_loc19_ = param2.y - param1.y;
|
||||
_loc10_ = param3.Support(param4,_loc20_,_loc19_);
|
||||
_loc13_ = param5.Support(param6,-_loc20_,-_loc19_);
|
||||
_loc8_ = _loc20_ * _loc20_ + _loc19_ * _loc19_;
|
||||
_loc15_ = _loc13_.x - _loc10_.x;
|
||||
_loc18_ = _loc13_.y - _loc10_.y;
|
||||
_loc14_ = _loc20_ * _loc15_ + _loc19_ * _loc18_;
|
||||
if(_loc8_ - _loc14_ <= 0.01 * _loc8_)
|
||||
{
|
||||
if(_loc23_ == 0)
|
||||
{
|
||||
param1.SetV(_loc10_);
|
||||
param2.SetV(_loc13_);
|
||||
}
|
||||
g_GJK_Iterations = _loc22_;
|
||||
return Math.sqrt(_loc8_);
|
||||
}
|
||||
switch(_loc23_)
|
||||
{
|
||||
case 0:
|
||||
_loc11_ = _loc17_[0];
|
||||
_loc11_.SetV(_loc10_);
|
||||
_loc11_ = _loc16_[0];
|
||||
_loc11_.SetV(_loc13_);
|
||||
_loc11_ = _loc21_[0];
|
||||
_loc11_.x = _loc15_;
|
||||
_loc11_.y = _loc18_;
|
||||
param1.SetV(_loc17_[0]);
|
||||
param2.SetV(_loc16_[0]);
|
||||
_loc23_++;
|
||||
break;
|
||||
case 1:
|
||||
_loc11_ = _loc17_[1];
|
||||
_loc11_.SetV(_loc10_);
|
||||
_loc11_ = _loc16_[1];
|
||||
_loc11_.SetV(_loc13_);
|
||||
_loc11_ = _loc21_[1];
|
||||
_loc11_.x = _loc15_;
|
||||
_loc11_.y = _loc18_;
|
||||
_loc23_ = ProcessTwo(param1,param2,_loc17_,_loc16_,_loc21_);
|
||||
break;
|
||||
case 2:
|
||||
_loc11_ = _loc17_[2];
|
||||
_loc11_.SetV(_loc10_);
|
||||
_loc11_ = _loc16_[2];
|
||||
_loc11_.SetV(_loc13_);
|
||||
_loc11_ = _loc21_[2];
|
||||
_loc11_.x = _loc15_;
|
||||
_loc11_.y = _loc18_;
|
||||
_loc23_ = ProcessThree(param1,param2,_loc17_,_loc16_,_loc21_);
|
||||
}
|
||||
if(_loc23_ == 3)
|
||||
{
|
||||
g_GJK_Iterations = _loc22_;
|
||||
return 0;
|
||||
}
|
||||
_loc7_ = -1.7976931348623157e+308;
|
||||
_loc12_ = 0;
|
||||
while(_loc12_ < _loc23_)
|
||||
{
|
||||
_loc11_ = _loc21_[_loc12_];
|
||||
_loc7_ = b2Math.b2Max(_loc7_,_loc11_.x * _loc11_.x + _loc11_.y * _loc11_.y);
|
||||
_loc12_++;
|
||||
}
|
||||
if(_loc23_ == 3 || _loc8_ <= 100 * Number.MIN_VALUE * _loc7_)
|
||||
{
|
||||
g_GJK_Iterations = _loc22_;
|
||||
_loc20_ = param2.x - param1.x;
|
||||
_loc19_ = param2.y - param1.y;
|
||||
_loc8_ = _loc20_ * _loc20_ + _loc19_ * _loc19_;
|
||||
return Math.sqrt(_loc8_);
|
||||
}
|
||||
_loc22_++;
|
||||
}
|
||||
g_GJK_Iterations = 20;
|
||||
return Math.sqrt(_loc8_);
|
||||
}
|
||||
|
||||
public static function DistanceCC(param1:b2Vec2, param2:b2Vec2, param3:b2CircleShape, param4:b2XForm, param5:b2CircleShape, param6:b2XForm) : Number
|
||||
{
|
||||
var _loc16_:b2Mat22 = null;
|
||||
var _loc10_:b2Vec2 = null;
|
||||
var _loc20_:Number = NaN;
|
||||
var _loc11_:Number = NaN;
|
||||
_loc16_ = param4.R;
|
||||
_loc10_ = param3.m_localPosition;
|
||||
var _loc12_:Number = param4.position.x + (_loc16_.col1.x * _loc10_.x + _loc16_.col2.x * _loc10_.y);
|
||||
var _loc19_:Number = param4.position.y + (_loc16_.col1.y * _loc10_.x + _loc16_.col2.y * _loc10_.y);
|
||||
_loc16_ = param6.R;
|
||||
_loc10_ = param5.m_localPosition;
|
||||
var _loc15_:Number = param6.position.x + (_loc16_.col1.x * _loc10_.x + _loc16_.col2.x * _loc10_.y);
|
||||
var _loc13_:Number = param6.position.y + (_loc16_.col1.y * _loc10_.x + _loc16_.col2.y * _loc10_.y);
|
||||
var _loc9_:Number = _loc15_ - _loc12_;
|
||||
var _loc8_:Number = _loc13_ - _loc19_;
|
||||
var _loc7_:Number = _loc9_ * _loc9_ + _loc8_ * _loc8_;
|
||||
var _loc17_:Number = param3.m_radius - 0.04;
|
||||
var _loc18_:Number = param5.m_radius - 0.04;
|
||||
var _loc14_:Number = _loc17_ + _loc18_;
|
||||
if(_loc7_ > _loc14_ * _loc14_)
|
||||
{
|
||||
_loc20_ = Math.sqrt(_loc7_);
|
||||
_loc9_ /= _loc20_;
|
||||
_loc8_ /= _loc20_;
|
||||
_loc11_ = _loc20_ - _loc14_;
|
||||
param1.x = _loc12_ + _loc17_ * _loc9_;
|
||||
param1.y = _loc19_ + _loc17_ * _loc8_;
|
||||
param2.x = _loc15_ - _loc18_ * _loc9_;
|
||||
param2.y = _loc13_ - _loc18_ * _loc8_;
|
||||
return _loc11_;
|
||||
}
|
||||
if(_loc7_ > Number.MIN_VALUE * Number.MIN_VALUE)
|
||||
{
|
||||
_loc20_ = Math.sqrt(_loc7_);
|
||||
_loc9_ /= _loc20_;
|
||||
_loc8_ /= _loc20_;
|
||||
param1.x = _loc12_ + _loc17_ * _loc9_;
|
||||
param1.y = _loc19_ + _loc17_ * _loc8_;
|
||||
param2.x = param1.x;
|
||||
param2.y = param1.y;
|
||||
return 0;
|
||||
}
|
||||
param1.x = _loc12_;
|
||||
param1.y = _loc19_;
|
||||
param2.x = param1.x;
|
||||
param2.y = param1.y;
|
||||
return 0;
|
||||
}
|
||||
|
||||
public static function DistancePC(param1:b2Vec2, param2:b2Vec2, param3:b2PolygonShape, param4:b2XForm, param5:b2CircleShape, param6:b2XForm) : Number
|
||||
{
|
||||
var _loc13_:b2Mat22 = null;
|
||||
var _loc9_:b2Vec2 = null;
|
||||
var _loc8_:Number = NaN;
|
||||
var _loc7_:Number = NaN;
|
||||
var _loc14_:Number = NaN;
|
||||
var _loc10_:b2Point = gPoint;
|
||||
_loc9_ = param5.m_localPosition;
|
||||
_loc13_ = param6.R;
|
||||
_loc10_.p.x = param6.position.x + (_loc13_.col1.x * _loc9_.x + _loc13_.col2.x * _loc9_.y);
|
||||
_loc10_.p.y = param6.position.y + (_loc13_.col1.y * _loc9_.x + _loc13_.col2.y * _loc9_.y);
|
||||
var _loc11_:Number = DistanceGeneric(param1,param2,param3,param4,_loc10_,b2Math.b2XForm_identity);
|
||||
var _loc12_:Number = param5.m_radius - 0.04;
|
||||
if(_loc11_ > _loc12_)
|
||||
{
|
||||
_loc11_ -= _loc12_;
|
||||
_loc8_ = param2.x - param1.x;
|
||||
_loc7_ = param2.y - param1.y;
|
||||
_loc14_ = Math.sqrt(_loc8_ * _loc8_ + _loc7_ * _loc7_);
|
||||
_loc8_ /= _loc14_;
|
||||
_loc7_ /= _loc14_;
|
||||
param2.x -= _loc12_ * _loc8_;
|
||||
param2.y -= _loc12_ * _loc7_;
|
||||
}
|
||||
else
|
||||
{
|
||||
_loc11_ = 0;
|
||||
param2.x = param1.x;
|
||||
param2.y = param1.y;
|
||||
}
|
||||
return _loc11_;
|
||||
}
|
||||
|
||||
public static function Distance(param1:b2Vec2, param2:b2Vec2, param3:b2Shape, param4:b2XForm, param5:b2Shape, param6:b2XForm) : Number
|
||||
{
|
||||
var _loc7_:int = param3.m_type;
|
||||
var _loc8_:int = param5.m_type;
|
||||
if(_loc7_ == 0 && _loc8_ == 0)
|
||||
{
|
||||
return DistanceCC(param1,param2,param3 as b2CircleShape,param4,param5 as b2CircleShape,param6);
|
||||
}
|
||||
if(_loc7_ == 1 && _loc8_ == 0)
|
||||
{
|
||||
return DistancePC(param1,param2,param3 as b2PolygonShape,param4,param5 as b2CircleShape,param6);
|
||||
}
|
||||
if(_loc7_ == 0 && _loc8_ == 1)
|
||||
{
|
||||
return DistancePC(param2,param1,param5 as b2PolygonShape,param6,param3 as b2CircleShape,param4);
|
||||
}
|
||||
if(_loc7_ == 1 && _loc8_ == 1)
|
||||
{
|
||||
return DistanceGeneric(param1,param2,param3 as b2PolygonShape,param4,param5 as b2PolygonShape,param6);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,56 @@
|
||||
package Box2D.Collision
|
||||
{
|
||||
import Box2D.Common.*;
|
||||
import Box2D.Common.Math.*;
|
||||
|
||||
public class b2Manifold
|
||||
{
|
||||
|
||||
public var points:Array;
|
||||
|
||||
public var normal:b2Vec2;
|
||||
|
||||
public var pointCount:int = 0;
|
||||
|
||||
public function b2Manifold()
|
||||
{
|
||||
var _loc1_:int = 0;
|
||||
super();
|
||||
points = new Array(2);
|
||||
_loc1_ = 0;
|
||||
while(_loc1_ < 2)
|
||||
{
|
||||
points[_loc1_] = new b2ManifoldPoint();
|
||||
_loc1_++;
|
||||
}
|
||||
normal = new b2Vec2();
|
||||
}
|
||||
|
||||
public function Reset() : void
|
||||
{
|
||||
var _loc1_:int = 0;
|
||||
_loc1_ = 0;
|
||||
while(_loc1_ < 2)
|
||||
{
|
||||
(points[_loc1_] as b2ManifoldPoint).Reset();
|
||||
_loc1_++;
|
||||
}
|
||||
normal.SetZero();
|
||||
pointCount = 0;
|
||||
}
|
||||
|
||||
public function Set(param1:b2Manifold) : void
|
||||
{
|
||||
var _loc2_:int = 0;
|
||||
pointCount = param1.pointCount;
|
||||
_loc2_ = 0;
|
||||
while(_loc2_ < 2)
|
||||
{
|
||||
(points[_loc2_] as b2ManifoldPoint).Set(param1.points[_loc2_]);
|
||||
_loc2_++;
|
||||
}
|
||||
normal.SetV(param1.normal);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,46 @@
|
||||
package Box2D.Collision
|
||||
{
|
||||
import Box2D.Common.Math.b2Vec2;
|
||||
|
||||
public class b2ManifoldPoint
|
||||
{
|
||||
|
||||
public var localPoint1:b2Vec2 = new b2Vec2();
|
||||
|
||||
public var localPoint2:b2Vec2 = new b2Vec2();
|
||||
|
||||
public var separation:Number;
|
||||
|
||||
public var normalImpulse:Number;
|
||||
|
||||
public var tangentImpulse:Number;
|
||||
|
||||
public var id:b2ContactID = new b2ContactID();
|
||||
|
||||
public function b2ManifoldPoint()
|
||||
{
|
||||
super();
|
||||
}
|
||||
|
||||
public function Reset() : void
|
||||
{
|
||||
localPoint1.SetZero();
|
||||
localPoint2.SetZero();
|
||||
separation = 0;
|
||||
normalImpulse = 0;
|
||||
tangentImpulse = 0;
|
||||
id.key = 0;
|
||||
}
|
||||
|
||||
public function Set(param1:b2ManifoldPoint) : void
|
||||
{
|
||||
localPoint1.SetV(param1.localPoint1);
|
||||
localPoint2.SetV(param1.localPoint2);
|
||||
separation = param1.separation;
|
||||
normalImpulse = param1.normalImpulse;
|
||||
tangentImpulse = param1.tangentImpulse;
|
||||
id.key = param1.id.key;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,21 @@
|
||||
package Box2D.Collision
|
||||
{
|
||||
import Box2D.Common.Math.b2Mat22;
|
||||
import Box2D.Common.Math.b2Vec2;
|
||||
|
||||
public class b2OBB
|
||||
{
|
||||
|
||||
public var R:b2Mat22 = new b2Mat22();
|
||||
|
||||
public var center:b2Vec2 = new b2Vec2();
|
||||
|
||||
public var extents:b2Vec2 = new b2Vec2();
|
||||
|
||||
public function b2OBB()
|
||||
{
|
||||
super();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,76 @@
|
||||
package Box2D.Collision
|
||||
{
|
||||
public class b2Pair
|
||||
{
|
||||
|
||||
public static var b2_nullPair:uint = 65535;
|
||||
|
||||
public static var b2_nullProxy:uint = 65535;
|
||||
|
||||
public static var b2_tableCapacity:int = 4096;
|
||||
|
||||
public static var e_pairBuffered:uint = 1;
|
||||
|
||||
public static var e_pairRemoved:uint = 2;
|
||||
|
||||
public static var e_pairFinal:uint = 4;
|
||||
|
||||
public static var b2_tableMask:int = b2_tableCapacity - 1;
|
||||
|
||||
public var userData:* = null;
|
||||
|
||||
public var proxyId1:uint;
|
||||
|
||||
public var proxyId2:uint;
|
||||
|
||||
public var next:uint;
|
||||
|
||||
public var status:uint;
|
||||
|
||||
public function b2Pair()
|
||||
{
|
||||
super();
|
||||
}
|
||||
|
||||
public function SetBuffered() : void
|
||||
{
|
||||
status |= e_pairBuffered;
|
||||
}
|
||||
|
||||
public function ClearBuffered() : void
|
||||
{
|
||||
status &= ~e_pairBuffered;
|
||||
}
|
||||
|
||||
public function IsBuffered() : Boolean
|
||||
{
|
||||
return (status & e_pairBuffered) == e_pairBuffered;
|
||||
}
|
||||
|
||||
public function SetRemoved() : void
|
||||
{
|
||||
status |= e_pairRemoved;
|
||||
}
|
||||
|
||||
public function ClearRemoved() : void
|
||||
{
|
||||
status &= ~e_pairRemoved;
|
||||
}
|
||||
|
||||
public function IsRemoved() : Boolean
|
||||
{
|
||||
return (status & e_pairRemoved) == e_pairRemoved;
|
||||
}
|
||||
|
||||
public function SetFinal() : void
|
||||
{
|
||||
status |= e_pairFinal;
|
||||
}
|
||||
|
||||
public function IsFinal() : Boolean
|
||||
{
|
||||
return (status & e_pairFinal) == e_pairFinal;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,21 @@
|
||||
package Box2D.Collision
|
||||
{
|
||||
public class b2PairCallback
|
||||
{
|
||||
|
||||
public function b2PairCallback()
|
||||
{
|
||||
super();
|
||||
}
|
||||
|
||||
public function PairAdded(param1:*, param2:*) : *
|
||||
{
|
||||
return null;
|
||||
}
|
||||
|
||||
public function PairRemoved(param1:*, param2:*, param3:*) : void
|
||||
{
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,297 @@
|
||||
package Box2D.Collision
|
||||
{
|
||||
import Box2D.Common.*;
|
||||
import Box2D.Common.Math.*;
|
||||
|
||||
public class b2PairManager
|
||||
{
|
||||
|
||||
public var m_broadPhase:b2BroadPhase;
|
||||
|
||||
public var m_callback:b2PairCallback;
|
||||
|
||||
public var m_pairs:Array;
|
||||
|
||||
public var m_freePair:uint;
|
||||
|
||||
public var m_pairCount:int;
|
||||
|
||||
public var m_pairBuffer:Array;
|
||||
|
||||
public var m_pairBufferCount:int;
|
||||
|
||||
public var m_hashTable:Array;
|
||||
|
||||
public function b2PairManager()
|
||||
{
|
||||
var _loc1_:* = 0;
|
||||
super();
|
||||
m_hashTable = new Array(b2Pair.b2_tableCapacity);
|
||||
_loc1_ = 0;
|
||||
while(_loc1_ < b2Pair.b2_tableCapacity)
|
||||
{
|
||||
m_hashTable[_loc1_] = b2Pair.b2_nullPair;
|
||||
_loc1_++;
|
||||
}
|
||||
m_pairs = new Array(4096);
|
||||
_loc1_ = 0;
|
||||
while(_loc1_ < 4096)
|
||||
{
|
||||
m_pairs[_loc1_] = new b2Pair();
|
||||
_loc1_++;
|
||||
}
|
||||
m_pairBuffer = new Array(4096);
|
||||
_loc1_ = 0;
|
||||
while(_loc1_ < 4096)
|
||||
{
|
||||
m_pairBuffer[_loc1_] = new b2BufferedPair();
|
||||
_loc1_++;
|
||||
}
|
||||
_loc1_ = 0;
|
||||
while(_loc1_ < 4096)
|
||||
{
|
||||
m_pairs[_loc1_].proxyId1 = b2Pair.b2_nullProxy;
|
||||
m_pairs[_loc1_].proxyId2 = b2Pair.b2_nullProxy;
|
||||
m_pairs[_loc1_].userData = null;
|
||||
m_pairs[_loc1_].status = 0;
|
||||
m_pairs[_loc1_].next = _loc1_ + 1;
|
||||
_loc1_++;
|
||||
}
|
||||
m_pairs[4095].next = b2Pair.b2_nullPair;
|
||||
m_pairCount = 0;
|
||||
m_pairBufferCount = 0;
|
||||
}
|
||||
|
||||
public static function Hash(param1:uint, param2:uint) : uint
|
||||
{
|
||||
var _loc3_:uint = uint(param2 << 16 & 0xFFFF0000 | param1);
|
||||
_loc3_ = ~_loc3_ + (_loc3_ << 15 & 0xFFFF8000);
|
||||
_loc3_ ^= _loc3_ >> 12 & 0x0FFFFF;
|
||||
_loc3_ += _loc3_ << 2 & 0xFFFFFFFC;
|
||||
_loc3_ ^= _loc3_ >> 4 & 0x0FFFFFFF;
|
||||
_loc3_ *= 2057;
|
||||
return uint(_loc3_ ^ _loc3_ >> 16 & 0xFFFF);
|
||||
}
|
||||
|
||||
public static function Equals(param1:b2Pair, param2:uint, param3:uint) : Boolean
|
||||
{
|
||||
return param1.proxyId1 == param2 && param1.proxyId2 == param3;
|
||||
}
|
||||
|
||||
public static function EqualsPair(param1:b2BufferedPair, param2:b2BufferedPair) : Boolean
|
||||
{
|
||||
return param1.proxyId1 == param2.proxyId1 && param1.proxyId2 == param2.proxyId2;
|
||||
}
|
||||
|
||||
public function Initialize(param1:b2BroadPhase, param2:b2PairCallback) : void
|
||||
{
|
||||
m_broadPhase = param1;
|
||||
m_callback = param2;
|
||||
}
|
||||
|
||||
public function AddBufferedPair(param1:int, param2:int) : void
|
||||
{
|
||||
var _loc4_:b2BufferedPair = null;
|
||||
var _loc3_:b2Pair = AddPair(param1,param2);
|
||||
if(_loc3_.IsBuffered() == false)
|
||||
{
|
||||
_loc3_.SetBuffered();
|
||||
_loc4_ = m_pairBuffer[m_pairBufferCount];
|
||||
_loc4_.proxyId1 = _loc3_.proxyId1;
|
||||
_loc4_.proxyId2 = _loc3_.proxyId2;
|
||||
m_pairBufferCount = m_pairBufferCount + 1;
|
||||
}
|
||||
_loc3_.ClearRemoved();
|
||||
if(b2BroadPhase.s_validate)
|
||||
{
|
||||
ValidateBuffer();
|
||||
}
|
||||
}
|
||||
|
||||
public function RemoveBufferedPair(param1:int, param2:int) : void
|
||||
{
|
||||
var _loc4_:b2BufferedPair = null;
|
||||
var _loc3_:b2Pair = Find(param1,param2);
|
||||
if(_loc3_ == null)
|
||||
{
|
||||
return;
|
||||
}
|
||||
if(_loc3_.IsBuffered() == false)
|
||||
{
|
||||
_loc3_.SetBuffered();
|
||||
_loc4_ = m_pairBuffer[m_pairBufferCount];
|
||||
_loc4_.proxyId1 = _loc3_.proxyId1;
|
||||
_loc4_.proxyId2 = _loc3_.proxyId2;
|
||||
m_pairBufferCount = m_pairBufferCount + 1;
|
||||
}
|
||||
_loc3_.SetRemoved();
|
||||
if(b2BroadPhase.s_validate)
|
||||
{
|
||||
ValidateBuffer();
|
||||
}
|
||||
}
|
||||
|
||||
public function Commit() : void
|
||||
{
|
||||
var _loc3_:b2BufferedPair = null;
|
||||
var _loc7_:int = 0;
|
||||
var _loc1_:b2Pair = null;
|
||||
var _loc4_:b2Proxy = null;
|
||||
var _loc5_:b2Proxy = null;
|
||||
var _loc2_:int = 0;
|
||||
var _loc6_:Array = m_broadPhase.m_proxyPool;
|
||||
_loc7_ = 0;
|
||||
while(_loc7_ < m_pairBufferCount)
|
||||
{
|
||||
_loc3_ = m_pairBuffer[_loc7_];
|
||||
_loc1_ = Find(_loc3_.proxyId1,_loc3_.proxyId2);
|
||||
_loc1_.ClearBuffered();
|
||||
_loc4_ = _loc6_[_loc1_.proxyId1];
|
||||
_loc5_ = _loc6_[_loc1_.proxyId2];
|
||||
if(_loc1_.IsRemoved())
|
||||
{
|
||||
if(_loc1_.IsFinal() == true)
|
||||
{
|
||||
m_callback.PairRemoved(_loc4_.userData,_loc5_.userData,_loc1_.userData);
|
||||
}
|
||||
_loc3_ = m_pairBuffer[_loc2_];
|
||||
_loc3_.proxyId1 = _loc1_.proxyId1;
|
||||
_loc3_.proxyId2 = _loc1_.proxyId2;
|
||||
_loc2_++;
|
||||
}
|
||||
else if(_loc1_.IsFinal() == false)
|
||||
{
|
||||
_loc1_.userData = m_callback.PairAdded(_loc4_.userData,_loc5_.userData);
|
||||
_loc1_.SetFinal();
|
||||
}
|
||||
_loc7_++;
|
||||
}
|
||||
_loc7_ = 0;
|
||||
while(_loc7_ < _loc2_)
|
||||
{
|
||||
_loc3_ = m_pairBuffer[_loc7_];
|
||||
RemovePair(_loc3_.proxyId1,_loc3_.proxyId2);
|
||||
_loc7_++;
|
||||
}
|
||||
m_pairBufferCount = 0;
|
||||
if(b2BroadPhase.s_validate)
|
||||
{
|
||||
ValidateTable();
|
||||
}
|
||||
}
|
||||
|
||||
private function AddPair(param1:uint, param2:uint) : b2Pair
|
||||
{
|
||||
var _loc6_:* = 0;
|
||||
var _loc3_:b2Pair = null;
|
||||
if(param1 > param2)
|
||||
{
|
||||
_loc6_ = param1;
|
||||
param1 = param2;
|
||||
param2 = _loc6_;
|
||||
}
|
||||
var _loc4_:uint = uint(Hash(param1,param2) & b2Pair.b2_tableMask);
|
||||
_loc3_ = _loc3_ = FindHash(param1,param2,_loc4_);
|
||||
if(_loc3_ != null)
|
||||
{
|
||||
return _loc3_;
|
||||
}
|
||||
var _loc5_:uint = m_freePair;
|
||||
_loc3_ = m_pairs[_loc5_];
|
||||
m_freePair = _loc3_.next;
|
||||
_loc3_.proxyId1 = param1;
|
||||
_loc3_.proxyId2 = param2;
|
||||
_loc3_.status = 0;
|
||||
_loc3_.userData = null;
|
||||
_loc3_.next = m_hashTable[_loc4_];
|
||||
m_hashTable[_loc4_] = _loc5_;
|
||||
m_pairCount = m_pairCount + 1;
|
||||
return _loc3_;
|
||||
}
|
||||
|
||||
private function RemovePair(param1:uint, param2:uint) : *
|
||||
{
|
||||
var _loc6_:b2Pair = null;
|
||||
var _loc7_:* = 0;
|
||||
var _loc3_:* = 0;
|
||||
var _loc8_:* = undefined;
|
||||
if(param1 > param2)
|
||||
{
|
||||
_loc7_ = param1;
|
||||
param1 = param2;
|
||||
param2 = _loc7_;
|
||||
}
|
||||
var _loc5_:uint = uint(Hash(param1,param2) & b2Pair.b2_tableMask);
|
||||
var _loc4_:uint = uint(m_hashTable[_loc5_]);
|
||||
var _loc9_:b2Pair = null;
|
||||
while(_loc4_ != b2Pair.b2_nullPair)
|
||||
{
|
||||
if(Equals(m_pairs[_loc4_],param1,param2))
|
||||
{
|
||||
_loc3_ = _loc4_;
|
||||
_loc6_ = m_pairs[_loc4_];
|
||||
if(_loc9_)
|
||||
{
|
||||
_loc9_.next = _loc6_.next;
|
||||
}
|
||||
else
|
||||
{
|
||||
m_hashTable[_loc5_] = _loc6_.next;
|
||||
}
|
||||
_loc6_ = m_pairs[_loc3_];
|
||||
_loc8_ = _loc6_.userData;
|
||||
_loc6_.next = m_freePair;
|
||||
_loc6_.proxyId1 = b2Pair.b2_nullProxy;
|
||||
_loc6_.proxyId2 = b2Pair.b2_nullProxy;
|
||||
_loc6_.userData = null;
|
||||
_loc6_.status = 0;
|
||||
m_freePair = _loc3_;
|
||||
m_pairCount = m_pairCount - 1;
|
||||
return _loc8_;
|
||||
}
|
||||
_loc9_ = m_pairs[_loc4_];
|
||||
_loc4_ = _loc9_.next;
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
private function Find(param1:uint, param2:uint) : b2Pair
|
||||
{
|
||||
var _loc4_:* = 0;
|
||||
if(param1 > param2)
|
||||
{
|
||||
_loc4_ = param1;
|
||||
param1 = param2;
|
||||
param2 = _loc4_;
|
||||
}
|
||||
var _loc3_:uint = uint(Hash(param1,param2) & b2Pair.b2_tableMask);
|
||||
return FindHash(param1,param2,_loc3_);
|
||||
}
|
||||
|
||||
private function FindHash(param1:uint, param2:uint, param3:uint) : b2Pair
|
||||
{
|
||||
var _loc5_:b2Pair = null;
|
||||
var _loc4_:uint = uint(m_hashTable[param3]);
|
||||
_loc5_ = m_pairs[_loc4_];
|
||||
while(_loc4_ != b2Pair.b2_nullPair && Equals(_loc5_,param1,param2) == false)
|
||||
{
|
||||
_loc4_ = _loc5_.next;
|
||||
_loc5_ = m_pairs[_loc4_];
|
||||
}
|
||||
if(_loc4_ == b2Pair.b2_nullPair)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
return _loc5_;
|
||||
}
|
||||
|
||||
private function ValidateBuffer() : void
|
||||
{
|
||||
}
|
||||
|
||||
private function ValidateTable() : void
|
||||
{
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,27 @@
|
||||
package Box2D.Collision
|
||||
{
|
||||
import Box2D.Common.Math.b2Vec2;
|
||||
import Box2D.Common.Math.b2XForm;
|
||||
|
||||
public class b2Point
|
||||
{
|
||||
|
||||
public var p:b2Vec2 = new b2Vec2();
|
||||
|
||||
public function b2Point()
|
||||
{
|
||||
super();
|
||||
}
|
||||
|
||||
public function Support(param1:b2XForm, param2:Number, param3:Number) : b2Vec2
|
||||
{
|
||||
return p;
|
||||
}
|
||||
|
||||
public function GetFirstVertex(param1:b2XForm) : b2Vec2
|
||||
{
|
||||
return p;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,37 @@
|
||||
package Box2D.Collision
|
||||
{
|
||||
public class b2Proxy
|
||||
{
|
||||
|
||||
public var lowerBounds:Array = [0,0];
|
||||
|
||||
public var upperBounds:Array = [0,0];
|
||||
|
||||
public var overlapCount:uint;
|
||||
|
||||
public var timeStamp:uint;
|
||||
|
||||
public var userData:* = null;
|
||||
|
||||
public function b2Proxy()
|
||||
{
|
||||
super();
|
||||
}
|
||||
|
||||
public function GetNext() : uint
|
||||
{
|
||||
return lowerBounds[0];
|
||||
}
|
||||
|
||||
public function SetNext(param1:uint) : void
|
||||
{
|
||||
lowerBounds[0] = param1 & 0xFFFF;
|
||||
}
|
||||
|
||||
public function IsValid() : Boolean
|
||||
{
|
||||
return overlapCount != 65535;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,58 @@
|
||||
package Box2D.Collision
|
||||
{
|
||||
import Box2D.Common.*;
|
||||
import Box2D.Common.Math.*;
|
||||
|
||||
public class b2Segment
|
||||
{
|
||||
|
||||
public var p1:b2Vec2 = new b2Vec2();
|
||||
|
||||
public var p2:b2Vec2 = new b2Vec2();
|
||||
|
||||
public function b2Segment()
|
||||
{
|
||||
super();
|
||||
}
|
||||
|
||||
public function TestSegment(param1:Array, param2:b2Vec2, param3:b2Segment, param4:Number) : Boolean
|
||||
{
|
||||
var _loc12_:Number = NaN;
|
||||
var _loc11_:Number = NaN;
|
||||
var _loc6_:Number = NaN;
|
||||
var _loc5_:Number = NaN;
|
||||
var _loc17_:Number = NaN;
|
||||
var _loc14_:b2Vec2 = param3.p1;
|
||||
var _loc15_:Number = param3.p2.x - _loc14_.x;
|
||||
var _loc16_:Number = param3.p2.y - _loc14_.y;
|
||||
var _loc9_:Number = p2.x - p1.x;
|
||||
var _loc7_:Number;
|
||||
var _loc10_:Number = _loc7_ = p2.y - p1.y;
|
||||
var _loc8_:Number = -_loc9_;
|
||||
var _loc18_:Number = 100 * Number.MIN_VALUE;
|
||||
var _loc13_:Number = -(_loc15_ * _loc10_ + _loc16_ * _loc8_);
|
||||
if(_loc13_ > _loc18_)
|
||||
{
|
||||
_loc12_ = _loc14_.x - p1.x;
|
||||
_loc11_ = _loc14_.y - p1.y;
|
||||
_loc6_ = _loc12_ * _loc10_ + _loc11_ * _loc8_;
|
||||
if(0 <= _loc6_ && _loc6_ <= param4 * _loc13_)
|
||||
{
|
||||
_loc5_ = -_loc15_ * _loc11_ + _loc16_ * _loc12_;
|
||||
if(-_loc18_ * _loc13_ <= _loc5_ && _loc5_ <= _loc13_ * (1 + _loc18_))
|
||||
{
|
||||
_loc6_ /= _loc13_;
|
||||
_loc17_ = Math.sqrt(_loc10_ * _loc10_ + _loc8_ * _loc8_);
|
||||
_loc10_ /= _loc17_;
|
||||
_loc8_ /= _loc17_;
|
||||
param1[0] = _loc6_;
|
||||
param2.Set(_loc10_,_loc8_);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,107 @@
|
||||
package Box2D.Collision
|
||||
{
|
||||
import Box2D.Collision.Shapes.b2Shape;
|
||||
import Box2D.Common.Math.b2Sweep;
|
||||
import Box2D.Common.Math.b2Vec2;
|
||||
import Box2D.Common.Math.b2XForm;
|
||||
|
||||
public class b2TimeOfImpact
|
||||
{
|
||||
|
||||
public static var s_p1:b2Vec2 = new b2Vec2();
|
||||
|
||||
public static var s_p2:b2Vec2 = new b2Vec2();
|
||||
|
||||
public static var s_xf1:b2XForm = new b2XForm();
|
||||
|
||||
public static var s_xf2:b2XForm = new b2XForm();
|
||||
|
||||
public function b2TimeOfImpact()
|
||||
{
|
||||
super();
|
||||
}
|
||||
|
||||
public static function TimeOfImpact(param1:b2Shape, param2:b2Sweep, param3:b2Shape, param4:b2Sweep) : Number
|
||||
{
|
||||
var _loc22_:Number = NaN;
|
||||
var _loc21_:Number = NaN;
|
||||
var _loc26_:Number = NaN;
|
||||
var _loc23_:b2XForm = null;
|
||||
var _loc27_:b2XForm = null;
|
||||
var _loc28_:Number = NaN;
|
||||
var _loc16_:Number = NaN;
|
||||
var _loc19_:Number = NaN;
|
||||
var _loc11_:Number = NaN;
|
||||
var _loc29_:Number = param1.m_sweepRadius;
|
||||
var _loc30_:Number = param3.m_sweepRadius;
|
||||
var _loc5_:Number = param2.t0;
|
||||
var _loc24_:Number = param2.c.x - param2.c0.x;
|
||||
var _loc25_:Number = param2.c.y - param2.c0.y;
|
||||
var _loc15_:Number = param4.c.x - param4.c0.x;
|
||||
var _loc17_:Number = param4.c.y - param4.c0.y;
|
||||
var _loc8_:Number = param2.a - param2.a0;
|
||||
var _loc10_:Number = param4.a - param4.a0;
|
||||
var _loc18_:Number = 0;
|
||||
var _loc7_:b2Vec2 = s_p1;
|
||||
var _loc6_:b2Vec2 = s_p2;
|
||||
var _loc13_:int = 20;
|
||||
var _loc31_:int = 0;
|
||||
var _loc9_:Number = 0;
|
||||
var _loc12_:Number = 0;
|
||||
var _loc14_:Number = 0;
|
||||
var _loc20_:Number = 0;
|
||||
while(true)
|
||||
{
|
||||
_loc26_ = (1 - _loc18_) * _loc5_ + _loc18_;
|
||||
_loc23_ = s_xf1;
|
||||
_loc27_ = s_xf2;
|
||||
param2.GetXForm(_loc23_,_loc26_);
|
||||
param4.GetXForm(_loc27_,_loc26_);
|
||||
_loc14_ = b2Distance.Distance(_loc7_,_loc6_,param1,_loc23_,param3,_loc27_);
|
||||
if(_loc31_ == 0)
|
||||
{
|
||||
if(_loc14_ > 2 * 0.04)
|
||||
{
|
||||
_loc20_ = 1.5 * 0.04;
|
||||
}
|
||||
else
|
||||
{
|
||||
_loc22_ = 0.05 * 0.04;
|
||||
_loc21_ = _loc14_ - 0.5 * 0.04;
|
||||
_loc20_ = _loc22_ > _loc21_ ? _loc22_ : _loc21_;
|
||||
}
|
||||
}
|
||||
if(_loc14_ - _loc20_ < 0.05 * 0.04 || _loc31_ == _loc13_)
|
||||
{
|
||||
break;
|
||||
}
|
||||
_loc9_ = _loc6_.x - _loc7_.x;
|
||||
_loc12_ = _loc6_.y - _loc7_.y;
|
||||
_loc28_ = Math.sqrt(_loc9_ * _loc9_ + _loc12_ * _loc12_);
|
||||
_loc9_ /= _loc28_;
|
||||
_loc12_ /= _loc28_;
|
||||
_loc16_ = _loc9_ * (_loc24_ - _loc15_) + _loc12_ * (_loc25_ - _loc17_) + (_loc8_ < 0 ? -_loc8_ : _loc8_) * _loc29_ + (_loc10_ < 0 ? -_loc10_ : _loc10_) * _loc30_;
|
||||
if(_loc16_ == 0)
|
||||
{
|
||||
_loc18_ = 1;
|
||||
break;
|
||||
}
|
||||
_loc19_ = (_loc14_ - _loc20_) / _loc16_;
|
||||
_loc11_ = _loc18_ + _loc19_;
|
||||
if(_loc11_ < 0 || 1 < _loc11_)
|
||||
{
|
||||
_loc18_ = 1;
|
||||
break;
|
||||
}
|
||||
if(_loc11_ < (1 + 100 * Number.MIN_VALUE) * _loc18_)
|
||||
{
|
||||
break;
|
||||
}
|
||||
_loc18_ = _loc11_;
|
||||
_loc31_++;
|
||||
}
|
||||
return _loc18_;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Reference in new issue
Block a user