mirror of
https://github.com/burrow-dev/burrow-server.git
synced 2026-11-19 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,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 _loc5_:b2Mat22 = param1.R;
|
||||
var _loc3_:Number = param1.position.x + (_loc5_.col1.x * m_localPosition.x + _loc5_.col2.x * m_localPosition.y);
|
||||
var _loc4_:Number = param1.position.y + (_loc5_.col1.y * m_localPosition.x + _loc5_.col2.y * m_localPosition.y);
|
||||
_loc3_ = param2.x - _loc3_;
|
||||
_loc4_ = param2.y - _loc4_;
|
||||
return _loc3_ * _loc3_ + _loc4_ * _loc4_ <= m_radius * m_radius;
|
||||
}
|
||||
|
||||
override public function TestSegment(param1:b2XForm, param2:Array, param3:b2Vec2, param4:b2Segment, param5:Number) : Boolean
|
||||
{
|
||||
var _loc17_:b2Mat22 = param1.R;
|
||||
var _loc15_:Number = param1.position.x + (_loc17_.col1.x * m_localPosition.x + _loc17_.col2.x * m_localPosition.y);
|
||||
var _loc16_:Number = param1.position.y + (_loc17_.col1.y * m_localPosition.x + _loc17_.col2.y * m_localPosition.y);
|
||||
var _loc11_:Number = param4.p1.x - _loc15_;
|
||||
var _loc12_:Number = param4.p1.y - _loc16_;
|
||||
var _loc9_:Number = _loc11_ * _loc11_ + _loc12_ * _loc12_ - m_radius * m_radius;
|
||||
if(_loc9_ < 0)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
var _loc13_:Number = param4.p2.x - param4.p1.x;
|
||||
var _loc14_:Number = param4.p2.y - param4.p1.y;
|
||||
var _loc10_:Number = _loc11_ * _loc13_ + _loc12_ * _loc14_;
|
||||
var _loc6_:Number = _loc13_ * _loc13_ + _loc14_ * _loc14_;
|
||||
var _loc7_:Number = _loc10_ * _loc10_ - _loc6_ * _loc9_;
|
||||
if(_loc7_ < 0 || _loc6_ < Number.MIN_VALUE)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
var _loc8_:Number = -(_loc10_ + Math.sqrt(_loc7_));
|
||||
if(0 <= _loc8_ && _loc8_ <= param5 * _loc6_)
|
||||
{
|
||||
_loc8_ /= _loc6_;
|
||||
param2[0] = _loc8_;
|
||||
param3.x = _loc11_ + _loc8_ * _loc13_;
|
||||
param3.y = _loc12_ + _loc8_ * _loc14_;
|
||||
param3.Normalize();
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
override public function ComputeAABB(param1:b2AABB, param2:b2XForm) : void
|
||||
{
|
||||
var _loc4_:b2Mat22 = param2.R;
|
||||
var _loc3_:Number = param2.position.x + (_loc4_.col1.x * m_localPosition.x + _loc4_.col2.x * m_localPosition.y);
|
||||
var _loc5_:Number = param2.position.y + (_loc4_.col1.y * m_localPosition.x + _loc4_.col2.y * m_localPosition.y);
|
||||
param1.lowerBound.Set(_loc3_ - m_radius,_loc5_ - m_radius);
|
||||
param1.upperBound.Set(_loc3_ + m_radius,_loc5_ + 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 _loc2_:Number = m_localPosition.x - param1.x;
|
||||
var _loc3_:Number = m_localPosition.y - param1.y;
|
||||
_loc2_ = Math.sqrt(_loc2_ * _loc2_ + _loc3_ * _loc3_);
|
||||
m_sweepRadius = _loc2_ + 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 _loc5_:Number = NaN;
|
||||
var _loc2_:Number = NaN;
|
||||
var _loc10_:Number = NaN;
|
||||
var _loc11_:Number = NaN;
|
||||
var _loc16_:Number = NaN;
|
||||
var _loc14_:Number = NaN;
|
||||
var _loc12_:Number = NaN;
|
||||
var _loc3_:Number = NaN;
|
||||
var _loc4_:Number = NaN;
|
||||
var _loc13_:Number = NaN;
|
||||
var _loc15_:Number = NaN;
|
||||
var _loc9_:Number = NaN;
|
||||
super(param1);
|
||||
m_type = 1;
|
||||
var _loc17_:b2PolygonDef = param1 as b2PolygonDef;
|
||||
m_vertexCount = _loc17_.vertexCount;
|
||||
var _loc6_:int = _loc7_;
|
||||
var _loc8_:int = _loc7_;
|
||||
_loc7_ = 0;
|
||||
while(_loc7_ < m_vertexCount)
|
||||
{
|
||||
m_vertices[_loc7_] = _loc17_.vertices[_loc7_].Copy();
|
||||
_loc7_++;
|
||||
}
|
||||
_loc7_ = 0;
|
||||
while(_loc7_ < m_vertexCount)
|
||||
{
|
||||
_loc6_ = _loc7_;
|
||||
_loc8_ = _loc7_ + 1 < m_vertexCount ? _loc7_ + 1 : 0;
|
||||
_loc5_ = m_vertices[_loc8_].x - m_vertices[_loc6_].x;
|
||||
_loc2_ = m_vertices[_loc8_].y - m_vertices[_loc6_].y;
|
||||
_loc10_ = Math.sqrt(_loc5_ * _loc5_ + _loc2_ * _loc2_);
|
||||
m_normals[_loc7_] = new b2Vec2(_loc2_ / _loc10_,-_loc5_ / _loc10_);
|
||||
_loc7_++;
|
||||
}
|
||||
m_centroid = ComputeCentroid(_loc17_.vertices,_loc17_.vertexCount);
|
||||
ComputeOBB(m_obb,m_vertices,m_vertexCount);
|
||||
_loc7_ = 0;
|
||||
while(_loc7_ < m_vertexCount)
|
||||
{
|
||||
_loc6_ = _loc7_ - 1 >= 0 ? _loc7_ - 1 : m_vertexCount - 1;
|
||||
_loc8_ = _loc7_;
|
||||
_loc11_ = Number(m_normals[_loc6_].x);
|
||||
_loc16_ = Number(m_normals[_loc6_].y);
|
||||
_loc14_ = Number(m_normals[_loc8_].x);
|
||||
_loc12_ = Number(m_normals[_loc8_].y);
|
||||
_loc3_ = m_vertices[_loc7_].x - m_centroid.x;
|
||||
_loc4_ = m_vertices[_loc7_].y - m_centroid.y;
|
||||
_loc13_ = _loc11_ * _loc3_ + _loc16_ * _loc4_ - 0.04;
|
||||
_loc15_ = _loc14_ * _loc3_ + _loc12_ * _loc4_ - 0.04;
|
||||
_loc9_ = 1 / (_loc11_ * _loc12_ - _loc16_ * _loc14_);
|
||||
m_coreVertices[_loc7_] = new b2Vec2(_loc9_ * (_loc12_ * _loc13_ - _loc16_ * _loc15_) + m_centroid.x,_loc9_ * (_loc11_ * _loc15_ - _loc14_ * _loc13_) + m_centroid.y);
|
||||
_loc7_++;
|
||||
}
|
||||
}
|
||||
|
||||
public static function ComputeCentroid(param1:Array, param2:int) : b2Vec2
|
||||
{
|
||||
var _loc8_:int = 0;
|
||||
var _loc4_:b2Vec2 = null;
|
||||
var _loc6_:b2Vec2 = null;
|
||||
var _loc11_:Number = NaN;
|
||||
var _loc10_:Number = NaN;
|
||||
var _loc9_:Number = NaN;
|
||||
var _loc12_:Number = NaN;
|
||||
var _loc7_:Number = NaN;
|
||||
var _loc14_:Number = NaN;
|
||||
var _loc5_:b2Vec2 = new b2Vec2();
|
||||
var _loc3_:Number = 0;
|
||||
var _loc15_:Number = 0;
|
||||
var _loc16_:Number = 0;
|
||||
var _loc13_:Number = 0.3333333333333333;
|
||||
_loc8_ = 0;
|
||||
while(_loc8_ < param2)
|
||||
{
|
||||
_loc4_ = param1[_loc8_];
|
||||
_loc6_ = _loc8_ + 1 < param2 ? param1[int(_loc8_ + 1)] : param1[0];
|
||||
_loc11_ = _loc4_.x - _loc15_;
|
||||
_loc10_ = _loc4_.y - _loc16_;
|
||||
_loc9_ = _loc6_.x - _loc15_;
|
||||
_loc12_ = _loc6_.y - _loc16_;
|
||||
_loc7_ = _loc11_ * _loc12_ - _loc10_ * _loc9_;
|
||||
_loc14_ = 0.5 * _loc7_;
|
||||
_loc3_ += _loc14_;
|
||||
_loc5_.x += _loc14_ * _loc13_ * (_loc15_ + _loc4_.x + _loc6_.x);
|
||||
_loc5_.y += _loc14_ * _loc13_ * (_loc16_ + _loc4_.y + _loc6_.y);
|
||||
_loc8_++;
|
||||
}
|
||||
_loc5_.x *= 1 / _loc3_;
|
||||
_loc5_.y *= 1 / _loc3_;
|
||||
return _loc5_;
|
||||
}
|
||||
|
||||
public static function ComputeOBB(param1:b2OBB, param2:Array, param3:int) : void
|
||||
{
|
||||
var _loc16_:int = 0;
|
||||
var _loc7_:b2Vec2 = null;
|
||||
var _loc6_:Number = NaN;
|
||||
var _loc8_:Number = NaN;
|
||||
var _loc14_:Number = NaN;
|
||||
var _loc23_:Number = NaN;
|
||||
var _loc21_:Number = NaN;
|
||||
var _loc15_:Number = NaN;
|
||||
var _loc12_:Number = NaN;
|
||||
var _loc20_:Number = NaN;
|
||||
var _loc19_:Number = NaN;
|
||||
var _loc17_:int = 0;
|
||||
var _loc22_:Number = NaN;
|
||||
var _loc24_:Number = NaN;
|
||||
var _loc11_:Number = NaN;
|
||||
var _loc13_:Number = NaN;
|
||||
var _loc10_:Number = NaN;
|
||||
var _loc5_:Number = NaN;
|
||||
var _loc4_:Number = NaN;
|
||||
var _loc25_:b2Mat22 = null;
|
||||
var _loc18_:Array = new Array(8 + 1);
|
||||
_loc16_ = 0;
|
||||
while(_loc16_ < param3)
|
||||
{
|
||||
_loc18_[_loc16_] = param2[_loc16_];
|
||||
_loc16_++;
|
||||
}
|
||||
_loc18_[param3] = _loc18_[0];
|
||||
var _loc9_:Number = 1.7976931348623157e+308;
|
||||
_loc16_ = 1;
|
||||
while(_loc16_ <= param3)
|
||||
{
|
||||
_loc7_ = _loc18_[int(_loc16_ - 1)];
|
||||
_loc6_ = _loc18_[_loc16_].x - _loc7_.x;
|
||||
_loc8_ = _loc18_[_loc16_].y - _loc7_.y;
|
||||
_loc14_ = Math.sqrt(_loc6_ * _loc6_ + _loc8_ * _loc8_);
|
||||
_loc6_ /= _loc14_;
|
||||
_loc8_ /= _loc14_;
|
||||
_loc23_ = -_loc8_;
|
||||
_loc21_ = _loc6_;
|
||||
_loc15_ = 1.7976931348623157e+308;
|
||||
_loc12_ = 1.7976931348623157e+308;
|
||||
_loc20_ = -1.7976931348623157e+308;
|
||||
_loc19_ = -1.7976931348623157e+308;
|
||||
_loc17_ = 0;
|
||||
while(_loc17_ < param3)
|
||||
{
|
||||
_loc22_ = _loc18_[_loc17_].x - _loc7_.x;
|
||||
_loc24_ = _loc18_[_loc17_].y - _loc7_.y;
|
||||
_loc11_ = _loc6_ * _loc22_ + _loc8_ * _loc24_;
|
||||
_loc13_ = _loc23_ * _loc22_ + _loc21_ * _loc24_;
|
||||
if(_loc11_ < _loc15_)
|
||||
{
|
||||
_loc15_ = _loc11_;
|
||||
}
|
||||
if(_loc13_ < _loc12_)
|
||||
{
|
||||
_loc12_ = _loc13_;
|
||||
}
|
||||
if(_loc11_ > _loc20_)
|
||||
{
|
||||
_loc20_ = _loc11_;
|
||||
}
|
||||
if(_loc13_ > _loc19_)
|
||||
{
|
||||
_loc19_ = _loc13_;
|
||||
}
|
||||
_loc17_++;
|
||||
}
|
||||
_loc10_ = (_loc20_ - _loc15_) * (_loc19_ - _loc12_);
|
||||
if(_loc10_ < 0.95 * _loc9_)
|
||||
{
|
||||
_loc9_ = _loc10_;
|
||||
param1.R.col1.x = _loc6_;
|
||||
param1.R.col1.y = _loc8_;
|
||||
param1.R.col2.x = _loc23_;
|
||||
param1.R.col2.y = _loc21_;
|
||||
_loc5_ = 0.5 * (_loc15_ + _loc20_);
|
||||
_loc4_ = 0.5 * (_loc12_ + _loc19_);
|
||||
_loc25_ = param1.R;
|
||||
param1.center.x = _loc7_.x + (_loc25_.col1.x * _loc5_ + _loc25_.col2.x * _loc4_);
|
||||
param1.center.y = _loc7_.y + (_loc25_.col1.y * _loc5_ + _loc25_.col2.y * _loc4_);
|
||||
param1.extents.x = 0.5 * (_loc20_ - _loc15_);
|
||||
param1.extents.y = 0.5 * (_loc19_ - _loc12_);
|
||||
}
|
||||
_loc16_++;
|
||||
}
|
||||
}
|
||||
|
||||
override public function TestPoint(param1:b2XForm, param2:b2Vec2) : Boolean
|
||||
{
|
||||
var _loc5_:b2Vec2 = null;
|
||||
var _loc9_:int = 0;
|
||||
var _loc6_:Number = NaN;
|
||||
var _loc7_:b2Mat22 = param1.R;
|
||||
var _loc3_:Number = param2.x - param1.position.x;
|
||||
var _loc4_:Number = param2.y - param1.position.y;
|
||||
var _loc8_:Number = _loc3_ * _loc7_.col1.x + _loc4_ * _loc7_.col1.y;
|
||||
var _loc10_:Number = _loc3_ * _loc7_.col2.x + _loc4_ * _loc7_.col2.y;
|
||||
_loc9_ = 0;
|
||||
while(_loc9_ < m_vertexCount)
|
||||
{
|
||||
_loc5_ = m_vertices[_loc9_];
|
||||
_loc3_ = _loc8_ - _loc5_.x;
|
||||
_loc4_ = _loc10_ - _loc5_.y;
|
||||
_loc5_ = m_normals[_loc9_];
|
||||
_loc6_ = _loc5_.x * _loc3_ + _loc5_.y * _loc4_;
|
||||
if(_loc6_ > 0)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
_loc9_++;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
override public function TestSegment(param1:b2XForm, param2:Array, param3:b2Vec2, param4:b2Segment, param5:Number) : Boolean
|
||||
{
|
||||
var _loc6_:Number = NaN;
|
||||
var _loc7_:Number = NaN;
|
||||
var _loc20_:b2Mat22 = null;
|
||||
var _loc16_:b2Vec2 = null;
|
||||
var _loc11_:int = 0;
|
||||
var _loc12_:Number = NaN;
|
||||
var _loc13_:Number = NaN;
|
||||
var _loc8_:Number = 0;
|
||||
var _loc9_:Number = param5;
|
||||
_loc6_ = param4.p1.x - param1.position.x;
|
||||
_loc7_ = param4.p1.y - param1.position.y;
|
||||
_loc20_ = param1.R;
|
||||
var _loc17_:Number = _loc6_ * _loc20_.col1.x + _loc7_ * _loc20_.col1.y;
|
||||
var _loc21_:Number = _loc6_ * _loc20_.col2.x + _loc7_ * _loc20_.col2.y;
|
||||
_loc6_ = param4.p2.x - param1.position.x;
|
||||
_loc7_ = param4.p2.y - param1.position.y;
|
||||
_loc20_ = param1.R;
|
||||
var _loc19_:Number = _loc6_ * _loc20_.col1.x + _loc7_ * _loc20_.col1.y;
|
||||
var _loc18_:Number = _loc6_ * _loc20_.col2.x + _loc7_ * _loc20_.col2.y;
|
||||
var _loc14_:Number = _loc19_ - _loc17_;
|
||||
var _loc15_:Number = _loc18_ - _loc21_;
|
||||
var _loc10_:* = -1;
|
||||
_loc11_ = 0;
|
||||
while(_loc11_ < m_vertexCount)
|
||||
{
|
||||
_loc16_ = m_vertices[_loc11_];
|
||||
_loc6_ = _loc16_.x - _loc17_;
|
||||
_loc7_ = _loc16_.y - _loc21_;
|
||||
_loc16_ = m_normals[_loc11_];
|
||||
_loc12_ = _loc16_.x * _loc6_ + _loc16_.y * _loc7_;
|
||||
_loc13_ = _loc16_.x * _loc14_ + _loc16_.y * _loc15_;
|
||||
if(_loc13_ < 0 && _loc12_ < _loc8_ * _loc13_)
|
||||
{
|
||||
_loc8_ = _loc12_ / _loc13_;
|
||||
_loc10_ = _loc11_;
|
||||
}
|
||||
else if(_loc13_ > 0 && _loc12_ < _loc9_ * _loc13_)
|
||||
{
|
||||
_loc9_ = _loc12_ / _loc13_;
|
||||
}
|
||||
if(_loc9_ < _loc8_)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
_loc11_++;
|
||||
}
|
||||
if(_loc10_ >= 0)
|
||||
{
|
||||
param2[0] = _loc8_;
|
||||
_loc20_ = param1.R;
|
||||
_loc16_ = m_normals[_loc10_];
|
||||
param3.x = _loc20_.col1.x * _loc16_.x + _loc20_.col2.x * _loc16_.y;
|
||||
param3.y = _loc20_.col1.y * _loc16_.x + _loc20_.col2.y * _loc16_.y;
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
override public function ComputeAABB(param1:b2AABB, param2:b2XForm) : void
|
||||
{
|
||||
var _loc8_:b2Mat22 = null;
|
||||
var _loc7_:b2Vec2 = null;
|
||||
var _loc6_:b2Mat22 = s_computeMat;
|
||||
_loc8_ = param2.R;
|
||||
_loc7_ = m_obb.R.col1;
|
||||
_loc6_.col1.x = _loc8_.col1.x * _loc7_.x + _loc8_.col2.x * _loc7_.y;
|
||||
_loc6_.col1.y = _loc8_.col1.y * _loc7_.x + _loc8_.col2.y * _loc7_.y;
|
||||
_loc7_ = m_obb.R.col2;
|
||||
_loc6_.col2.x = _loc8_.col1.x * _loc7_.x + _loc8_.col2.x * _loc7_.y;
|
||||
_loc6_.col2.y = _loc8_.col1.y * _loc7_.x + _loc8_.col2.y * _loc7_.y;
|
||||
_loc6_.Abs();
|
||||
var _loc9_:b2Mat22 = _loc6_;
|
||||
_loc7_ = m_obb.extents;
|
||||
var _loc3_:Number = _loc9_.col1.x * _loc7_.x + _loc9_.col2.x * _loc7_.y;
|
||||
var _loc5_:Number = _loc9_.col1.y * _loc7_.x + _loc9_.col2.y * _loc7_.y;
|
||||
_loc8_ = param2.R;
|
||||
_loc7_ = m_obb.center;
|
||||
var _loc10_:Number = param2.position.x + (_loc8_.col1.x * _loc7_.x + _loc8_.col2.x * _loc7_.y);
|
||||
var _loc4_:Number = param2.position.y + (_loc8_.col1.y * _loc7_.x + _loc8_.col2.y * _loc7_.y);
|
||||
param1.lowerBound.Set(_loc10_ - _loc3_,_loc4_ - _loc5_);
|
||||
param1.upperBound.Set(_loc10_ + _loc3_,_loc4_ + _loc5_);
|
||||
}
|
||||
|
||||
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 _loc16_:int = 0;
|
||||
var _loc3_:b2Vec2 = null;
|
||||
var _loc4_:b2Vec2 = null;
|
||||
var _loc18_:Number = NaN;
|
||||
var _loc17_:Number = NaN;
|
||||
var _loc10_:Number = NaN;
|
||||
var _loc11_:Number = NaN;
|
||||
var _loc5_:Number = NaN;
|
||||
var _loc21_:Number = NaN;
|
||||
var _loc7_:Number = NaN;
|
||||
var _loc9_:Number = NaN;
|
||||
var _loc14_:Number = NaN;
|
||||
var _loc24_:Number = NaN;
|
||||
var _loc13_:Number = NaN;
|
||||
var _loc25_:Number = NaN;
|
||||
var _loc12_:Number = NaN;
|
||||
var _loc19_:Number = NaN;
|
||||
var _loc6_:Number = 0;
|
||||
var _loc2_:Number = 0;
|
||||
var _loc15_:Number = 0;
|
||||
var _loc8_:Number = 0;
|
||||
var _loc22_:Number = 0;
|
||||
var _loc23_:Number = 0;
|
||||
var _loc20_:Number = 0.3333333333333333;
|
||||
_loc16_ = 0;
|
||||
while(_loc16_ < m_vertexCount)
|
||||
{
|
||||
_loc3_ = m_vertices[_loc16_];
|
||||
_loc4_ = _loc16_ + 1 < m_vertexCount ? m_vertices[int(_loc16_ + 1)] : m_vertices[0];
|
||||
_loc18_ = _loc3_.x - _loc22_;
|
||||
_loc17_ = _loc3_.y - _loc23_;
|
||||
_loc10_ = _loc4_.x - _loc22_;
|
||||
_loc11_ = _loc4_.y - _loc23_;
|
||||
_loc5_ = _loc18_ * _loc11_ - _loc17_ * _loc10_;
|
||||
_loc21_ = 0.5 * _loc5_;
|
||||
_loc15_ += _loc21_;
|
||||
_loc6_ += _loc21_ * _loc20_ * (_loc22_ + _loc3_.x + _loc4_.x);
|
||||
_loc2_ += _loc21_ * _loc20_ * (_loc23_ + _loc3_.y + _loc4_.y);
|
||||
_loc7_ = _loc22_;
|
||||
_loc9_ = _loc23_;
|
||||
_loc14_ = _loc18_;
|
||||
_loc24_ = _loc17_;
|
||||
_loc13_ = _loc10_;
|
||||
_loc25_ = _loc11_;
|
||||
_loc12_ = _loc20_ * (0.25 * (_loc14_ * _loc14_ + _loc13_ * _loc14_ + _loc13_ * _loc13_) + (_loc7_ * _loc14_ + _loc7_ * _loc13_)) + 0.5 * _loc7_ * _loc7_;
|
||||
_loc19_ = _loc20_ * (0.25 * (_loc24_ * _loc24_ + _loc25_ * _loc24_ + _loc25_ * _loc25_) + (_loc9_ * _loc24_ + _loc9_ * _loc25_)) + 0.5 * _loc9_ * _loc9_;
|
||||
_loc8_ += _loc5_ * (_loc12_ + _loc19_);
|
||||
_loc16_++;
|
||||
}
|
||||
param1.mass = m_density * _loc15_;
|
||||
_loc6_ *= 1 / _loc15_;
|
||||
_loc2_ *= 1 / _loc15_;
|
||||
param1.center.Set(_loc6_,_loc2_);
|
||||
param1.I = m_density * _loc8_;
|
||||
}
|
||||
|
||||
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 _loc4_:b2Vec2 = null;
|
||||
var _loc6_:b2Mat22 = null;
|
||||
var _loc7_:int = 0;
|
||||
var _loc10_:Number = NaN;
|
||||
_loc6_ = param1.R;
|
||||
var _loc8_:Number = param2 * _loc6_.col1.x + param3 * _loc6_.col1.y;
|
||||
var _loc5_:Number = param2 * _loc6_.col2.x + param3 * _loc6_.col2.y;
|
||||
var _loc11_:int = 0;
|
||||
_loc4_ = m_coreVertices[0];
|
||||
var _loc9_:Number = _loc4_.x * _loc8_ + _loc4_.y * _loc5_;
|
||||
_loc7_ = 1;
|
||||
while(_loc7_ < m_vertexCount)
|
||||
{
|
||||
_loc4_ = m_coreVertices[_loc7_];
|
||||
_loc10_ = _loc4_.x * _loc8_ + _loc4_.y * _loc5_;
|
||||
if(_loc10_ > _loc9_)
|
||||
{
|
||||
_loc11_ = _loc7_;
|
||||
_loc9_ = _loc10_;
|
||||
}
|
||||
_loc7_++;
|
||||
}
|
||||
_loc6_ = param1.R;
|
||||
_loc4_ = m_coreVertices[_loc11_];
|
||||
s_supportVec.x = param1.position.x + (_loc6_.col1.x * _loc4_.x + _loc6_.col2.x * _loc4_.y);
|
||||
s_supportVec.y = param1.position.y + (_loc6_.col1.y * _loc4_.x + _loc6_.col2.y * _loc4_.y);
|
||||
return s_supportVec;
|
||||
}
|
||||
|
||||
override public function UpdateSweepRadius(param1:b2Vec2) : void
|
||||
{
|
||||
var _loc4_:b2Vec2 = null;
|
||||
var _loc5_:int = 0;
|
||||
var _loc2_:Number = NaN;
|
||||
var _loc3_:Number = NaN;
|
||||
m_sweepRadius = 0;
|
||||
_loc5_ = 0;
|
||||
while(_loc5_ < m_vertexCount)
|
||||
{
|
||||
_loc4_ = m_coreVertices[_loc5_];
|
||||
_loc2_ = _loc4_.x - param1.x;
|
||||
_loc3_ = _loc4_.y - param1.y;
|
||||
_loc2_ = Math.sqrt(_loc2_ * _loc2_ + _loc3_ * _loc3_);
|
||||
if(_loc2_ > m_sweepRadius)
|
||||
{
|
||||
m_sweepRadius = _loc2_;
|
||||
}
|
||||
_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 _loc4_:b2AABB = s_proxyAABB;
|
||||
ComputeAABB(_loc4_,param2);
|
||||
var _loc3_:Boolean = param1.InRange(_loc4_);
|
||||
if(_loc3_)
|
||||
{
|
||||
m_proxyId = param1.CreateProxy(_loc4_,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 _loc4_:b2AABB = s_resetAABB;
|
||||
ComputeAABB(_loc4_,param2);
|
||||
var _loc3_:Boolean = param1.InRange(_loc4_);
|
||||
if(_loc3_)
|
||||
{
|
||||
m_proxyId = param1.CreateProxy(_loc4_,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();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Reference in new issue
Block a user