mirror of
https://github.com/burrow-dev/burrow-server.git
synced 2026-11-18 17:27: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,116 @@
|
||||
package Box2D.Dynamics.Contacts
|
||||
{
|
||||
import Box2D.Collision.*;
|
||||
import Box2D.Collision.Shapes.*;
|
||||
import Box2D.Common.*;
|
||||
import Box2D.Common.Math.*;
|
||||
import Box2D.Dynamics.*;
|
||||
|
||||
public class b2CircleContact extends b2Contact
|
||||
{
|
||||
|
||||
private static const s_evalCP:b2ContactPoint = new b2ContactPoint();
|
||||
|
||||
private var m_manifolds:Array = [new b2Manifold()];
|
||||
|
||||
public var m_manifold:b2Manifold;
|
||||
|
||||
private var m0:b2Manifold = new b2Manifold();
|
||||
|
||||
public function b2CircleContact(param1:b2Shape, param2:b2Shape)
|
||||
{
|
||||
super(param1,param2);
|
||||
m_manifold = m_manifolds[0];
|
||||
m_manifold.pointCount = 0;
|
||||
var _loc3_:b2ManifoldPoint = m_manifold.points[0];
|
||||
_loc3_.normalImpulse = 0;
|
||||
_loc3_.tangentImpulse = 0;
|
||||
}
|
||||
|
||||
public static function Create(param1:b2Shape, param2:b2Shape, param3:*) : b2Contact
|
||||
{
|
||||
return new b2CircleContact(param1,param2);
|
||||
}
|
||||
|
||||
public static function Destroy(param1:b2Contact, param2:*) : void
|
||||
{
|
||||
}
|
||||
|
||||
override public function Evaluate(param1:b2ContactListener) : void
|
||||
{
|
||||
var _loc4_:b2Vec2 = null;
|
||||
var _loc5_:b2Vec2 = null;
|
||||
var _loc6_:b2ManifoldPoint = null;
|
||||
var _loc3_:b2ManifoldPoint = null;
|
||||
var _loc8_:b2Body = m_shape1.m_body;
|
||||
var _loc2_:b2Body = m_shape2.m_body;
|
||||
m0.Set(m_manifold);
|
||||
b2Collision.b2CollideCircles(m_manifold,m_shape1 as b2CircleShape,_loc8_.m_xf,m_shape2 as b2CircleShape,_loc2_.m_xf);
|
||||
var _loc7_:b2ContactPoint = s_evalCP;
|
||||
_loc7_.shape1 = m_shape1;
|
||||
_loc7_.shape2 = m_shape2;
|
||||
_loc7_.friction = m_friction;
|
||||
_loc7_.restitution = m_restitution;
|
||||
if(m_manifold.pointCount > 0)
|
||||
{
|
||||
m_manifoldCount = 1;
|
||||
_loc3_ = m_manifold.points[0];
|
||||
if(m0.pointCount == 0)
|
||||
{
|
||||
_loc3_.normalImpulse = 0;
|
||||
_loc3_.tangentImpulse = 0;
|
||||
if(param1)
|
||||
{
|
||||
_loc7_.position = _loc8_.GetWorldPoint(_loc3_.localPoint1);
|
||||
_loc4_ = _loc8_.GetLinearVelocityFromLocalPoint(_loc3_.localPoint1);
|
||||
_loc5_ = _loc2_.GetLinearVelocityFromLocalPoint(_loc3_.localPoint2);
|
||||
_loc7_.velocity.Set(_loc5_.x - _loc4_.x,_loc5_.y - _loc4_.y);
|
||||
_loc7_.normal.SetV(m_manifold.normal);
|
||||
_loc7_.separation = _loc3_.separation;
|
||||
_loc7_.id.key = _loc3_.id._key;
|
||||
param1.Add(_loc7_);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
_loc6_ = m0.points[0];
|
||||
_loc3_.normalImpulse = _loc6_.normalImpulse;
|
||||
_loc3_.tangentImpulse = _loc6_.tangentImpulse;
|
||||
if(param1)
|
||||
{
|
||||
_loc7_.position = _loc8_.GetWorldPoint(_loc3_.localPoint1);
|
||||
_loc4_ = _loc8_.GetLinearVelocityFromLocalPoint(_loc3_.localPoint1);
|
||||
_loc5_ = _loc2_.GetLinearVelocityFromLocalPoint(_loc3_.localPoint2);
|
||||
_loc7_.velocity.Set(_loc5_.x - _loc4_.x,_loc5_.y - _loc4_.y);
|
||||
_loc7_.normal.SetV(m_manifold.normal);
|
||||
_loc7_.separation = _loc3_.separation;
|
||||
_loc7_.id.key = _loc3_.id._key;
|
||||
param1.Persist(_loc7_);
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
m_manifoldCount = 0;
|
||||
if(m0.pointCount > 0 && param1)
|
||||
{
|
||||
_loc6_ = m0.points[0];
|
||||
_loc7_.position = _loc8_.GetWorldPoint(_loc6_.localPoint1);
|
||||
_loc4_ = _loc8_.GetLinearVelocityFromLocalPoint(_loc6_.localPoint1);
|
||||
_loc5_ = _loc2_.GetLinearVelocityFromLocalPoint(_loc6_.localPoint2);
|
||||
_loc7_.velocity.Set(_loc5_.x - _loc4_.x,_loc5_.y - _loc4_.y);
|
||||
_loc7_.normal.SetV(m0.normal);
|
||||
_loc7_.separation = _loc6_.separation;
|
||||
_loc7_.id.key = _loc6_.id._key;
|
||||
param1.Remove(_loc7_);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
override public function GetManifolds() : Array
|
||||
{
|
||||
return m_manifolds;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,216 @@
|
||||
package Box2D.Dynamics.Contacts
|
||||
{
|
||||
import Box2D.Collision.*;
|
||||
import Box2D.Collision.Shapes.*;
|
||||
import Box2D.Common.*;
|
||||
import Box2D.Common.Math.*;
|
||||
import Box2D.Dynamics.*;
|
||||
|
||||
public class b2Contact
|
||||
{
|
||||
|
||||
public static var e_nonSolidFlag:uint = 1;
|
||||
|
||||
public static var e_slowFlag:uint = 2;
|
||||
|
||||
public static var e_islandFlag:uint = 4;
|
||||
|
||||
public static var e_toiFlag:uint = 8;
|
||||
|
||||
public static var s_registers:Array;
|
||||
|
||||
public static var s_initialized:Boolean = false;
|
||||
|
||||
public var m_flags:uint;
|
||||
|
||||
public var m_prev:b2Contact;
|
||||
|
||||
public var m_next:b2Contact;
|
||||
|
||||
public var m_node1:b2ContactEdge = new b2ContactEdge();
|
||||
|
||||
public var m_node2:b2ContactEdge = new b2ContactEdge();
|
||||
|
||||
public var m_shape1:b2Shape;
|
||||
|
||||
public var m_shape2:b2Shape;
|
||||
|
||||
public var m_manifoldCount:int;
|
||||
|
||||
public var m_friction:Number;
|
||||
|
||||
public var m_restitution:Number;
|
||||
|
||||
public var m_toi:Number;
|
||||
|
||||
public function b2Contact(param1:b2Shape = null, param2:b2Shape = null)
|
||||
{
|
||||
super();
|
||||
m_flags = 0;
|
||||
if(!param1 || !param2)
|
||||
{
|
||||
m_shape1 = null;
|
||||
m_shape2 = null;
|
||||
return;
|
||||
}
|
||||
if(param1.IsSensor() || param2.IsSensor())
|
||||
{
|
||||
m_flags |= e_nonSolidFlag;
|
||||
}
|
||||
m_shape1 = param1;
|
||||
m_shape2 = param2;
|
||||
m_manifoldCount = 0;
|
||||
m_friction = Math.sqrt(m_shape1.m_friction * m_shape2.m_friction);
|
||||
m_restitution = b2Math.b2Max(m_shape1.m_restitution,m_shape2.m_restitution);
|
||||
m_prev = null;
|
||||
m_next = null;
|
||||
m_node1.contact = null;
|
||||
m_node1.prev = null;
|
||||
m_node1.next = null;
|
||||
m_node1.other = null;
|
||||
m_node2.contact = null;
|
||||
m_node2.prev = null;
|
||||
m_node2.next = null;
|
||||
m_node2.other = null;
|
||||
}
|
||||
|
||||
public static function AddType(param1:Function, param2:Function, param3:int, param4:int) : void
|
||||
{
|
||||
s_registers[param3][param4].createFcn = param1;
|
||||
s_registers[param3][param4].destroyFcn = param2;
|
||||
s_registers[param3][param4].primary = true;
|
||||
if(param3 != param4)
|
||||
{
|
||||
s_registers[param4][param3].createFcn = param1;
|
||||
s_registers[param4][param3].destroyFcn = param2;
|
||||
s_registers[param4][param3].primary = false;
|
||||
}
|
||||
}
|
||||
|
||||
public static function InitializeRegisters() : void
|
||||
{
|
||||
var _loc1_:int = 0;
|
||||
var _loc2_:int = 0;
|
||||
s_registers = new Array(2);
|
||||
_loc1_ = 0;
|
||||
while(_loc1_ < 2)
|
||||
{
|
||||
s_registers[_loc1_] = new Array(2);
|
||||
_loc2_ = 0;
|
||||
while(_loc2_ < 2)
|
||||
{
|
||||
s_registers[_loc1_][_loc2_] = new b2ContactRegister();
|
||||
_loc2_++;
|
||||
}
|
||||
_loc1_++;
|
||||
}
|
||||
AddType(b2CircleContact.Create,b2CircleContact.Destroy,0,0);
|
||||
AddType(b2PolyAndCircleContact.Create,b2PolyAndCircleContact.Destroy,1,0);
|
||||
AddType(b2PolygonContact.Create,b2PolygonContact.Destroy,1,1);
|
||||
}
|
||||
|
||||
public static function Create(param1:b2Shape, param2:b2Shape, param3:*) : b2Contact
|
||||
{
|
||||
var _loc5_:b2Contact = null;
|
||||
var _loc7_:int = 0;
|
||||
var _loc9_:b2Manifold = null;
|
||||
if(s_initialized == false)
|
||||
{
|
||||
InitializeRegisters();
|
||||
s_initialized = true;
|
||||
}
|
||||
var _loc8_:int = param1.m_type;
|
||||
var _loc4_:int = param2.m_type;
|
||||
var _loc6_:b2ContactRegister = s_registers[_loc8_][_loc4_];
|
||||
var _loc10_:Function = _loc6_.createFcn;
|
||||
if(_loc10_ != null)
|
||||
{
|
||||
if(_loc6_.primary)
|
||||
{
|
||||
return _loc10_(param1,param2,param3);
|
||||
}
|
||||
_loc5_ = _loc10_(param2,param1,param3);
|
||||
_loc7_ = 0;
|
||||
while(_loc7_ < _loc5_.m_manifoldCount)
|
||||
{
|
||||
_loc9_ = _loc5_.GetManifolds()[_loc7_];
|
||||
_loc9_.normal = _loc9_.normal.Negative();
|
||||
_loc7_++;
|
||||
}
|
||||
return _loc5_;
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
public static function Destroy(param1:b2Contact, param2:*) : void
|
||||
{
|
||||
if(param1.m_manifoldCount > 0)
|
||||
{
|
||||
param1.m_shape1.m_body.WakeUp();
|
||||
param1.m_shape2.m_body.WakeUp();
|
||||
}
|
||||
var _loc6_:int = param1.m_shape1.m_type;
|
||||
var _loc4_:int = param1.m_shape2.m_type;
|
||||
var _loc5_:b2ContactRegister = s_registers[_loc6_][_loc4_];
|
||||
var _loc3_:Function = _loc5_.destroyFcn;
|
||||
_loc3_(param1,param2);
|
||||
}
|
||||
|
||||
public function GetManifolds() : Array
|
||||
{
|
||||
return null;
|
||||
}
|
||||
|
||||
public function GetManifoldCount() : int
|
||||
{
|
||||
return m_manifoldCount;
|
||||
}
|
||||
|
||||
public function IsSolid() : Boolean
|
||||
{
|
||||
return (m_flags & e_nonSolidFlag) == 0;
|
||||
}
|
||||
|
||||
public function GetNext() : b2Contact
|
||||
{
|
||||
return m_next;
|
||||
}
|
||||
|
||||
public function GetShape1() : b2Shape
|
||||
{
|
||||
return m_shape1;
|
||||
}
|
||||
|
||||
public function GetShape2() : b2Shape
|
||||
{
|
||||
return m_shape2;
|
||||
}
|
||||
|
||||
public function Update(param1:b2ContactListener) : void
|
||||
{
|
||||
var _loc2_:int = m_manifoldCount;
|
||||
Evaluate(param1);
|
||||
var _loc3_:int = m_manifoldCount;
|
||||
var _loc4_:b2Body = m_shape1.m_body;
|
||||
var _loc5_:b2Body = m_shape2.m_body;
|
||||
if(_loc3_ == 0 && _loc2_ > 0)
|
||||
{
|
||||
_loc4_.WakeUp();
|
||||
_loc5_.WakeUp();
|
||||
}
|
||||
if(_loc4_.IsStatic() || _loc4_.IsBullet() || _loc5_.IsStatic() || _loc5_.IsBullet())
|
||||
{
|
||||
m_flags &= ~e_slowFlag;
|
||||
}
|
||||
else
|
||||
{
|
||||
m_flags |= e_slowFlag;
|
||||
}
|
||||
}
|
||||
|
||||
public function Evaluate(param1:b2ContactListener) : void
|
||||
{
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,41 @@
|
||||
package Box2D.Dynamics.Contacts
|
||||
{
|
||||
import Box2D.Collision.*;
|
||||
import Box2D.Common.*;
|
||||
import Box2D.Common.Math.*;
|
||||
import Box2D.Dynamics.*;
|
||||
|
||||
public class b2ContactConstraint
|
||||
{
|
||||
|
||||
public var points:Array;
|
||||
|
||||
public var normal:b2Vec2 = new b2Vec2();
|
||||
|
||||
public var manifold:b2Manifold;
|
||||
|
||||
public var body1:b2Body;
|
||||
|
||||
public var body2:b2Body;
|
||||
|
||||
public var friction:Number;
|
||||
|
||||
public var restitution:Number;
|
||||
|
||||
public var pointCount:int;
|
||||
|
||||
public function b2ContactConstraint()
|
||||
{
|
||||
var _loc1_:int = 0;
|
||||
super();
|
||||
points = new Array(2);
|
||||
_loc1_ = 0;
|
||||
while(_loc1_ < 2)
|
||||
{
|
||||
points[_loc1_] = new b2ContactConstraintPoint();
|
||||
_loc1_++;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,38 @@
|
||||
package Box2D.Dynamics.Contacts
|
||||
{
|
||||
import Box2D.Common.Math.b2Vec2;
|
||||
|
||||
public class b2ContactConstraintPoint
|
||||
{
|
||||
|
||||
public var localAnchor1:b2Vec2 = new b2Vec2();
|
||||
|
||||
public var localAnchor2:b2Vec2 = new b2Vec2();
|
||||
|
||||
public var r1:b2Vec2 = new b2Vec2();
|
||||
|
||||
public var r2:b2Vec2 = new b2Vec2();
|
||||
|
||||
public var normalImpulse:Number;
|
||||
|
||||
public var tangentImpulse:Number;
|
||||
|
||||
public var positionImpulse:Number;
|
||||
|
||||
public var normalMass:Number;
|
||||
|
||||
public var tangentMass:Number;
|
||||
|
||||
public var equalizedMass:Number;
|
||||
|
||||
public var separation:Number;
|
||||
|
||||
public var velocityBias:Number;
|
||||
|
||||
public function b2ContactConstraintPoint()
|
||||
{
|
||||
super();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,22 @@
|
||||
package Box2D.Dynamics.Contacts
|
||||
{
|
||||
import Box2D.Dynamics.b2Body;
|
||||
|
||||
public class b2ContactEdge
|
||||
{
|
||||
|
||||
public var other:b2Body;
|
||||
|
||||
public var contact:b2Contact;
|
||||
|
||||
public var prev:b2ContactEdge;
|
||||
|
||||
public var next:b2ContactEdge;
|
||||
|
||||
public function b2ContactEdge()
|
||||
{
|
||||
super();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,18 @@
|
||||
package Box2D.Dynamics.Contacts
|
||||
{
|
||||
public class b2ContactRegister
|
||||
{
|
||||
|
||||
public var createFcn:Function;
|
||||
|
||||
public var destroyFcn:Function;
|
||||
|
||||
public var primary:Boolean;
|
||||
|
||||
public function b2ContactRegister()
|
||||
{
|
||||
super();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,30 @@
|
||||
package Box2D.Dynamics.Contacts
|
||||
{
|
||||
import Box2D.Collision.Shapes.b2Shape;
|
||||
import Box2D.Collision.b2ContactID;
|
||||
import Box2D.Common.Math.b2Vec2;
|
||||
|
||||
public class b2ContactResult
|
||||
{
|
||||
|
||||
public var shape1:b2Shape;
|
||||
|
||||
public var shape2:b2Shape;
|
||||
|
||||
public var position:b2Vec2 = new b2Vec2();
|
||||
|
||||
public var normal:b2Vec2 = new b2Vec2();
|
||||
|
||||
public var normalImpulse:Number;
|
||||
|
||||
public var tangentImpulse:Number;
|
||||
|
||||
public var id:b2ContactID = new b2ContactID();
|
||||
|
||||
public function b2ContactResult()
|
||||
{
|
||||
super();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,475 @@
|
||||
package Box2D.Dynamics.Contacts
|
||||
{
|
||||
import Box2D.Collision.*;
|
||||
import Box2D.Common.*;
|
||||
import Box2D.Common.Math.*;
|
||||
import Box2D.Dynamics.*;
|
||||
|
||||
public class b2ContactSolver
|
||||
{
|
||||
|
||||
public var m_step:b2TimeStep = new b2TimeStep();
|
||||
|
||||
public var m_allocator:*;
|
||||
|
||||
public var m_constraints:Array = [];
|
||||
|
||||
public var m_constraintCount:int;
|
||||
|
||||
public function b2ContactSolver(param1:b2TimeStep, param2:Array, param3:int, param4:*)
|
||||
{
|
||||
var _loc14_:b2Contact = null;
|
||||
var _loc28_:int = 0;
|
||||
var _loc40_:* = null;
|
||||
var _loc44_:b2Mat22 = null;
|
||||
var _loc9_:b2Body = null;
|
||||
var _loc10_:b2Body = null;
|
||||
var _loc11_:int = 0;
|
||||
var _loc6_:Array = null;
|
||||
var _loc33_:Number = NaN;
|
||||
var _loc37_:Number = NaN;
|
||||
var _loc46_:Number = NaN;
|
||||
var _loc47_:Number = NaN;
|
||||
var _loc21_:Number = NaN;
|
||||
var _loc20_:Number = NaN;
|
||||
var _loc18_:Number = NaN;
|
||||
var _loc19_:Number = NaN;
|
||||
var _loc29_:int = 0;
|
||||
var _loc16_:b2Manifold = null;
|
||||
var _loc5_:Number = NaN;
|
||||
var _loc7_:Number = NaN;
|
||||
var _loc23_:b2ContactConstraint = null;
|
||||
var _loc31_:* = 0;
|
||||
var _loc32_:b2ManifoldPoint = null;
|
||||
var _loc12_:b2ContactConstraintPoint = null;
|
||||
var _loc24_:Number = NaN;
|
||||
var _loc25_:Number = NaN;
|
||||
var _loc43_:Number = NaN;
|
||||
var _loc45_:Number = NaN;
|
||||
var _loc17_:Number = NaN;
|
||||
var _loc15_:Number = NaN;
|
||||
var _loc8_:Number = NaN;
|
||||
var _loc30_:Number = NaN;
|
||||
var _loc38_:Number = NaN;
|
||||
var _loc41_:Number = NaN;
|
||||
var _loc13_:Number = NaN;
|
||||
var _loc36_:Number = NaN;
|
||||
var _loc26_:Number = NaN;
|
||||
var _loc22_:Number = NaN;
|
||||
var _loc34_:Number = NaN;
|
||||
var _loc35_:Number = NaN;
|
||||
var _loc42_:Number = NaN;
|
||||
var _loc39_:Number = NaN;
|
||||
super();
|
||||
m_step.dt = param1.dt;
|
||||
m_step.inv_dt = param1.inv_dt;
|
||||
m_step.maxIterations = param1.maxIterations;
|
||||
m_allocator = param4;
|
||||
m_constraintCount = 0;
|
||||
_loc28_ = 0;
|
||||
while(_loc28_ < param3)
|
||||
{
|
||||
_loc14_ = param2[_loc28_];
|
||||
m_constraintCount += _loc14_.m_manifoldCount;
|
||||
_loc28_++;
|
||||
}
|
||||
_loc28_ = 0;
|
||||
while(_loc28_ < m_constraintCount)
|
||||
{
|
||||
m_constraints[_loc28_] = new b2ContactConstraint();
|
||||
_loc28_++;
|
||||
}
|
||||
var _loc27_:int = 0;
|
||||
_loc28_ = 0;
|
||||
while(_loc28_ < param3)
|
||||
{
|
||||
_loc14_ = param2[_loc28_];
|
||||
_loc9_ = _loc14_.m_shape1.m_body;
|
||||
_loc10_ = _loc14_.m_shape2.m_body;
|
||||
_loc11_ = _loc14_.m_manifoldCount;
|
||||
_loc6_ = _loc14_.GetManifolds();
|
||||
_loc33_ = _loc14_.m_friction;
|
||||
_loc37_ = _loc14_.m_restitution;
|
||||
_loc46_ = _loc9_.m_linearVelocity.x;
|
||||
_loc47_ = _loc9_.m_linearVelocity.y;
|
||||
_loc21_ = _loc10_.m_linearVelocity.x;
|
||||
_loc20_ = _loc10_.m_linearVelocity.y;
|
||||
_loc18_ = _loc9_.m_angularVelocity;
|
||||
_loc19_ = _loc10_.m_angularVelocity;
|
||||
_loc29_ = 0;
|
||||
while(_loc29_ < _loc11_)
|
||||
{
|
||||
_loc16_ = _loc6_[_loc29_];
|
||||
_loc5_ = _loc16_.normal.x;
|
||||
_loc7_ = _loc16_.normal.y;
|
||||
_loc23_ = m_constraints[_loc27_];
|
||||
_loc23_.body1 = _loc9_;
|
||||
_loc23_.body2 = _loc10_;
|
||||
_loc23_.manifold = _loc16_;
|
||||
_loc23_.normal.x = _loc5_;
|
||||
_loc23_.normal.y = _loc7_;
|
||||
_loc23_.pointCount = _loc16_.pointCount;
|
||||
_loc23_.friction = _loc33_;
|
||||
_loc23_.restitution = _loc37_;
|
||||
_loc31_ = 0;
|
||||
while(_loc31_ < _loc23_.pointCount)
|
||||
{
|
||||
_loc32_ = _loc16_.points[_loc31_];
|
||||
_loc12_ = _loc23_.points[_loc31_];
|
||||
_loc12_.normalImpulse = _loc32_.normalImpulse;
|
||||
_loc12_.tangentImpulse = _loc32_.tangentImpulse;
|
||||
_loc12_.separation = _loc32_.separation;
|
||||
_loc12_.positionImpulse = 0;
|
||||
_loc12_.localAnchor1.SetV(_loc32_.localPoint1);
|
||||
_loc12_.localAnchor2.SetV(_loc32_.localPoint2);
|
||||
_loc44_ = _loc9_.m_xf.R;
|
||||
_loc43_ = _loc32_.localPoint1.x - _loc9_.m_sweep.localCenter.x;
|
||||
_loc45_ = _loc32_.localPoint1.y - _loc9_.m_sweep.localCenter.y;
|
||||
_loc24_ = _loc44_.col1.x * _loc43_ + _loc44_.col2.x * _loc45_;
|
||||
_loc45_ = _loc44_.col1.y * _loc43_ + _loc44_.col2.y * _loc45_;
|
||||
_loc43_ = _loc24_;
|
||||
_loc12_.r1.Set(_loc43_,_loc45_);
|
||||
_loc44_ = _loc10_.m_xf.R;
|
||||
_loc17_ = _loc32_.localPoint2.x - _loc10_.m_sweep.localCenter.x;
|
||||
_loc15_ = _loc32_.localPoint2.y - _loc10_.m_sweep.localCenter.y;
|
||||
_loc24_ = _loc44_.col1.x * _loc17_ + _loc44_.col2.x * _loc15_;
|
||||
_loc15_ = _loc44_.col1.y * _loc17_ + _loc44_.col2.y * _loc15_;
|
||||
_loc17_ = _loc24_;
|
||||
_loc12_.r2.Set(_loc17_,_loc15_);
|
||||
_loc8_ = _loc43_ * _loc43_ + _loc45_ * _loc45_;
|
||||
_loc30_ = _loc17_ * _loc17_ + _loc15_ * _loc15_;
|
||||
_loc38_ = _loc43_ * _loc5_ + _loc45_ * _loc7_;
|
||||
_loc41_ = _loc17_ * _loc5_ + _loc15_ * _loc7_;
|
||||
_loc13_ = _loc9_.m_invMass + _loc10_.m_invMass;
|
||||
_loc13_ = _loc13_ + (_loc9_.m_invI * (_loc8_ - _loc38_ * _loc38_) + _loc10_.m_invI * (_loc30_ - _loc41_ * _loc41_));
|
||||
_loc12_.normalMass = 1 / _loc13_;
|
||||
_loc36_ = _loc9_.m_mass * _loc9_.m_invMass + _loc10_.m_mass * _loc10_.m_invMass;
|
||||
_loc36_ = _loc36_ + (_loc9_.m_mass * _loc9_.m_invI * (_loc8_ - _loc38_ * _loc38_) + _loc10_.m_mass * _loc10_.m_invI * (_loc30_ - _loc41_ * _loc41_));
|
||||
_loc12_.equalizedMass = 1 / _loc36_;
|
||||
_loc26_ = _loc7_;
|
||||
_loc22_ = -_loc5_;
|
||||
_loc34_ = _loc43_ * _loc26_ + _loc45_ * _loc22_;
|
||||
_loc35_ = _loc17_ * _loc26_ + _loc15_ * _loc22_;
|
||||
_loc42_ = _loc9_.m_invMass + _loc10_.m_invMass;
|
||||
_loc42_ = _loc42_ + (_loc9_.m_invI * (_loc8_ - _loc34_ * _loc34_) + _loc10_.m_invI * (_loc30_ - _loc35_ * _loc35_));
|
||||
_loc12_.tangentMass = 1 / _loc42_;
|
||||
_loc12_.velocityBias = 0;
|
||||
if(_loc12_.separation > 0)
|
||||
{
|
||||
_loc12_.velocityBias = -60 * _loc12_.separation;
|
||||
}
|
||||
_loc24_ = _loc21_ + -_loc19_ * _loc15_ - _loc46_ - -_loc18_ * _loc45_;
|
||||
_loc25_ = _loc20_ + _loc19_ * _loc17_ - _loc47_ - _loc18_ * _loc43_;
|
||||
_loc39_ = _loc23_.normal.x * _loc24_ + _loc23_.normal.y * _loc25_;
|
||||
if(_loc39_ < -1)
|
||||
{
|
||||
_loc12_.velocityBias += -_loc23_.restitution * _loc39_;
|
||||
}
|
||||
_loc31_++;
|
||||
}
|
||||
_loc27_++;
|
||||
_loc29_++;
|
||||
}
|
||||
_loc28_++;
|
||||
}
|
||||
}
|
||||
|
||||
public function InitVelocityConstraints(param1:b2TimeStep) : void
|
||||
{
|
||||
var _loc21_:* = null;
|
||||
var _loc22_:* = null;
|
||||
var _loc23_:* = null;
|
||||
var _loc13_:int = 0;
|
||||
var _loc8_:b2ContactConstraint = null;
|
||||
var _loc18_:b2Body = null;
|
||||
var _loc19_:b2Body = null;
|
||||
var _loc9_:Number = NaN;
|
||||
var _loc5_:Number = NaN;
|
||||
var _loc6_:Number = NaN;
|
||||
var _loc3_:Number = NaN;
|
||||
var _loc4_:Number = NaN;
|
||||
var _loc7_:Number = NaN;
|
||||
var _loc11_:Number = NaN;
|
||||
var _loc2_:Number = NaN;
|
||||
var _loc10_:Number = NaN;
|
||||
var _loc15_:int = 0;
|
||||
var _loc17_:int = 0;
|
||||
var _loc20_:b2ContactConstraintPoint = null;
|
||||
var _loc12_:Number = NaN;
|
||||
var _loc14_:Number = NaN;
|
||||
var _loc16_:b2ContactConstraintPoint = null;
|
||||
_loc13_ = 0;
|
||||
while(_loc13_ < m_constraintCount)
|
||||
{
|
||||
_loc8_ = m_constraints[_loc13_];
|
||||
_loc18_ = _loc8_.body1;
|
||||
_loc19_ = _loc8_.body2;
|
||||
_loc9_ = _loc18_.m_invMass;
|
||||
_loc5_ = _loc18_.m_invI;
|
||||
_loc6_ = _loc19_.m_invMass;
|
||||
_loc3_ = _loc19_.m_invI;
|
||||
_loc4_ = _loc8_.normal.x;
|
||||
_loc11_ = _loc7_ = _loc8_.normal.y;
|
||||
_loc2_ = -_loc4_;
|
||||
if(param1.warmStarting)
|
||||
{
|
||||
_loc17_ = _loc8_.pointCount;
|
||||
_loc15_ = 0;
|
||||
while(_loc15_ < _loc17_)
|
||||
{
|
||||
_loc20_ = _loc8_.points[_loc15_];
|
||||
_loc20_.normalImpulse = _loc20_.normalImpulse * param1.dtRatio;
|
||||
_loc20_.tangentImpulse *= param1.dtRatio;
|
||||
_loc12_ = _loc20_.normalImpulse * _loc4_ + _loc20_.tangentImpulse * _loc11_;
|
||||
_loc14_ = _loc20_.normalImpulse * _loc7_ + _loc20_.tangentImpulse * _loc2_;
|
||||
_loc18_.m_angularVelocity -= _loc5_ * (_loc20_.r1.x * _loc14_ - _loc20_.r1.y * _loc12_);
|
||||
_loc18_.m_linearVelocity.x -= _loc9_ * _loc12_;
|
||||
_loc18_.m_linearVelocity.y -= _loc9_ * _loc14_;
|
||||
_loc19_.m_angularVelocity += _loc3_ * (_loc20_.r2.x * _loc14_ - _loc20_.r2.y * _loc12_);
|
||||
_loc19_.m_linearVelocity.x += _loc6_ * _loc12_;
|
||||
_loc19_.m_linearVelocity.y += _loc6_ * _loc14_;
|
||||
_loc15_++;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
_loc17_ = _loc8_.pointCount;
|
||||
_loc15_ = 0;
|
||||
while(_loc15_ < _loc17_)
|
||||
{
|
||||
_loc16_ = _loc8_.points[_loc15_];
|
||||
_loc16_.normalImpulse = 0;
|
||||
_loc16_.tangentImpulse = 0;
|
||||
_loc15_++;
|
||||
}
|
||||
}
|
||||
_loc13_++;
|
||||
}
|
||||
}
|
||||
|
||||
public function SolveVelocityConstraints() : void
|
||||
{
|
||||
var _loc24_:int = 0;
|
||||
var _loc14_:b2ContactConstraintPoint = null;
|
||||
var _loc30_:Number = NaN;
|
||||
var _loc34_:Number = NaN;
|
||||
var _loc16_:Number = NaN;
|
||||
var _loc15_:Number = NaN;
|
||||
var _loc8_:Number = NaN;
|
||||
var _loc7_:Number = NaN;
|
||||
var _loc31_:Number = NaN;
|
||||
var _loc38_:Number = NaN;
|
||||
var _loc32_:Number = NaN;
|
||||
var _loc27_:Number = NaN;
|
||||
var _loc35_:Number = NaN;
|
||||
var _loc28_:Number = NaN;
|
||||
var _loc9_:Number = NaN;
|
||||
var _loc11_:Number = NaN;
|
||||
var _loc33_:* = null;
|
||||
var _loc29_:* = null;
|
||||
var _loc23_:int = 0;
|
||||
var _loc20_:b2ContactConstraint = null;
|
||||
var _loc12_:b2Body = null;
|
||||
var _loc13_:b2Body = null;
|
||||
var _loc17_:Number = NaN;
|
||||
var _loc18_:Number = NaN;
|
||||
var _loc36_:b2Vec2 = null;
|
||||
var _loc37_:b2Vec2 = null;
|
||||
var _loc6_:Number = NaN;
|
||||
var _loc3_:Number = NaN;
|
||||
var _loc4_:Number = NaN;
|
||||
var _loc1_:Number = NaN;
|
||||
var _loc2_:Number = NaN;
|
||||
var _loc5_:Number = NaN;
|
||||
var _loc22_:Number = NaN;
|
||||
var _loc19_:Number = NaN;
|
||||
var _loc26_:Number = NaN;
|
||||
var _loc21_:Number = NaN;
|
||||
var _loc25_:int = 0;
|
||||
var _loc10_:Number = NaN;
|
||||
_loc23_ = 0;
|
||||
while(_loc23_ < m_constraintCount)
|
||||
{
|
||||
_loc20_ = m_constraints[_loc23_];
|
||||
_loc12_ = _loc20_.body1;
|
||||
_loc13_ = _loc20_.body2;
|
||||
_loc17_ = _loc12_.m_angularVelocity;
|
||||
_loc18_ = _loc13_.m_angularVelocity;
|
||||
_loc36_ = _loc12_.m_linearVelocity;
|
||||
_loc37_ = _loc13_.m_linearVelocity;
|
||||
_loc6_ = _loc12_.m_invMass;
|
||||
_loc3_ = _loc12_.m_invI;
|
||||
_loc4_ = _loc13_.m_invMass;
|
||||
_loc1_ = _loc13_.m_invI;
|
||||
_loc2_ = _loc20_.normal.x;
|
||||
_loc22_ = _loc5_ = _loc20_.normal.y;
|
||||
_loc19_ = -_loc2_;
|
||||
_loc26_ = _loc20_.friction;
|
||||
_loc25_ = _loc20_.pointCount;
|
||||
_loc24_ = 0;
|
||||
while(_loc24_ < _loc25_)
|
||||
{
|
||||
_loc14_ = _loc20_.points[_loc24_];
|
||||
_loc8_ = _loc37_.x + -_loc18_ * _loc14_.r2.y - _loc36_.x - -_loc17_ * _loc14_.r1.y;
|
||||
_loc7_ = _loc37_.y + _loc18_ * _loc14_.r2.x - _loc36_.y - _loc17_ * _loc14_.r1.x;
|
||||
_loc31_ = _loc8_ * _loc2_ + _loc7_ * _loc5_;
|
||||
_loc32_ = -_loc14_.normalMass * (_loc31_ - _loc14_.velocityBias);
|
||||
_loc38_ = _loc8_ * _loc22_ + _loc7_ * _loc19_;
|
||||
_loc27_ = _loc14_.tangentMass * -_loc38_;
|
||||
_loc35_ = b2Math.b2Max(_loc14_.normalImpulse + _loc32_,0);
|
||||
_loc32_ = _loc35_ - _loc14_.normalImpulse;
|
||||
_loc10_ = _loc26_ * _loc14_.normalImpulse;
|
||||
_loc28_ = b2Math.b2Clamp(_loc14_.tangentImpulse + _loc27_,-_loc10_,_loc10_);
|
||||
_loc27_ = _loc28_ - _loc14_.tangentImpulse;
|
||||
_loc9_ = _loc32_ * _loc2_ + _loc27_ * _loc22_;
|
||||
_loc11_ = _loc32_ * _loc5_ + _loc27_ * _loc19_;
|
||||
_loc36_.x -= _loc6_ * _loc9_;
|
||||
_loc36_.y -= _loc6_ * _loc11_;
|
||||
_loc17_ -= _loc3_ * (_loc14_.r1.x * _loc11_ - _loc14_.r1.y * _loc9_);
|
||||
_loc37_.x += _loc4_ * _loc9_;
|
||||
_loc37_.y += _loc4_ * _loc11_;
|
||||
_loc18_ += _loc1_ * (_loc14_.r2.x * _loc11_ - _loc14_.r2.y * _loc9_);
|
||||
_loc14_.normalImpulse = _loc35_;
|
||||
_loc14_.tangentImpulse = _loc28_;
|
||||
_loc24_++;
|
||||
}
|
||||
_loc12_.m_angularVelocity = _loc17_;
|
||||
_loc13_.m_angularVelocity = _loc18_;
|
||||
_loc23_++;
|
||||
}
|
||||
}
|
||||
|
||||
public function FinalizeVelocityConstraints() : void
|
||||
{
|
||||
var _loc2_:int = 0;
|
||||
var _loc1_:b2ContactConstraint = null;
|
||||
var _loc4_:b2Manifold = null;
|
||||
var _loc3_:int = 0;
|
||||
var _loc5_:b2ManifoldPoint = null;
|
||||
var _loc6_:b2ContactConstraintPoint = null;
|
||||
_loc2_ = 0;
|
||||
while(_loc2_ < m_constraintCount)
|
||||
{
|
||||
_loc1_ = m_constraints[_loc2_];
|
||||
_loc4_ = _loc1_.manifold;
|
||||
_loc3_ = 0;
|
||||
while(_loc3_ < _loc1_.pointCount)
|
||||
{
|
||||
_loc5_ = _loc4_.points[_loc3_];
|
||||
_loc6_ = _loc1_.points[_loc3_];
|
||||
_loc5_.normalImpulse = _loc6_.normalImpulse;
|
||||
_loc5_.tangentImpulse = _loc6_.tangentImpulse;
|
||||
_loc3_++;
|
||||
}
|
||||
_loc2_++;
|
||||
}
|
||||
}
|
||||
|
||||
public function SolvePositionConstraints(param1:Number) : Boolean
|
||||
{
|
||||
var _loc35_:b2Mat22 = null;
|
||||
var _loc32_:b2Vec2 = null;
|
||||
var _loc29_:int = 0;
|
||||
var _loc24_:b2ContactConstraint = null;
|
||||
var _loc12_:b2Body = null;
|
||||
var _loc13_:b2Body = null;
|
||||
var _loc23_:b2Vec2 = null;
|
||||
var _loc21_:Number = NaN;
|
||||
var _loc26_:b2Vec2 = null;
|
||||
var _loc19_:Number = NaN;
|
||||
var _loc7_:Number = NaN;
|
||||
var _loc4_:Number = NaN;
|
||||
var _loc5_:Number = NaN;
|
||||
var _loc2_:Number = NaN;
|
||||
var _loc3_:Number = NaN;
|
||||
var _loc6_:Number = NaN;
|
||||
var _loc31_:int = 0;
|
||||
var _loc30_:int = 0;
|
||||
var _loc14_:b2ContactConstraintPoint = null;
|
||||
var _loc34_:Number = NaN;
|
||||
var _loc37_:Number = NaN;
|
||||
var _loc20_:Number = NaN;
|
||||
var _loc18_:Number = NaN;
|
||||
var _loc25_:Number = NaN;
|
||||
var _loc33_:Number = NaN;
|
||||
var _loc36_:Number = NaN;
|
||||
var _loc17_:Number = NaN;
|
||||
var _loc16_:Number = NaN;
|
||||
var _loc11_:Number = NaN;
|
||||
var _loc9_:Number = NaN;
|
||||
var _loc15_:Number = NaN;
|
||||
var _loc8_:Number = NaN;
|
||||
var _loc10_:Number = NaN;
|
||||
var _loc38_:Number = NaN;
|
||||
var _loc27_:Number = NaN;
|
||||
var _loc22_:Number = NaN;
|
||||
var _loc28_:Number = 0;
|
||||
_loc29_ = 0;
|
||||
while(_loc29_ < m_constraintCount)
|
||||
{
|
||||
_loc24_ = m_constraints[_loc29_];
|
||||
_loc12_ = _loc24_.body1;
|
||||
_loc13_ = _loc24_.body2;
|
||||
_loc23_ = _loc12_.m_sweep.c;
|
||||
_loc21_ = _loc12_.m_sweep.a;
|
||||
_loc26_ = _loc13_.m_sweep.c;
|
||||
_loc19_ = _loc13_.m_sweep.a;
|
||||
_loc7_ = _loc12_.m_mass * _loc12_.m_invMass;
|
||||
_loc4_ = _loc12_.m_mass * _loc12_.m_invI;
|
||||
_loc5_ = _loc13_.m_mass * _loc13_.m_invMass;
|
||||
_loc2_ = _loc13_.m_mass * _loc13_.m_invI;
|
||||
_loc3_ = _loc24_.normal.x;
|
||||
_loc6_ = _loc24_.normal.y;
|
||||
_loc31_ = _loc24_.pointCount;
|
||||
_loc30_ = 0;
|
||||
while(_loc30_ < _loc31_)
|
||||
{
|
||||
_loc14_ = _loc24_.points[_loc30_];
|
||||
_loc35_ = _loc12_.m_xf.R;
|
||||
_loc32_ = _loc12_.m_sweep.localCenter;
|
||||
_loc34_ = _loc14_.localAnchor1.x - _loc32_.x;
|
||||
_loc37_ = _loc14_.localAnchor1.y - _loc32_.y;
|
||||
_loc25_ = _loc35_.col1.x * _loc34_ + _loc35_.col2.x * _loc37_;
|
||||
_loc37_ = _loc35_.col1.y * _loc34_ + _loc35_.col2.y * _loc37_;
|
||||
_loc34_ = _loc25_;
|
||||
_loc35_ = _loc13_.m_xf.R;
|
||||
_loc32_ = _loc13_.m_sweep.localCenter;
|
||||
_loc20_ = _loc14_.localAnchor2.x - _loc32_.x;
|
||||
_loc18_ = _loc14_.localAnchor2.y - _loc32_.y;
|
||||
_loc25_ = _loc35_.col1.x * _loc20_ + _loc35_.col2.x * _loc18_;
|
||||
_loc18_ = _loc35_.col1.y * _loc20_ + _loc35_.col2.y * _loc18_;
|
||||
_loc20_ = _loc25_;
|
||||
_loc33_ = _loc23_.x + _loc34_;
|
||||
_loc36_ = _loc23_.y + _loc37_;
|
||||
_loc17_ = _loc26_.x + _loc20_;
|
||||
_loc16_ = _loc26_.y + _loc18_;
|
||||
_loc11_ = _loc17_ - _loc33_;
|
||||
_loc9_ = _loc16_ - _loc36_;
|
||||
_loc15_ = _loc11_ * _loc3_ + _loc9_ * _loc6_ + _loc14_.separation;
|
||||
_loc28_ = b2Math.b2Min(_loc28_,_loc15_);
|
||||
_loc8_ = param1 * b2Math.b2Clamp(_loc15_ + 0.005,-0.2,0);
|
||||
_loc10_ = -_loc14_.equalizedMass * _loc8_;
|
||||
_loc38_ = _loc14_.positionImpulse;
|
||||
_loc14_.positionImpulse = b2Math.b2Max(_loc38_ + _loc10_,0);
|
||||
_loc10_ = _loc14_.positionImpulse - _loc38_;
|
||||
_loc27_ = _loc10_ * _loc3_;
|
||||
_loc22_ = _loc10_ * _loc6_;
|
||||
_loc23_.x -= _loc7_ * _loc27_;
|
||||
_loc23_.y -= _loc7_ * _loc22_;
|
||||
_loc21_ -= _loc4_ * (_loc34_ * _loc22_ - _loc37_ * _loc27_);
|
||||
_loc12_.m_sweep.a = _loc21_;
|
||||
_loc12_.SynchronizeTransform();
|
||||
_loc26_.x += _loc5_ * _loc27_;
|
||||
_loc26_.y += _loc5_ * _loc22_;
|
||||
_loc19_ += _loc2_ * (_loc20_ * _loc22_ - _loc18_ * _loc27_);
|
||||
_loc13_.m_sweep.a = _loc19_;
|
||||
_loc13_.SynchronizeTransform();
|
||||
_loc30_++;
|
||||
}
|
||||
_loc29_++;
|
||||
}
|
||||
return _loc28_ >= -1.5 * 0.005;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,23 @@
|
||||
package Box2D.Dynamics.Contacts
|
||||
{
|
||||
import Box2D.Dynamics.b2ContactListener;
|
||||
|
||||
public class b2NullContact extends b2Contact
|
||||
{
|
||||
|
||||
public function b2NullContact()
|
||||
{
|
||||
super();
|
||||
}
|
||||
|
||||
override public function Evaluate(param1:b2ContactListener) : void
|
||||
{
|
||||
}
|
||||
|
||||
override public function GetManifolds() : Array
|
||||
{
|
||||
return null;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,147 @@
|
||||
package Box2D.Dynamics.Contacts
|
||||
{
|
||||
import Box2D.Collision.*;
|
||||
import Box2D.Collision.Shapes.*;
|
||||
import Box2D.Common.*;
|
||||
import Box2D.Common.Math.*;
|
||||
import Box2D.Dynamics.*;
|
||||
|
||||
public class b2PolyAndCircleContact extends b2Contact
|
||||
{
|
||||
|
||||
private static const s_evalCP:b2ContactPoint = new b2ContactPoint();
|
||||
|
||||
private var m_manifolds:Array = [new b2Manifold()];
|
||||
|
||||
public var m_manifold:b2Manifold;
|
||||
|
||||
private var m0:b2Manifold = new b2Manifold();
|
||||
|
||||
public function b2PolyAndCircleContact(param1:b2Shape, param2:b2Shape)
|
||||
{
|
||||
super(param1,param2);
|
||||
m_manifold = m_manifolds[0];
|
||||
b2Settings.b2Assert(m_shape1.m_type == 1);
|
||||
b2Settings.b2Assert(m_shape2.m_type == 0);
|
||||
m_manifold.pointCount = 0;
|
||||
var _loc3_:b2ManifoldPoint = m_manifold.points[0];
|
||||
_loc3_.normalImpulse = 0;
|
||||
_loc3_.tangentImpulse = 0;
|
||||
}
|
||||
|
||||
public static function Create(param1:b2Shape, param2:b2Shape, param3:*) : b2Contact
|
||||
{
|
||||
return new b2PolyAndCircleContact(param1,param2);
|
||||
}
|
||||
|
||||
public static function Destroy(param1:b2Contact, param2:*) : void
|
||||
{
|
||||
}
|
||||
|
||||
override public function Evaluate(param1:b2ContactListener) : void
|
||||
{
|
||||
var _loc3_:int = 0;
|
||||
var _loc11_:b2Vec2 = null;
|
||||
var _loc13_:b2Vec2 = null;
|
||||
var _loc5_:b2ManifoldPoint = null;
|
||||
var _loc2_:b2ManifoldPoint = null;
|
||||
var _loc10_:Boolean = false;
|
||||
var _loc9_:* = 0;
|
||||
var _loc4_:int = 0;
|
||||
var _loc7_:b2Body = m_shape1.m_body;
|
||||
var _loc8_:b2Body = m_shape2.m_body;
|
||||
m0.Set(m_manifold);
|
||||
b2Collision.b2CollidePolygonAndCircle(m_manifold,m_shape1 as b2PolygonShape,_loc7_.m_xf,m_shape2 as b2CircleShape,_loc8_.m_xf);
|
||||
var _loc12_:Array = [false,false];
|
||||
var _loc6_:b2ContactPoint = s_evalCP;
|
||||
_loc6_.shape1 = m_shape1;
|
||||
_loc6_.shape2 = m_shape2;
|
||||
_loc6_.friction = m_friction;
|
||||
_loc6_.restitution = m_restitution;
|
||||
if(m_manifold.pointCount > 0)
|
||||
{
|
||||
_loc3_ = 0;
|
||||
while(_loc3_ < m_manifold.pointCount)
|
||||
{
|
||||
_loc2_ = m_manifold.points[_loc3_];
|
||||
_loc2_.normalImpulse = 0;
|
||||
_loc2_.tangentImpulse = 0;
|
||||
_loc10_ = false;
|
||||
_loc9_ = _loc2_.id._key;
|
||||
_loc4_ = 0;
|
||||
while(_loc4_ < m0.pointCount)
|
||||
{
|
||||
if(_loc12_[_loc4_] != true)
|
||||
{
|
||||
_loc5_ = m0.points[_loc4_];
|
||||
if(_loc5_.id._key == _loc9_)
|
||||
{
|
||||
_loc12_[_loc4_] = true;
|
||||
_loc2_.normalImpulse = _loc5_.normalImpulse;
|
||||
_loc2_.tangentImpulse = _loc5_.tangentImpulse;
|
||||
_loc10_ = true;
|
||||
if(param1 != null)
|
||||
{
|
||||
_loc6_.position = _loc7_.GetWorldPoint(_loc2_.localPoint1);
|
||||
_loc11_ = _loc7_.GetLinearVelocityFromLocalPoint(_loc2_.localPoint1);
|
||||
_loc13_ = _loc8_.GetLinearVelocityFromLocalPoint(_loc2_.localPoint2);
|
||||
_loc6_.velocity.Set(_loc13_.x - _loc11_.x,_loc13_.y - _loc11_.y);
|
||||
_loc6_.normal.SetV(m_manifold.normal);
|
||||
_loc6_.separation = _loc2_.separation;
|
||||
_loc6_.id.key = _loc9_;
|
||||
param1.Persist(_loc6_);
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
_loc4_++;
|
||||
}
|
||||
if(_loc10_ == false && param1 != null)
|
||||
{
|
||||
_loc6_.position = _loc7_.GetWorldPoint(_loc2_.localPoint1);
|
||||
_loc11_ = _loc7_.GetLinearVelocityFromLocalPoint(_loc2_.localPoint1);
|
||||
_loc13_ = _loc8_.GetLinearVelocityFromLocalPoint(_loc2_.localPoint2);
|
||||
_loc6_.velocity.Set(_loc13_.x - _loc11_.x,_loc13_.y - _loc11_.y);
|
||||
_loc6_.normal.SetV(m_manifold.normal);
|
||||
_loc6_.separation = _loc2_.separation;
|
||||
_loc6_.id.key = _loc9_;
|
||||
param1.Add(_loc6_);
|
||||
}
|
||||
_loc3_++;
|
||||
}
|
||||
m_manifoldCount = 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
m_manifoldCount = 0;
|
||||
}
|
||||
if(param1 == null)
|
||||
{
|
||||
return;
|
||||
}
|
||||
_loc3_ = 0;
|
||||
while(_loc3_ < m0.pointCount)
|
||||
{
|
||||
if(!_loc12_[_loc3_])
|
||||
{
|
||||
_loc5_ = m0.points[_loc3_];
|
||||
_loc6_.position = _loc7_.GetWorldPoint(_loc5_.localPoint1);
|
||||
_loc11_ = _loc7_.GetLinearVelocityFromLocalPoint(_loc5_.localPoint1);
|
||||
_loc13_ = _loc8_.GetLinearVelocityFromLocalPoint(_loc5_.localPoint2);
|
||||
_loc6_.velocity.Set(_loc13_.x - _loc11_.x,_loc13_.y - _loc11_.y);
|
||||
_loc6_.normal.SetV(m0.normal);
|
||||
_loc6_.separation = _loc5_.separation;
|
||||
_loc6_.id.key = _loc5_.id._key;
|
||||
param1.Remove(_loc6_);
|
||||
}
|
||||
_loc3_++;
|
||||
}
|
||||
}
|
||||
|
||||
override public function GetManifolds() : Array
|
||||
{
|
||||
return m_manifolds;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,143 @@
|
||||
package Box2D.Dynamics.Contacts
|
||||
{
|
||||
import Box2D.Collision.*;
|
||||
import Box2D.Collision.Shapes.*;
|
||||
import Box2D.Common.*;
|
||||
import Box2D.Common.Math.*;
|
||||
import Box2D.Dynamics.*;
|
||||
|
||||
public class b2PolygonContact extends b2Contact
|
||||
{
|
||||
|
||||
private static const s_evalCP:b2ContactPoint = new b2ContactPoint();
|
||||
|
||||
private var m0:b2Manifold = new b2Manifold();
|
||||
|
||||
private var m_manifolds:Array = [new b2Manifold()];
|
||||
|
||||
public var m_manifold:b2Manifold;
|
||||
|
||||
public function b2PolygonContact(param1:b2Shape, param2:b2Shape)
|
||||
{
|
||||
super(param1,param2);
|
||||
m_manifold = m_manifolds[0];
|
||||
m_manifold.pointCount = 0;
|
||||
}
|
||||
|
||||
public static function Create(param1:b2Shape, param2:b2Shape, param3:*) : b2Contact
|
||||
{
|
||||
return new b2PolygonContact(param1,param2);
|
||||
}
|
||||
|
||||
public static function Destroy(param1:b2Contact, param2:*) : void
|
||||
{
|
||||
}
|
||||
|
||||
override public function Evaluate(param1:b2ContactListener) : void
|
||||
{
|
||||
var _loc11_:b2Vec2 = null;
|
||||
var _loc13_:b2Vec2 = null;
|
||||
var _loc5_:b2ManifoldPoint = null;
|
||||
var _loc6_:b2ContactPoint = null;
|
||||
var _loc3_:int = 0;
|
||||
var _loc2_:b2ManifoldPoint = null;
|
||||
var _loc10_:Boolean = false;
|
||||
var _loc9_:* = 0;
|
||||
var _loc4_:int = 0;
|
||||
var _loc7_:b2Body = m_shape1.m_body;
|
||||
var _loc8_:b2Body = m_shape2.m_body;
|
||||
m0.Set(m_manifold);
|
||||
b2Collision.b2CollidePolygons(m_manifold,m_shape1 as b2PolygonShape,_loc7_.m_xf,m_shape2 as b2PolygonShape,_loc8_.m_xf);
|
||||
var _loc12_:Array = [false,false];
|
||||
_loc6_ = s_evalCP;
|
||||
_loc6_.shape1 = m_shape1;
|
||||
_loc6_.shape2 = m_shape2;
|
||||
_loc6_.friction = m_friction;
|
||||
_loc6_.restitution = m_restitution;
|
||||
if(m_manifold.pointCount > 0)
|
||||
{
|
||||
_loc3_ = 0;
|
||||
while(_loc3_ < m_manifold.pointCount)
|
||||
{
|
||||
_loc2_ = m_manifold.points[_loc3_];
|
||||
_loc2_.normalImpulse = 0;
|
||||
_loc2_.tangentImpulse = 0;
|
||||
_loc10_ = false;
|
||||
_loc9_ = _loc2_.id._key;
|
||||
_loc4_ = 0;
|
||||
while(_loc4_ < m0.pointCount)
|
||||
{
|
||||
if(_loc12_[_loc4_] != true)
|
||||
{
|
||||
_loc5_ = m0.points[_loc4_];
|
||||
if(_loc5_.id._key == _loc9_)
|
||||
{
|
||||
_loc12_[_loc4_] = true;
|
||||
_loc2_.normalImpulse = _loc5_.normalImpulse;
|
||||
_loc2_.tangentImpulse = _loc5_.tangentImpulse;
|
||||
_loc10_ = true;
|
||||
if(param1 != null)
|
||||
{
|
||||
_loc6_.position = _loc7_.GetWorldPoint(_loc2_.localPoint1);
|
||||
_loc11_ = _loc7_.GetLinearVelocityFromLocalPoint(_loc2_.localPoint1);
|
||||
_loc13_ = _loc8_.GetLinearVelocityFromLocalPoint(_loc2_.localPoint2);
|
||||
_loc6_.velocity.Set(_loc13_.x - _loc11_.x,_loc13_.y - _loc11_.y);
|
||||
_loc6_.normal.SetV(m_manifold.normal);
|
||||
_loc6_.separation = _loc2_.separation;
|
||||
_loc6_.id.key = _loc9_;
|
||||
param1.Persist(_loc6_);
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
_loc4_++;
|
||||
}
|
||||
if(_loc10_ == false && param1 != null)
|
||||
{
|
||||
_loc6_.position = _loc7_.GetWorldPoint(_loc2_.localPoint1);
|
||||
_loc11_ = _loc7_.GetLinearVelocityFromLocalPoint(_loc2_.localPoint1);
|
||||
_loc13_ = _loc8_.GetLinearVelocityFromLocalPoint(_loc2_.localPoint2);
|
||||
_loc6_.velocity.Set(_loc13_.x - _loc11_.x,_loc13_.y - _loc11_.y);
|
||||
_loc6_.normal.SetV(m_manifold.normal);
|
||||
_loc6_.separation = _loc2_.separation;
|
||||
_loc6_.id.key = _loc9_;
|
||||
param1.Add(_loc6_);
|
||||
}
|
||||
_loc3_++;
|
||||
}
|
||||
m_manifoldCount = 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
m_manifoldCount = 0;
|
||||
}
|
||||
if(param1 == null)
|
||||
{
|
||||
return;
|
||||
}
|
||||
_loc3_ = 0;
|
||||
while(_loc3_ < m0.pointCount)
|
||||
{
|
||||
if(!_loc12_[_loc3_])
|
||||
{
|
||||
_loc5_ = m0.points[_loc3_];
|
||||
_loc6_.position = _loc7_.GetWorldPoint(_loc5_.localPoint1);
|
||||
_loc11_ = _loc7_.GetLinearVelocityFromLocalPoint(_loc5_.localPoint1);
|
||||
_loc13_ = _loc8_.GetLinearVelocityFromLocalPoint(_loc5_.localPoint2);
|
||||
_loc6_.velocity.Set(_loc13_.x - _loc11_.x,_loc13_.y - _loc11_.y);
|
||||
_loc6_.normal.SetV(m0.normal);
|
||||
_loc6_.separation = _loc5_.separation;
|
||||
_loc6_.id.key = _loc5_.id._key;
|
||||
param1.Remove(_loc6_);
|
||||
}
|
||||
_loc3_++;
|
||||
}
|
||||
}
|
||||
|
||||
override public function GetManifolds() : Array
|
||||
{
|
||||
return m_manifolds;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,218 @@
|
||||
package Box2D.Dynamics.Joints
|
||||
{
|
||||
import Box2D.Common.Math.b2Mat22;
|
||||
import Box2D.Common.Math.b2Math;
|
||||
import Box2D.Common.Math.b2Vec2;
|
||||
import Box2D.Dynamics.b2Body;
|
||||
import Box2D.Dynamics.b2TimeStep;
|
||||
|
||||
public class b2DistanceJoint extends b2Joint
|
||||
{
|
||||
|
||||
public var m_localAnchor1:b2Vec2 = new b2Vec2();
|
||||
|
||||
public var m_localAnchor2:b2Vec2 = new b2Vec2();
|
||||
|
||||
public var m_u:b2Vec2 = new b2Vec2();
|
||||
|
||||
public var m_frequencyHz:Number;
|
||||
|
||||
public var m_dampingRatio:Number;
|
||||
|
||||
public var m_gamma:Number;
|
||||
|
||||
public var m_bias:Number;
|
||||
|
||||
public var m_impulse:Number;
|
||||
|
||||
public var m_mass:Number;
|
||||
|
||||
public var m_length:Number;
|
||||
|
||||
public function b2DistanceJoint(param1:b2DistanceJointDef)
|
||||
{
|
||||
var _loc4_:* = null;
|
||||
var _loc2_:Number = NaN;
|
||||
var _loc3_:Number = NaN;
|
||||
super(param1);
|
||||
m_localAnchor1.SetV(param1.localAnchor1);
|
||||
m_localAnchor2.SetV(param1.localAnchor2);
|
||||
m_length = param1.length;
|
||||
m_frequencyHz = param1.frequencyHz;
|
||||
m_dampingRatio = param1.dampingRatio;
|
||||
m_impulse = 0;
|
||||
m_gamma = 0;
|
||||
m_bias = 0;
|
||||
m_inv_dt = 0;
|
||||
}
|
||||
|
||||
override public function InitVelocityConstraints(param1:b2TimeStep) : void
|
||||
{
|
||||
var _loc15_:b2Mat22 = null;
|
||||
var _loc4_:Number = NaN;
|
||||
var _loc3_:Number = NaN;
|
||||
var _loc10_:Number = NaN;
|
||||
var _loc5_:Number = NaN;
|
||||
var _loc9_:Number = NaN;
|
||||
var _loc7_:Number = NaN;
|
||||
var _loc8_:Number = NaN;
|
||||
m_inv_dt = param1.inv_dt;
|
||||
var _loc11_:b2Body = m_body1;
|
||||
var _loc12_:b2Body = m_body2;
|
||||
_loc15_ = _loc11_.m_xf.R;
|
||||
var _loc13_:Number = m_localAnchor1.x - _loc11_.m_sweep.localCenter.x;
|
||||
var _loc17_:Number = m_localAnchor1.y - _loc11_.m_sweep.localCenter.y;
|
||||
_loc4_ = _loc15_.col1.x * _loc13_ + _loc15_.col2.x * _loc17_;
|
||||
_loc17_ = _loc15_.col1.y * _loc13_ + _loc15_.col2.y * _loc17_;
|
||||
_loc13_ = _loc4_;
|
||||
_loc15_ = _loc12_.m_xf.R;
|
||||
var _loc16_:Number = m_localAnchor2.x - _loc12_.m_sweep.localCenter.x;
|
||||
var _loc14_:Number = m_localAnchor2.y - _loc12_.m_sweep.localCenter.y;
|
||||
_loc4_ = _loc15_.col1.x * _loc16_ + _loc15_.col2.x * _loc14_;
|
||||
_loc14_ = _loc15_.col1.y * _loc16_ + _loc15_.col2.y * _loc14_;
|
||||
_loc16_ = _loc4_;
|
||||
m_u.x = _loc12_.m_sweep.c.x + _loc16_ - _loc11_.m_sweep.c.x - _loc13_;
|
||||
m_u.y = _loc12_.m_sweep.c.y + _loc14_ - _loc11_.m_sweep.c.y - _loc17_;
|
||||
var _loc6_:Number = Math.sqrt(m_u.x * m_u.x + m_u.y * m_u.y);
|
||||
if(_loc6_ > 0.005)
|
||||
{
|
||||
m_u.Multiply(1 / _loc6_);
|
||||
}
|
||||
else
|
||||
{
|
||||
m_u.SetZero();
|
||||
}
|
||||
var _loc19_:Number = _loc13_ * m_u.y - _loc17_ * m_u.x;
|
||||
var _loc18_:Number = _loc16_ * m_u.y - _loc14_ * m_u.x;
|
||||
var _loc2_:Number = _loc11_.m_invMass + _loc11_.m_invI * _loc19_ * _loc19_ + _loc12_.m_invMass + _loc12_.m_invI * _loc18_ * _loc18_;
|
||||
m_mass = 1 / _loc2_;
|
||||
if(m_frequencyHz > 0)
|
||||
{
|
||||
_loc3_ = _loc6_ - m_length;
|
||||
_loc10_ = 2 * 3.141592653589793 * m_frequencyHz;
|
||||
_loc5_ = 2 * m_mass * m_dampingRatio * _loc10_;
|
||||
_loc9_ = m_mass * _loc10_ * _loc10_;
|
||||
m_gamma = 1 / (param1.dt * (_loc5_ + param1.dt * _loc9_));
|
||||
m_bias = _loc3_ * param1.dt * _loc9_ * m_gamma;
|
||||
m_mass = 1 / (_loc2_ + m_gamma);
|
||||
}
|
||||
if(param1.warmStarting)
|
||||
{
|
||||
m_impulse *= param1.dtRatio;
|
||||
_loc7_ = m_impulse * m_u.x;
|
||||
_loc8_ = m_impulse * m_u.y;
|
||||
_loc11_.m_linearVelocity.x -= _loc11_.m_invMass * _loc7_;
|
||||
_loc11_.m_linearVelocity.y -= _loc11_.m_invMass * _loc8_;
|
||||
_loc11_.m_angularVelocity -= _loc11_.m_invI * (_loc13_ * _loc8_ - _loc17_ * _loc7_);
|
||||
_loc12_.m_linearVelocity.x += _loc12_.m_invMass * _loc7_;
|
||||
_loc12_.m_linearVelocity.y += _loc12_.m_invMass * _loc8_;
|
||||
_loc12_.m_angularVelocity += _loc12_.m_invI * (_loc16_ * _loc8_ - _loc14_ * _loc7_);
|
||||
}
|
||||
else
|
||||
{
|
||||
m_impulse = 0;
|
||||
}
|
||||
}
|
||||
|
||||
override public function SolveVelocityConstraints(param1:b2TimeStep) : void
|
||||
{
|
||||
var _loc9_:b2Mat22 = null;
|
||||
var _loc5_:b2Body = m_body1;
|
||||
var _loc6_:b2Body = m_body2;
|
||||
_loc9_ = _loc5_.m_xf.R;
|
||||
var _loc7_:Number = m_localAnchor1.x - _loc5_.m_sweep.localCenter.x;
|
||||
var _loc13_:Number = m_localAnchor1.y - _loc5_.m_sweep.localCenter.y;
|
||||
var _loc2_:Number = _loc9_.col1.x * _loc7_ + _loc9_.col2.x * _loc13_;
|
||||
_loc13_ = _loc9_.col1.y * _loc7_ + _loc9_.col2.y * _loc13_;
|
||||
_loc7_ = _loc2_;
|
||||
_loc9_ = _loc6_.m_xf.R;
|
||||
var _loc10_:Number = m_localAnchor2.x - _loc6_.m_sweep.localCenter.x;
|
||||
var _loc8_:Number = m_localAnchor2.y - _loc6_.m_sweep.localCenter.y;
|
||||
_loc2_ = _loc9_.col1.x * _loc10_ + _loc9_.col2.x * _loc8_;
|
||||
_loc8_ = _loc9_.col1.y * _loc10_ + _loc9_.col2.y * _loc8_;
|
||||
_loc10_ = _loc2_;
|
||||
var _loc14_:Number = _loc5_.m_linearVelocity.x + -_loc5_.m_angularVelocity * _loc13_;
|
||||
var _loc17_:Number = _loc5_.m_linearVelocity.y + _loc5_.m_angularVelocity * _loc7_;
|
||||
var _loc16_:Number = _loc6_.m_linearVelocity.x + -_loc6_.m_angularVelocity * _loc8_;
|
||||
var _loc15_:Number = _loc6_.m_linearVelocity.y + _loc6_.m_angularVelocity * _loc10_;
|
||||
var _loc11_:Number = m_u.x * (_loc16_ - _loc14_) + m_u.y * (_loc15_ - _loc17_);
|
||||
var _loc12_:Number = -m_mass * (_loc11_ + m_bias + m_gamma * m_impulse);
|
||||
m_impulse += _loc12_;
|
||||
var _loc3_:Number = _loc12_ * m_u.x;
|
||||
var _loc4_:Number = _loc12_ * m_u.y;
|
||||
_loc5_.m_linearVelocity.x -= _loc5_.m_invMass * _loc3_;
|
||||
_loc5_.m_linearVelocity.y -= _loc5_.m_invMass * _loc4_;
|
||||
_loc5_.m_angularVelocity -= _loc5_.m_invI * (_loc7_ * _loc4_ - _loc13_ * _loc3_);
|
||||
_loc6_.m_linearVelocity.x += _loc6_.m_invMass * _loc3_;
|
||||
_loc6_.m_linearVelocity.y += _loc6_.m_invMass * _loc4_;
|
||||
_loc6_.m_angularVelocity += _loc6_.m_invI * (_loc10_ * _loc4_ - _loc8_ * _loc3_);
|
||||
}
|
||||
|
||||
override public function SolvePositionConstraints() : Boolean
|
||||
{
|
||||
var _loc12_:b2Mat22 = null;
|
||||
if(m_frequencyHz > 0)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
var _loc6_:b2Body = m_body1;
|
||||
var _loc7_:b2Body = m_body2;
|
||||
_loc12_ = _loc6_.m_xf.R;
|
||||
var _loc10_:Number = m_localAnchor1.x - _loc6_.m_sweep.localCenter.x;
|
||||
var _loc15_:Number = m_localAnchor1.y - _loc6_.m_sweep.localCenter.y;
|
||||
var _loc2_:Number = _loc12_.col1.x * _loc10_ + _loc12_.col2.x * _loc15_;
|
||||
_loc15_ = _loc12_.col1.y * _loc10_ + _loc12_.col2.y * _loc15_;
|
||||
_loc10_ = _loc2_;
|
||||
_loc12_ = _loc7_.m_xf.R;
|
||||
var _loc13_:Number = m_localAnchor2.x - _loc7_.m_sweep.localCenter.x;
|
||||
var _loc11_:Number = m_localAnchor2.y - _loc7_.m_sweep.localCenter.y;
|
||||
_loc2_ = _loc12_.col1.x * _loc13_ + _loc12_.col2.x * _loc11_;
|
||||
_loc11_ = _loc12_.col1.y * _loc13_ + _loc12_.col2.y * _loc11_;
|
||||
_loc13_ = _loc2_;
|
||||
var _loc8_:Number = _loc7_.m_sweep.c.x + _loc13_ - _loc6_.m_sweep.c.x - _loc10_;
|
||||
var _loc9_:Number = _loc7_.m_sweep.c.y + _loc11_ - _loc6_.m_sweep.c.y - _loc15_;
|
||||
var _loc3_:Number = Math.sqrt(_loc8_ * _loc8_ + _loc9_ * _loc9_);
|
||||
_loc8_ /= _loc3_;
|
||||
_loc9_ /= _loc3_;
|
||||
var _loc1_:Number = _loc3_ - m_length;
|
||||
_loc1_ = b2Math.b2Clamp(_loc1_,-0.2,0.2);
|
||||
var _loc14_:Number = -m_mass * _loc1_;
|
||||
m_u.Set(_loc8_,_loc9_);
|
||||
var _loc4_:Number = _loc14_ * m_u.x;
|
||||
var _loc5_:Number = _loc14_ * m_u.y;
|
||||
_loc6_.m_sweep.c.x -= _loc6_.m_invMass * _loc4_;
|
||||
_loc6_.m_sweep.c.y -= _loc6_.m_invMass * _loc5_;
|
||||
_loc6_.m_sweep.a -= _loc6_.m_invI * (_loc10_ * _loc5_ - _loc15_ * _loc4_);
|
||||
_loc7_.m_sweep.c.x += _loc7_.m_invMass * _loc4_;
|
||||
_loc7_.m_sweep.c.y += _loc7_.m_invMass * _loc5_;
|
||||
_loc7_.m_sweep.a += _loc7_.m_invI * (_loc13_ * _loc5_ - _loc11_ * _loc4_);
|
||||
_loc6_.SynchronizeTransform();
|
||||
_loc7_.SynchronizeTransform();
|
||||
return b2Math.b2Abs(_loc1_) < 0.005;
|
||||
}
|
||||
|
||||
override public function GetAnchor1() : b2Vec2
|
||||
{
|
||||
return m_body1.GetWorldPoint(m_localAnchor1);
|
||||
}
|
||||
|
||||
override public function GetAnchor2() : b2Vec2
|
||||
{
|
||||
return m_body2.GetWorldPoint(m_localAnchor2);
|
||||
}
|
||||
|
||||
override public function GetReactionForce() : b2Vec2
|
||||
{
|
||||
var _loc1_:b2Vec2 = new b2Vec2();
|
||||
_loc1_.SetV(m_u);
|
||||
_loc1_.Multiply(m_inv_dt * m_impulse);
|
||||
return _loc1_;
|
||||
}
|
||||
|
||||
override public function GetReactionTorque() : Number
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,42 @@
|
||||
package Box2D.Dynamics.Joints
|
||||
{
|
||||
import Box2D.Common.Math.b2Vec2;
|
||||
import Box2D.Dynamics.b2Body;
|
||||
|
||||
public class b2DistanceJointDef extends b2JointDef
|
||||
{
|
||||
|
||||
public var localAnchor1:b2Vec2 = new b2Vec2();
|
||||
|
||||
public var localAnchor2:b2Vec2 = new b2Vec2();
|
||||
|
||||
public var length:Number;
|
||||
|
||||
public var frequencyHz:Number;
|
||||
|
||||
public var dampingRatio:Number;
|
||||
|
||||
public function b2DistanceJointDef()
|
||||
{
|
||||
super();
|
||||
type = 3;
|
||||
length = 1;
|
||||
frequencyHz = 0;
|
||||
dampingRatio = 0;
|
||||
}
|
||||
|
||||
public function Initialize(param1:b2Body, param2:b2Body, param3:b2Vec2, param4:b2Vec2) : void
|
||||
{
|
||||
body1 = param1;
|
||||
body2 = param2;
|
||||
localAnchor1.SetV(body1.GetLocalPoint(param3));
|
||||
localAnchor2.SetV(body2.GetLocalPoint(param4));
|
||||
var _loc5_:Number = param4.x - param3.x;
|
||||
var _loc6_:Number = param4.y - param3.y;
|
||||
length = Math.sqrt(_loc5_ * _loc5_ + _loc6_ * _loc6_);
|
||||
frequencyHz = 0;
|
||||
dampingRatio = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,251 @@
|
||||
package Box2D.Dynamics.Joints
|
||||
{
|
||||
import Box2D.Common.Math.b2Mat22;
|
||||
import Box2D.Common.Math.b2Vec2;
|
||||
import Box2D.Dynamics.b2Body;
|
||||
import Box2D.Dynamics.b2TimeStep;
|
||||
|
||||
public class b2GearJoint extends b2Joint
|
||||
{
|
||||
|
||||
public var m_ground1:b2Body;
|
||||
|
||||
public var m_ground2:b2Body;
|
||||
|
||||
public var m_revolute1:b2RevoluteJoint;
|
||||
|
||||
public var m_prismatic1:b2PrismaticJoint;
|
||||
|
||||
public var m_revolute2:b2RevoluteJoint;
|
||||
|
||||
public var m_prismatic2:b2PrismaticJoint;
|
||||
|
||||
public var m_groundAnchor1:b2Vec2 = new b2Vec2();
|
||||
|
||||
public var m_groundAnchor2:b2Vec2 = new b2Vec2();
|
||||
|
||||
public var m_localAnchor1:b2Vec2 = new b2Vec2();
|
||||
|
||||
public var m_localAnchor2:b2Vec2 = new b2Vec2();
|
||||
|
||||
public var m_J:b2Jacobian = new b2Jacobian();
|
||||
|
||||
public var m_constant:Number;
|
||||
|
||||
public var m_ratio:Number;
|
||||
|
||||
public var m_mass:Number;
|
||||
|
||||
public var m_force:Number;
|
||||
|
||||
public function b2GearJoint(param1:b2GearJointDef)
|
||||
{
|
||||
var _loc4_:Number = NaN;
|
||||
var _loc3_:Number = NaN;
|
||||
super(param1);
|
||||
var _loc5_:int = param1.joint1.m_type;
|
||||
var _loc2_:int = param1.joint2.m_type;
|
||||
m_revolute1 = null;
|
||||
m_prismatic1 = null;
|
||||
m_revolute2 = null;
|
||||
m_prismatic2 = null;
|
||||
m_ground1 = param1.joint1.m_body1;
|
||||
m_body1 = param1.joint1.m_body2;
|
||||
if(_loc5_ == 1)
|
||||
{
|
||||
m_revolute1 = param1.joint1 as b2RevoluteJoint;
|
||||
m_groundAnchor1.SetV(m_revolute1.m_localAnchor1);
|
||||
m_localAnchor1.SetV(m_revolute1.m_localAnchor2);
|
||||
_loc4_ = m_revolute1.GetJointAngle();
|
||||
}
|
||||
else
|
||||
{
|
||||
m_prismatic1 = param1.joint1 as b2PrismaticJoint;
|
||||
m_groundAnchor1.SetV(m_prismatic1.m_localAnchor1);
|
||||
m_localAnchor1.SetV(m_prismatic1.m_localAnchor2);
|
||||
_loc4_ = m_prismatic1.GetJointTranslation();
|
||||
}
|
||||
m_ground2 = param1.joint2.m_body1;
|
||||
m_body2 = param1.joint2.m_body2;
|
||||
if(_loc2_ == 1)
|
||||
{
|
||||
m_revolute2 = param1.joint2 as b2RevoluteJoint;
|
||||
m_groundAnchor2.SetV(m_revolute2.m_localAnchor1);
|
||||
m_localAnchor2.SetV(m_revolute2.m_localAnchor2);
|
||||
_loc3_ = m_revolute2.GetJointAngle();
|
||||
}
|
||||
else
|
||||
{
|
||||
m_prismatic2 = param1.joint2 as b2PrismaticJoint;
|
||||
m_groundAnchor2.SetV(m_prismatic2.m_localAnchor1);
|
||||
m_localAnchor2.SetV(m_prismatic2.m_localAnchor2);
|
||||
_loc3_ = m_prismatic2.GetJointTranslation();
|
||||
}
|
||||
m_ratio = param1.ratio;
|
||||
m_constant = _loc4_ + m_ratio * _loc3_;
|
||||
m_force = 0;
|
||||
}
|
||||
|
||||
override public function GetAnchor1() : b2Vec2
|
||||
{
|
||||
return m_body1.GetWorldPoint(m_localAnchor1);
|
||||
}
|
||||
|
||||
override public function GetAnchor2() : b2Vec2
|
||||
{
|
||||
return m_body2.GetWorldPoint(m_localAnchor2);
|
||||
}
|
||||
|
||||
override public function GetReactionForce() : b2Vec2
|
||||
{
|
||||
return new b2Vec2(m_force * m_J.linear2.x,m_force * m_J.linear2.y);
|
||||
}
|
||||
|
||||
override public function GetReactionTorque() : Number
|
||||
{
|
||||
var _loc4_:b2Mat22 = m_body2.m_xf.R;
|
||||
var _loc2_:Number = m_localAnchor1.x - m_body2.m_sweep.localCenter.x;
|
||||
var _loc3_:Number = m_localAnchor1.y - m_body2.m_sweep.localCenter.y;
|
||||
var _loc1_:Number = _loc4_.col1.x * _loc2_ + _loc4_.col2.x * _loc3_;
|
||||
_loc3_ = _loc4_.col1.y * _loc2_ + _loc4_.col2.y * _loc3_;
|
||||
_loc2_ = _loc1_;
|
||||
return m_force * m_J.angular2 - (_loc2_ * (m_force * m_J.linear2.y) - _loc3_ * (m_force * m_J.linear2.x));
|
||||
}
|
||||
|
||||
public function GetRatio() : Number
|
||||
{
|
||||
return m_ratio;
|
||||
}
|
||||
|
||||
override public function InitVelocityConstraints(param1:b2TimeStep) : void
|
||||
{
|
||||
var _loc5_:Number = NaN;
|
||||
var _loc3_:Number = NaN;
|
||||
var _loc4_:Number = NaN;
|
||||
var _loc6_:Number = NaN;
|
||||
var _loc15_:b2Mat22 = null;
|
||||
var _loc14_:b2Vec2 = null;
|
||||
var _loc11_:Number = NaN;
|
||||
var _loc2_:Number = NaN;
|
||||
var _loc13_:Number = NaN;
|
||||
var _loc7_:b2Body = m_ground1;
|
||||
var _loc8_:b2Body = m_ground2;
|
||||
var _loc10_:b2Body = m_body1;
|
||||
var _loc12_:b2Body = m_body2;
|
||||
var _loc9_:Number = 0;
|
||||
m_J.SetZero();
|
||||
if(m_revolute1)
|
||||
{
|
||||
m_J.angular1 = -1;
|
||||
_loc9_ += _loc10_.m_invI;
|
||||
}
|
||||
else
|
||||
{
|
||||
_loc15_ = _loc7_.m_xf.R;
|
||||
_loc14_ = m_prismatic1.m_localXAxis1;
|
||||
_loc5_ = _loc15_.col1.x * _loc14_.x + _loc15_.col2.x * _loc14_.y;
|
||||
_loc3_ = _loc15_.col1.y * _loc14_.x + _loc15_.col2.y * _loc14_.y;
|
||||
_loc15_ = _loc10_.m_xf.R;
|
||||
_loc4_ = m_localAnchor1.x - _loc10_.m_sweep.localCenter.x;
|
||||
_loc6_ = m_localAnchor1.y - _loc10_.m_sweep.localCenter.y;
|
||||
_loc2_ = _loc15_.col1.x * _loc4_ + _loc15_.col2.x * _loc6_;
|
||||
_loc6_ = _loc15_.col1.y * _loc4_ + _loc15_.col2.y * _loc6_;
|
||||
_loc4_ = _loc2_;
|
||||
_loc11_ = _loc4_ * _loc3_ - _loc6_ * _loc5_;
|
||||
m_J.linear1.Set(-_loc5_,-_loc3_);
|
||||
m_J.angular1 = -_loc11_;
|
||||
_loc9_ += _loc10_.m_invMass + _loc10_.m_invI * _loc11_ * _loc11_;
|
||||
}
|
||||
if(m_revolute2)
|
||||
{
|
||||
m_J.angular2 = -m_ratio;
|
||||
_loc9_ += m_ratio * m_ratio * _loc12_.m_invI;
|
||||
}
|
||||
else
|
||||
{
|
||||
_loc15_ = _loc8_.m_xf.R;
|
||||
_loc14_ = m_prismatic2.m_localXAxis1;
|
||||
_loc5_ = _loc15_.col1.x * _loc14_.x + _loc15_.col2.x * _loc14_.y;
|
||||
_loc3_ = _loc15_.col1.y * _loc14_.x + _loc15_.col2.y * _loc14_.y;
|
||||
_loc15_ = _loc12_.m_xf.R;
|
||||
_loc4_ = m_localAnchor2.x - _loc12_.m_sweep.localCenter.x;
|
||||
_loc6_ = m_localAnchor2.y - _loc12_.m_sweep.localCenter.y;
|
||||
_loc2_ = _loc15_.col1.x * _loc4_ + _loc15_.col2.x * _loc6_;
|
||||
_loc6_ = _loc15_.col1.y * _loc4_ + _loc15_.col2.y * _loc6_;
|
||||
_loc4_ = _loc2_;
|
||||
_loc11_ = _loc4_ * _loc3_ - _loc6_ * _loc5_;
|
||||
m_J.linear2.Set(-m_ratio * _loc5_,-m_ratio * _loc3_);
|
||||
m_J.angular2 = -m_ratio * _loc11_;
|
||||
_loc9_ += m_ratio * m_ratio * (_loc12_.m_invMass + _loc12_.m_invI * _loc11_ * _loc11_);
|
||||
}
|
||||
m_mass = 1 / _loc9_;
|
||||
if(param1.warmStarting)
|
||||
{
|
||||
_loc13_ = param1.dt * m_force;
|
||||
_loc10_.m_linearVelocity.x += _loc10_.m_invMass * _loc13_ * m_J.linear1.x;
|
||||
_loc10_.m_linearVelocity.y += _loc10_.m_invMass * _loc13_ * m_J.linear1.y;
|
||||
_loc10_.m_angularVelocity += _loc10_.m_invI * _loc13_ * m_J.angular1;
|
||||
_loc12_.m_linearVelocity.x += _loc12_.m_invMass * _loc13_ * m_J.linear2.x;
|
||||
_loc12_.m_linearVelocity.y += _loc12_.m_invMass * _loc13_ * m_J.linear2.y;
|
||||
_loc12_.m_angularVelocity += _loc12_.m_invI * _loc13_ * m_J.angular2;
|
||||
}
|
||||
else
|
||||
{
|
||||
m_force = 0;
|
||||
}
|
||||
}
|
||||
|
||||
override public function SolveVelocityConstraints(param1:b2TimeStep) : void
|
||||
{
|
||||
var _loc6_:b2Body = m_body1;
|
||||
var _loc2_:b2Body = m_body2;
|
||||
var _loc4_:Number = m_J.Compute(_loc6_.m_linearVelocity,_loc6_.m_angularVelocity,_loc2_.m_linearVelocity,_loc2_.m_angularVelocity);
|
||||
var _loc5_:Number = -param1.inv_dt * m_mass * _loc4_;
|
||||
m_force += _loc5_;
|
||||
var _loc3_:Number = param1.dt * _loc5_;
|
||||
_loc6_.m_linearVelocity.x += _loc6_.m_invMass * _loc3_ * m_J.linear1.x;
|
||||
_loc6_.m_linearVelocity.y += _loc6_.m_invMass * _loc3_ * m_J.linear1.y;
|
||||
_loc6_.m_angularVelocity += _loc6_.m_invI * _loc3_ * m_J.angular1;
|
||||
_loc2_.m_linearVelocity.x += _loc2_.m_invMass * _loc3_ * m_J.linear2.x;
|
||||
_loc2_.m_linearVelocity.y += _loc2_.m_invMass * _loc3_ * m_J.linear2.y;
|
||||
_loc2_.m_angularVelocity += _loc2_.m_invI * _loc3_ * m_J.angular2;
|
||||
}
|
||||
|
||||
override public function SolvePositionConstraints() : Boolean
|
||||
{
|
||||
var _loc5_:Number = NaN;
|
||||
var _loc4_:Number = NaN;
|
||||
var _loc2_:Number = 0;
|
||||
var _loc7_:b2Body = m_body1;
|
||||
var _loc1_:b2Body = m_body2;
|
||||
if(m_revolute1)
|
||||
{
|
||||
_loc5_ = m_revolute1.GetJointAngle();
|
||||
}
|
||||
else
|
||||
{
|
||||
_loc5_ = m_prismatic1.GetJointTranslation();
|
||||
}
|
||||
if(m_revolute2)
|
||||
{
|
||||
_loc4_ = m_revolute2.GetJointAngle();
|
||||
}
|
||||
else
|
||||
{
|
||||
_loc4_ = m_prismatic2.GetJointTranslation();
|
||||
}
|
||||
var _loc3_:Number = m_constant - (_loc5_ + m_ratio * _loc4_);
|
||||
var _loc6_:Number = -m_mass * _loc3_;
|
||||
_loc7_.m_sweep.c.x += _loc7_.m_invMass * _loc6_ * m_J.linear1.x;
|
||||
_loc7_.m_sweep.c.y += _loc7_.m_invMass * _loc6_ * m_J.linear1.y;
|
||||
_loc7_.m_sweep.a += _loc7_.m_invI * _loc6_ * m_J.angular1;
|
||||
_loc1_.m_sweep.c.x += _loc1_.m_invMass * _loc6_ * m_J.linear2.x;
|
||||
_loc1_.m_sweep.c.y += _loc1_.m_invMass * _loc6_ * m_J.linear2.y;
|
||||
_loc1_.m_sweep.a += _loc1_.m_invI * _loc6_ * m_J.angular2;
|
||||
_loc7_.SynchronizeTransform();
|
||||
_loc1_.SynchronizeTransform();
|
||||
return _loc2_ < 0.005;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,22 @@
|
||||
package Box2D.Dynamics.Joints
|
||||
{
|
||||
public class b2GearJointDef extends b2JointDef
|
||||
{
|
||||
|
||||
public var joint1:b2Joint;
|
||||
|
||||
public var joint2:b2Joint;
|
||||
|
||||
public var ratio:Number;
|
||||
|
||||
public function b2GearJointDef()
|
||||
{
|
||||
super();
|
||||
type = 6;
|
||||
joint1 = null;
|
||||
joint2 = null;
|
||||
ratio = 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,43 @@
|
||||
package Box2D.Dynamics.Joints
|
||||
{
|
||||
import Box2D.Common.Math.b2Vec2;
|
||||
|
||||
public class b2Jacobian
|
||||
{
|
||||
|
||||
public var linear1:b2Vec2 = new b2Vec2();
|
||||
|
||||
public var angular1:Number;
|
||||
|
||||
public var linear2:b2Vec2 = new b2Vec2();
|
||||
|
||||
public var angular2:Number;
|
||||
|
||||
public function b2Jacobian()
|
||||
{
|
||||
super();
|
||||
}
|
||||
|
||||
public function SetZero() : void
|
||||
{
|
||||
linear1.SetZero();
|
||||
angular1 = 0;
|
||||
linear2.SetZero();
|
||||
angular2 = 0;
|
||||
}
|
||||
|
||||
public function Set(param1:b2Vec2, param2:Number, param3:b2Vec2, param4:Number) : void
|
||||
{
|
||||
linear1.SetV(param1);
|
||||
angular1 = param2;
|
||||
linear2.SetV(param3);
|
||||
angular2 = param4;
|
||||
}
|
||||
|
||||
public function Compute(param1:b2Vec2, param2:Number, param3:b2Vec2, param4:Number) : Number
|
||||
{
|
||||
return linear1.x * param1.x + linear1.y * param1.y + angular1 * param2 + (linear2.x * param3.x + linear2.y * param3.y) + angular2 * param4;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,165 @@
|
||||
package Box2D.Dynamics.Joints
|
||||
{
|
||||
import Box2D.Common.Math.b2Vec2;
|
||||
import Box2D.Dynamics.b2Body;
|
||||
import Box2D.Dynamics.b2TimeStep;
|
||||
|
||||
public class b2Joint
|
||||
{
|
||||
|
||||
public static const e_unknownJoint:int = 0;
|
||||
|
||||
public static const e_revoluteJoint:int = 1;
|
||||
|
||||
public static const e_prismaticJoint:int = 2;
|
||||
|
||||
public static const e_distanceJoint:int = 3;
|
||||
|
||||
public static const e_pulleyJoint:int = 4;
|
||||
|
||||
public static const e_mouseJoint:int = 5;
|
||||
|
||||
public static const e_gearJoint:int = 6;
|
||||
|
||||
public static const e_inactiveLimit:int = 0;
|
||||
|
||||
public static const e_atLowerLimit:int = 1;
|
||||
|
||||
public static const e_atUpperLimit:int = 2;
|
||||
|
||||
public static const e_equalLimits:int = 3;
|
||||
|
||||
public var m_type:int;
|
||||
|
||||
public var m_prev:b2Joint;
|
||||
|
||||
public var m_next:b2Joint;
|
||||
|
||||
public var m_node1:b2JointEdge = new b2JointEdge();
|
||||
|
||||
public var m_node2:b2JointEdge = new b2JointEdge();
|
||||
|
||||
public var m_body1:b2Body;
|
||||
|
||||
public var m_body2:b2Body;
|
||||
|
||||
public var m_inv_dt:Number;
|
||||
|
||||
public var m_islandFlag:Boolean;
|
||||
|
||||
public var m_collideConnected:Boolean;
|
||||
|
||||
public var m_userData:*;
|
||||
|
||||
public function b2Joint(param1:b2JointDef)
|
||||
{
|
||||
super();
|
||||
m_type = param1.type;
|
||||
m_prev = null;
|
||||
m_next = null;
|
||||
m_body1 = param1.body1;
|
||||
m_body2 = param1.body2;
|
||||
m_collideConnected = param1.collideConnected;
|
||||
m_islandFlag = false;
|
||||
m_userData = param1.userData;
|
||||
}
|
||||
|
||||
public static function Create(param1:b2JointDef, param2:*) : b2Joint
|
||||
{
|
||||
var _loc3_:b2Joint = null;
|
||||
switch(param1.type - 1)
|
||||
{
|
||||
case 0:
|
||||
_loc3_ = new b2RevoluteJoint(param1 as b2RevoluteJointDef);
|
||||
break;
|
||||
case 1:
|
||||
_loc3_ = new b2PrismaticJoint(param1 as b2PrismaticJointDef);
|
||||
break;
|
||||
case 2:
|
||||
_loc3_ = new b2DistanceJoint(param1 as b2DistanceJointDef);
|
||||
break;
|
||||
case 3:
|
||||
_loc3_ = new b2PulleyJoint(param1 as b2PulleyJointDef);
|
||||
break;
|
||||
case 4:
|
||||
_loc3_ = new b2MouseJoint(param1 as b2MouseJointDef);
|
||||
break;
|
||||
case 5:
|
||||
_loc3_ = new b2GearJoint(param1 as b2GearJointDef);
|
||||
}
|
||||
return _loc3_;
|
||||
}
|
||||
|
||||
public static function Destroy(param1:b2Joint, param2:*) : void
|
||||
{
|
||||
}
|
||||
|
||||
public function GetType() : int
|
||||
{
|
||||
return m_type;
|
||||
}
|
||||
|
||||
public function GetAnchor1() : b2Vec2
|
||||
{
|
||||
return null;
|
||||
}
|
||||
|
||||
public function GetAnchor2() : b2Vec2
|
||||
{
|
||||
return null;
|
||||
}
|
||||
|
||||
public function GetReactionForce() : b2Vec2
|
||||
{
|
||||
return null;
|
||||
}
|
||||
|
||||
public function GetReactionTorque() : Number
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
public function GetBody1() : b2Body
|
||||
{
|
||||
return m_body1;
|
||||
}
|
||||
|
||||
public function GetBody2() : b2Body
|
||||
{
|
||||
return m_body2;
|
||||
}
|
||||
|
||||
public function GetNext() : b2Joint
|
||||
{
|
||||
return m_next;
|
||||
}
|
||||
|
||||
public function GetUserData() : *
|
||||
{
|
||||
return m_userData;
|
||||
}
|
||||
|
||||
public function SetUserData(param1:*) : void
|
||||
{
|
||||
m_userData = param1;
|
||||
}
|
||||
|
||||
public function InitVelocityConstraints(param1:b2TimeStep) : void
|
||||
{
|
||||
}
|
||||
|
||||
public function SolveVelocityConstraints(param1:b2TimeStep) : void
|
||||
{
|
||||
}
|
||||
|
||||
public function InitPositionConstraints() : void
|
||||
{
|
||||
}
|
||||
|
||||
public function SolvePositionConstraints() : Boolean
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,29 @@
|
||||
package Box2D.Dynamics.Joints
|
||||
{
|
||||
import Box2D.Dynamics.b2Body;
|
||||
|
||||
public class b2JointDef
|
||||
{
|
||||
|
||||
public var type:int;
|
||||
|
||||
public var userData:*;
|
||||
|
||||
public var body1:b2Body;
|
||||
|
||||
public var body2:b2Body;
|
||||
|
||||
public var collideConnected:Boolean;
|
||||
|
||||
public function b2JointDef()
|
||||
{
|
||||
super();
|
||||
type = 0;
|
||||
userData = null;
|
||||
body1 = null;
|
||||
body2 = null;
|
||||
collideConnected = false;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,22 @@
|
||||
package Box2D.Dynamics.Joints
|
||||
{
|
||||
import Box2D.Dynamics.b2Body;
|
||||
|
||||
public class b2JointEdge
|
||||
{
|
||||
|
||||
public var other:b2Body;
|
||||
|
||||
public var joint:b2Joint;
|
||||
|
||||
public var prev:b2JointEdge;
|
||||
|
||||
public var next:b2JointEdge;
|
||||
|
||||
public function b2JointEdge()
|
||||
{
|
||||
super();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,159 @@
|
||||
package Box2D.Dynamics.Joints
|
||||
{
|
||||
import Box2D.Common.Math.b2Mat22;
|
||||
import Box2D.Common.Math.b2Vec2;
|
||||
import Box2D.Dynamics.b2Body;
|
||||
import Box2D.Dynamics.b2TimeStep;
|
||||
|
||||
public class b2MouseJoint extends b2Joint
|
||||
{
|
||||
|
||||
private var K:b2Mat22 = new b2Mat22();
|
||||
|
||||
private var K1:b2Mat22 = new b2Mat22();
|
||||
|
||||
private var K2:b2Mat22 = new b2Mat22();
|
||||
|
||||
public var m_localAnchor:b2Vec2 = new b2Vec2();
|
||||
|
||||
public var m_target:b2Vec2 = new b2Vec2();
|
||||
|
||||
public var m_impulse:b2Vec2 = new b2Vec2();
|
||||
|
||||
public var m_mass:b2Mat22 = new b2Mat22();
|
||||
|
||||
public var m_C:b2Vec2 = new b2Vec2();
|
||||
|
||||
public var m_maxForce:Number;
|
||||
|
||||
public var m_beta:Number;
|
||||
|
||||
public var m_gamma:Number;
|
||||
|
||||
public function b2MouseJoint(param1:b2MouseJointDef)
|
||||
{
|
||||
super(param1);
|
||||
m_target.SetV(param1.target);
|
||||
var _loc2_:Number = m_target.x - m_body2.m_xf.position.x;
|
||||
var _loc4_:Number = m_target.y - m_body2.m_xf.position.y;
|
||||
var _loc6_:b2Mat22 = m_body2.m_xf.R;
|
||||
m_localAnchor.x = _loc2_ * _loc6_.col1.x + _loc4_ * _loc6_.col1.y;
|
||||
m_localAnchor.y = _loc2_ * _loc6_.col2.x + _loc4_ * _loc6_.col2.y;
|
||||
m_maxForce = param1.maxForce;
|
||||
m_impulse.SetZero();
|
||||
var _loc5_:Number = m_body2.m_mass;
|
||||
var _loc8_:Number = 2 * 3.141592653589793 * param1.frequencyHz;
|
||||
var _loc3_:Number = 2 * _loc5_ * param1.dampingRatio * _loc8_;
|
||||
var _loc7_:Number = param1.timeStep * _loc5_ * (_loc8_ * _loc8_);
|
||||
m_gamma = 1 / (_loc3_ + _loc7_);
|
||||
m_beta = _loc7_ / (_loc3_ + _loc7_);
|
||||
}
|
||||
|
||||
override public function GetAnchor1() : b2Vec2
|
||||
{
|
||||
return m_target;
|
||||
}
|
||||
|
||||
override public function GetAnchor2() : b2Vec2
|
||||
{
|
||||
return m_body2.GetWorldPoint(m_localAnchor);
|
||||
}
|
||||
|
||||
override public function GetReactionForce() : b2Vec2
|
||||
{
|
||||
return m_impulse;
|
||||
}
|
||||
|
||||
override public function GetReactionTorque() : Number
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
public function SetTarget(param1:b2Vec2) : void
|
||||
{
|
||||
if(m_body2.IsSleeping())
|
||||
{
|
||||
m_body2.WakeUp();
|
||||
}
|
||||
m_target = param1;
|
||||
}
|
||||
|
||||
override public function InitVelocityConstraints(param1:b2TimeStep) : void
|
||||
{
|
||||
var _loc8_:b2Mat22 = null;
|
||||
var _loc2_:b2Body = m_body2;
|
||||
_loc8_ = _loc2_.m_xf.R;
|
||||
var _loc5_:Number = m_localAnchor.x - _loc2_.m_sweep.localCenter.x;
|
||||
var _loc6_:Number = m_localAnchor.y - _loc2_.m_sweep.localCenter.y;
|
||||
var _loc4_:Number = _loc8_.col1.x * _loc5_ + _loc8_.col2.x * _loc6_;
|
||||
_loc6_ = _loc8_.col1.y * _loc5_ + _loc8_.col2.y * _loc6_;
|
||||
_loc5_ = _loc4_;
|
||||
var _loc3_:Number = _loc2_.m_invMass;
|
||||
var _loc9_:Number = _loc2_.m_invI;
|
||||
K1.col1.x = _loc3_;
|
||||
K1.col2.x = 0;
|
||||
K1.col1.y = 0;
|
||||
K1.col2.y = _loc3_;
|
||||
K2.col1.x = _loc9_ * _loc6_ * _loc6_;
|
||||
K2.col2.x = -_loc9_ * _loc5_ * _loc6_;
|
||||
K2.col1.y = -_loc9_ * _loc5_ * _loc6_;
|
||||
K2.col2.y = _loc9_ * _loc5_ * _loc5_;
|
||||
K.SetM(K1);
|
||||
K.AddM(K2);
|
||||
K.col1.x += m_gamma;
|
||||
K.col2.y += m_gamma;
|
||||
K.Invert(m_mass);
|
||||
m_C.x = _loc2_.m_sweep.c.x + _loc5_ - m_target.x;
|
||||
m_C.y = _loc2_.m_sweep.c.y + _loc6_ - m_target.y;
|
||||
_loc2_.m_angularVelocity *= 0.98;
|
||||
var _loc7_:Number = param1.dt * m_impulse.x;
|
||||
var _loc10_:Number = param1.dt * m_impulse.y;
|
||||
_loc2_.m_linearVelocity.x += _loc3_ * _loc7_;
|
||||
_loc2_.m_linearVelocity.y += _loc3_ * _loc10_;
|
||||
_loc2_.m_angularVelocity += _loc9_ * (_loc5_ * _loc10_ - _loc6_ * _loc7_);
|
||||
}
|
||||
|
||||
override public function SolveVelocityConstraints(param1:b2TimeStep) : void
|
||||
{
|
||||
var _loc16_:b2Mat22 = null;
|
||||
var _loc3_:Number = NaN;
|
||||
var _loc4_:Number = NaN;
|
||||
var _loc2_:b2Body = m_body2;
|
||||
_loc16_ = _loc2_.m_xf.R;
|
||||
var _loc5_:Number = m_localAnchor.x - _loc2_.m_sweep.localCenter.x;
|
||||
var _loc6_:Number = m_localAnchor.y - _loc2_.m_sweep.localCenter.y;
|
||||
_loc3_ = _loc16_.col1.x * _loc5_ + _loc16_.col2.x * _loc6_;
|
||||
_loc6_ = _loc16_.col1.y * _loc5_ + _loc16_.col2.y * _loc6_;
|
||||
_loc5_ = _loc3_;
|
||||
var _loc12_:Number = _loc2_.m_linearVelocity.x + -_loc2_.m_angularVelocity * _loc6_;
|
||||
var _loc11_:Number = _loc2_.m_linearVelocity.y + _loc2_.m_angularVelocity * _loc5_;
|
||||
_loc16_ = m_mass;
|
||||
_loc3_ = _loc12_ + m_beta * param1.inv_dt * m_C.x + m_gamma * param1.dt * m_impulse.x;
|
||||
_loc4_ = _loc11_ + m_beta * param1.inv_dt * m_C.y + m_gamma * param1.dt * m_impulse.y;
|
||||
var _loc14_:Number = -param1.inv_dt * (_loc16_.col1.x * _loc3_ + _loc16_.col2.x * _loc4_);
|
||||
var _loc13_:Number = -param1.inv_dt * (_loc16_.col1.y * _loc3_ + _loc16_.col2.y * _loc4_);
|
||||
var _loc9_:Number = m_impulse.x;
|
||||
var _loc10_:Number = m_impulse.y;
|
||||
m_impulse.x += _loc14_;
|
||||
m_impulse.y += _loc13_;
|
||||
var _loc15_:Number = m_impulse.Length();
|
||||
if(_loc15_ > m_maxForce)
|
||||
{
|
||||
m_impulse.Multiply(m_maxForce / _loc15_);
|
||||
}
|
||||
_loc14_ = m_impulse.x - _loc9_;
|
||||
_loc13_ = m_impulse.y - _loc10_;
|
||||
var _loc7_:Number = param1.dt * _loc14_;
|
||||
var _loc8_:Number = param1.dt * _loc13_;
|
||||
_loc2_.m_linearVelocity.x += _loc2_.m_invMass * _loc7_;
|
||||
_loc2_.m_linearVelocity.y += _loc2_.m_invMass * _loc8_;
|
||||
_loc2_.m_angularVelocity += _loc2_.m_invI * (_loc5_ * _loc8_ - _loc6_ * _loc7_);
|
||||
}
|
||||
|
||||
override public function SolvePositionConstraints() : Boolean
|
||||
{
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,29 @@
|
||||
package Box2D.Dynamics.Joints
|
||||
{
|
||||
import Box2D.Common.Math.b2Vec2;
|
||||
|
||||
public class b2MouseJointDef extends b2JointDef
|
||||
{
|
||||
|
||||
public var target:b2Vec2 = new b2Vec2();
|
||||
|
||||
public var maxForce:Number;
|
||||
|
||||
public var frequencyHz:Number;
|
||||
|
||||
public var dampingRatio:Number;
|
||||
|
||||
public var timeStep:Number;
|
||||
|
||||
public function b2MouseJointDef()
|
||||
{
|
||||
super();
|
||||
type = 5;
|
||||
maxForce = 0;
|
||||
frequencyHz = 5;
|
||||
dampingRatio = 0.7;
|
||||
timeStep = 0.016666666666666666;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,534 @@
|
||||
package Box2D.Dynamics.Joints
|
||||
{
|
||||
import Box2D.Common.Math.b2Mat22;
|
||||
import Box2D.Common.Math.b2Math;
|
||||
import Box2D.Common.Math.b2Vec2;
|
||||
import Box2D.Dynamics.b2Body;
|
||||
import Box2D.Dynamics.b2TimeStep;
|
||||
|
||||
public class b2PrismaticJoint extends b2Joint
|
||||
{
|
||||
|
||||
public var m_localAnchor1:b2Vec2 = new b2Vec2();
|
||||
|
||||
public var m_localAnchor2:b2Vec2 = new b2Vec2();
|
||||
|
||||
public var m_localXAxis1:b2Vec2 = new b2Vec2();
|
||||
|
||||
public var m_localYAxis1:b2Vec2 = new b2Vec2();
|
||||
|
||||
public var m_refAngle:Number;
|
||||
|
||||
public var m_linearJacobian:b2Jacobian = new b2Jacobian();
|
||||
|
||||
public var m_linearMass:Number;
|
||||
|
||||
public var m_force:Number;
|
||||
|
||||
public var m_angularMass:Number;
|
||||
|
||||
public var m_torque:Number;
|
||||
|
||||
public var m_motorJacobian:b2Jacobian = new b2Jacobian();
|
||||
|
||||
public var m_motorMass:Number;
|
||||
|
||||
public var m_motorForce:Number;
|
||||
|
||||
public var m_limitForce:Number;
|
||||
|
||||
public var m_limitPositionImpulse:Number;
|
||||
|
||||
public var m_lowerTranslation:Number;
|
||||
|
||||
public var m_upperTranslation:Number;
|
||||
|
||||
public var m_maxMotorForce:Number;
|
||||
|
||||
public var m_motorSpeed:Number;
|
||||
|
||||
public var m_enableLimit:Boolean;
|
||||
|
||||
public var m_enableMotor:Boolean;
|
||||
|
||||
public var m_limitState:int;
|
||||
|
||||
public function b2PrismaticJoint(param1:b2PrismaticJointDef)
|
||||
{
|
||||
var _loc4_:* = null;
|
||||
var _loc2_:Number = NaN;
|
||||
var _loc3_:Number = NaN;
|
||||
super(param1);
|
||||
m_localAnchor1.SetV(param1.localAnchor1);
|
||||
m_localAnchor2.SetV(param1.localAnchor2);
|
||||
m_localXAxis1.SetV(param1.localAxis1);
|
||||
m_localYAxis1.x = -m_localXAxis1.y;
|
||||
m_localYAxis1.y = m_localXAxis1.x;
|
||||
m_refAngle = param1.referenceAngle;
|
||||
m_linearJacobian.SetZero();
|
||||
m_linearMass = 0;
|
||||
m_force = 0;
|
||||
m_angularMass = 0;
|
||||
m_torque = 0;
|
||||
m_motorJacobian.SetZero();
|
||||
m_motorMass = 0;
|
||||
m_motorForce = 0;
|
||||
m_limitForce = 0;
|
||||
m_limitPositionImpulse = 0;
|
||||
m_lowerTranslation = param1.lowerTranslation;
|
||||
m_upperTranslation = param1.upperTranslation;
|
||||
m_maxMotorForce = param1.maxMotorForce;
|
||||
m_motorSpeed = param1.motorSpeed;
|
||||
m_enableLimit = param1.enableLimit;
|
||||
m_enableMotor = param1.enableMotor;
|
||||
}
|
||||
|
||||
override public function GetAnchor1() : b2Vec2
|
||||
{
|
||||
return m_body1.GetWorldPoint(m_localAnchor1);
|
||||
}
|
||||
|
||||
override public function GetAnchor2() : b2Vec2
|
||||
{
|
||||
return m_body2.GetWorldPoint(m_localAnchor2);
|
||||
}
|
||||
|
||||
override public function GetReactionForce() : b2Vec2
|
||||
{
|
||||
var _loc4_:b2Mat22 = m_body1.m_xf.R;
|
||||
var _loc3_:Number = m_limitForce * (_loc4_.col1.x * m_localXAxis1.x + _loc4_.col2.x * m_localXAxis1.y);
|
||||
var _loc1_:Number = m_limitForce * (_loc4_.col1.y * m_localXAxis1.x + _loc4_.col2.y * m_localXAxis1.y);
|
||||
var _loc2_:Number = m_force * (_loc4_.col1.x * m_localYAxis1.x + _loc4_.col2.x * m_localYAxis1.y);
|
||||
var _loc5_:Number = m_force * (_loc4_.col1.y * m_localYAxis1.x + _loc4_.col2.y * m_localYAxis1.y);
|
||||
return new b2Vec2(m_limitForce * _loc3_ + m_force * _loc2_,m_limitForce * _loc1_ + m_force * _loc5_);
|
||||
}
|
||||
|
||||
override public function GetReactionTorque() : Number
|
||||
{
|
||||
return m_torque;
|
||||
}
|
||||
|
||||
public function GetJointTranslation() : Number
|
||||
{
|
||||
var _loc7_:* = null;
|
||||
var _loc9_:b2Body = m_body1;
|
||||
var _loc1_:b2Body = m_body2;
|
||||
var _loc2_:b2Vec2 = _loc9_.GetWorldPoint(m_localAnchor1);
|
||||
var _loc3_:b2Vec2 = _loc1_.GetWorldPoint(m_localAnchor2);
|
||||
var _loc4_:Number = _loc3_.x - _loc2_.x;
|
||||
var _loc5_:Number = _loc3_.y - _loc2_.y;
|
||||
var _loc8_:b2Vec2 = _loc9_.GetWorldVector(m_localXAxis1);
|
||||
return _loc8_.x * _loc4_ + _loc8_.y * _loc5_;
|
||||
}
|
||||
|
||||
public function GetJointSpeed() : Number
|
||||
{
|
||||
var _loc13_:b2Mat22 = null;
|
||||
var _loc4_:b2Body = m_body1;
|
||||
var _loc5_:b2Body = m_body2;
|
||||
_loc13_ = _loc4_.m_xf.R;
|
||||
var _loc11_:Number = m_localAnchor1.x - _loc4_.m_sweep.localCenter.x;
|
||||
var _loc17_:Number = m_localAnchor1.y - _loc4_.m_sweep.localCenter.y;
|
||||
var _loc1_:Number = _loc13_.col1.x * _loc11_ + _loc13_.col2.x * _loc17_;
|
||||
_loc17_ = _loc13_.col1.y * _loc11_ + _loc13_.col2.y * _loc17_;
|
||||
_loc11_ = _loc1_;
|
||||
_loc13_ = _loc5_.m_xf.R;
|
||||
var _loc14_:Number = m_localAnchor2.x - _loc5_.m_sweep.localCenter.x;
|
||||
var _loc12_:Number = m_localAnchor2.y - _loc5_.m_sweep.localCenter.y;
|
||||
_loc1_ = _loc13_.col1.x * _loc14_ + _loc13_.col2.x * _loc12_;
|
||||
_loc12_ = _loc13_.col1.y * _loc14_ + _loc13_.col2.y * _loc12_;
|
||||
_loc14_ = _loc1_;
|
||||
var _loc8_:Number = _loc4_.m_sweep.c.x + _loc11_;
|
||||
var _loc15_:Number = _loc4_.m_sweep.c.y + _loc17_;
|
||||
var _loc10_:Number = _loc5_.m_sweep.c.x + _loc14_;
|
||||
var _loc9_:Number = _loc5_.m_sweep.c.y + _loc12_;
|
||||
var _loc6_:Number = _loc10_ - _loc8_;
|
||||
var _loc7_:Number = _loc9_ - _loc15_;
|
||||
var _loc2_:b2Vec2 = _loc4_.GetWorldVector(m_localXAxis1);
|
||||
var _loc18_:b2Vec2 = _loc4_.m_linearVelocity;
|
||||
var _loc20_:b2Vec2 = _loc5_.m_linearVelocity;
|
||||
var _loc16_:Number = _loc4_.m_angularVelocity;
|
||||
var _loc19_:Number = _loc5_.m_angularVelocity;
|
||||
return _loc6_ * (-_loc16_ * _loc2_.y) + _loc7_ * (_loc16_ * _loc2_.x) + (_loc2_.x * (_loc20_.x + -_loc19_ * _loc12_ - _loc18_.x - -_loc16_ * _loc17_) + _loc2_.y * (_loc20_.y + _loc19_ * _loc14_ - _loc18_.y - _loc16_ * _loc11_));
|
||||
}
|
||||
|
||||
public function IsLimitEnabled() : Boolean
|
||||
{
|
||||
return m_enableLimit;
|
||||
}
|
||||
|
||||
public function EnableLimit(param1:Boolean) : void
|
||||
{
|
||||
m_enableLimit = param1;
|
||||
}
|
||||
|
||||
public function GetLowerLimit() : Number
|
||||
{
|
||||
return m_lowerTranslation;
|
||||
}
|
||||
|
||||
public function GetUpperLimit() : Number
|
||||
{
|
||||
return m_upperTranslation;
|
||||
}
|
||||
|
||||
public function SetLimits(param1:Number, param2:Number) : void
|
||||
{
|
||||
m_lowerTranslation = param1;
|
||||
m_upperTranslation = param2;
|
||||
}
|
||||
|
||||
public function IsMotorEnabled() : Boolean
|
||||
{
|
||||
return m_enableMotor;
|
||||
}
|
||||
|
||||
public function EnableMotor(param1:Boolean) : void
|
||||
{
|
||||
m_enableMotor = param1;
|
||||
}
|
||||
|
||||
public function SetMotorSpeed(param1:Number) : void
|
||||
{
|
||||
m_motorSpeed = param1;
|
||||
}
|
||||
|
||||
public function GetMotorSpeed() : Number
|
||||
{
|
||||
return m_motorSpeed;
|
||||
}
|
||||
|
||||
public function SetMaxMotorForce(param1:Number) : void
|
||||
{
|
||||
m_maxMotorForce = param1;
|
||||
}
|
||||
|
||||
public function GetMotorForce() : Number
|
||||
{
|
||||
return m_motorForce;
|
||||
}
|
||||
|
||||
override public function InitVelocityConstraints(param1:b2TimeStep) : void
|
||||
{
|
||||
var _loc27_:b2Mat22 = null;
|
||||
var _loc17_:Number = NaN;
|
||||
var _loc11_:Number = NaN;
|
||||
var _loc9_:Number = NaN;
|
||||
var _loc21_:Number = NaN;
|
||||
var _loc22_:Number = NaN;
|
||||
var _loc26_:Number = NaN;
|
||||
var _loc13_:Number = NaN;
|
||||
var _loc16_:Number = NaN;
|
||||
var _loc24_:Number = NaN;
|
||||
var _loc23_:Number = NaN;
|
||||
var _loc18_:Number = NaN;
|
||||
var _loc19_:Number = NaN;
|
||||
var _loc6_:b2Body = m_body1;
|
||||
var _loc7_:b2Body = m_body2;
|
||||
_loc27_ = _loc6_.m_xf.R;
|
||||
var _loc25_:Number = m_localAnchor1.x - _loc6_.m_sweep.localCenter.x;
|
||||
var _loc28_:Number = m_localAnchor1.y - _loc6_.m_sweep.localCenter.y;
|
||||
_loc17_ = _loc27_.col1.x * _loc25_ + _loc27_.col2.x * _loc28_;
|
||||
_loc28_ = _loc27_.col1.y * _loc25_ + _loc27_.col2.y * _loc28_;
|
||||
_loc25_ = _loc17_;
|
||||
_loc27_ = _loc7_.m_xf.R;
|
||||
var _loc15_:Number = m_localAnchor2.x - _loc7_.m_sweep.localCenter.x;
|
||||
var _loc14_:Number = m_localAnchor2.y - _loc7_.m_sweep.localCenter.y;
|
||||
_loc17_ = _loc27_.col1.x * _loc15_ + _loc27_.col2.x * _loc14_;
|
||||
_loc14_ = _loc27_.col1.y * _loc15_ + _loc27_.col2.y * _loc14_;
|
||||
_loc15_ = _loc17_;
|
||||
var _loc5_:Number = _loc6_.m_invMass;
|
||||
var _loc3_:Number = _loc7_.m_invMass;
|
||||
var _loc4_:Number = _loc6_.m_invI;
|
||||
var _loc2_:Number = _loc7_.m_invI;
|
||||
_loc27_ = _loc6_.m_xf.R;
|
||||
var _loc8_:Number = _loc27_.col1.x * m_localYAxis1.x + _loc27_.col2.x * m_localYAxis1.y;
|
||||
var _loc20_:Number = _loc27_.col1.y * m_localYAxis1.x + _loc27_.col2.y * m_localYAxis1.y;
|
||||
var _loc10_:Number = _loc7_.m_sweep.c.x + _loc15_ - _loc6_.m_sweep.c.x;
|
||||
var _loc12_:Number = _loc7_.m_sweep.c.y + _loc14_ - _loc6_.m_sweep.c.y;
|
||||
m_linearJacobian.linear1.x = -_loc8_;
|
||||
m_linearJacobian.linear1.y = -_loc20_;
|
||||
m_linearJacobian.linear2.x = _loc8_;
|
||||
m_linearJacobian.linear2.y = _loc20_;
|
||||
m_linearJacobian.angular1 = -(_loc10_ * _loc20_ - _loc12_ * _loc8_);
|
||||
m_linearJacobian.angular2 = _loc15_ * _loc20_ - _loc14_ * _loc8_;
|
||||
m_linearMass = _loc5_ + _loc4_ * m_linearJacobian.angular1 * m_linearJacobian.angular1 + _loc3_ + _loc2_ * m_linearJacobian.angular2 * m_linearJacobian.angular2;
|
||||
m_linearMass = 1 / m_linearMass;
|
||||
m_angularMass = _loc4_ + _loc2_;
|
||||
if(m_angularMass > Number.MIN_VALUE)
|
||||
{
|
||||
m_angularMass = 1 / m_angularMass;
|
||||
}
|
||||
if(m_enableLimit || m_enableMotor)
|
||||
{
|
||||
_loc27_ = _loc6_.m_xf.R;
|
||||
_loc11_ = _loc27_.col1.x * m_localXAxis1.x + _loc27_.col2.x * m_localXAxis1.y;
|
||||
_loc9_ = _loc27_.col1.y * m_localXAxis1.x + _loc27_.col2.y * m_localXAxis1.y;
|
||||
m_motorJacobian.linear1.x = -_loc11_;
|
||||
m_motorJacobian.linear1.y = -_loc9_;
|
||||
m_motorJacobian.linear2.x = _loc11_;
|
||||
m_motorJacobian.linear2.y = _loc9_;
|
||||
m_motorJacobian.angular1 = -(_loc10_ * _loc9_ - _loc12_ * _loc11_);
|
||||
m_motorJacobian.angular2 = _loc15_ * _loc9_ - _loc14_ * _loc11_;
|
||||
m_motorMass = _loc5_ + _loc4_ * m_motorJacobian.angular1 * m_motorJacobian.angular1 + _loc3_ + _loc2_ * m_motorJacobian.angular2 * m_motorJacobian.angular2;
|
||||
m_motorMass = 1 / m_motorMass;
|
||||
if(m_enableLimit)
|
||||
{
|
||||
_loc21_ = _loc10_ - _loc25_;
|
||||
_loc22_ = _loc12_ - _loc28_;
|
||||
_loc26_ = _loc11_ * _loc21_ + _loc9_ * _loc22_;
|
||||
if(b2Math.b2Abs(m_upperTranslation - m_lowerTranslation) < 2 * 0.005)
|
||||
{
|
||||
m_limitState = 3;
|
||||
}
|
||||
else if(_loc26_ <= m_lowerTranslation)
|
||||
{
|
||||
if(m_limitState != 1)
|
||||
{
|
||||
m_limitForce = 0;
|
||||
}
|
||||
m_limitState = 1;
|
||||
}
|
||||
else if(_loc26_ >= m_upperTranslation)
|
||||
{
|
||||
if(m_limitState != 2)
|
||||
{
|
||||
m_limitForce = 0;
|
||||
}
|
||||
m_limitState = 2;
|
||||
}
|
||||
else
|
||||
{
|
||||
m_limitState = 0;
|
||||
m_limitForce = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
if(m_enableMotor == false)
|
||||
{
|
||||
m_motorForce = 0;
|
||||
}
|
||||
if(m_enableLimit == false)
|
||||
{
|
||||
m_limitForce = 0;
|
||||
}
|
||||
if(param1.warmStarting)
|
||||
{
|
||||
_loc13_ = param1.dt * (m_force * m_linearJacobian.linear1.x + (m_motorForce + m_limitForce) * m_motorJacobian.linear1.x);
|
||||
_loc16_ = param1.dt * (m_force * m_linearJacobian.linear1.y + (m_motorForce + m_limitForce) * m_motorJacobian.linear1.y);
|
||||
_loc24_ = param1.dt * (m_force * m_linearJacobian.linear2.x + (m_motorForce + m_limitForce) * m_motorJacobian.linear2.x);
|
||||
_loc23_ = param1.dt * (m_force * m_linearJacobian.linear2.y + (m_motorForce + m_limitForce) * m_motorJacobian.linear2.y);
|
||||
_loc18_ = param1.dt * (m_force * m_linearJacobian.angular1 - m_torque + (m_motorForce + m_limitForce) * m_motorJacobian.angular1);
|
||||
_loc19_ = param1.dt * (m_force * m_linearJacobian.angular2 + m_torque + (m_motorForce + m_limitForce) * m_motorJacobian.angular2);
|
||||
_loc6_.m_linearVelocity.x += _loc5_ * _loc13_;
|
||||
_loc6_.m_linearVelocity.y += _loc5_ * _loc16_;
|
||||
_loc6_.m_angularVelocity += _loc4_ * _loc18_;
|
||||
_loc7_.m_linearVelocity.x += _loc3_ * _loc24_;
|
||||
_loc7_.m_linearVelocity.y += _loc3_ * _loc23_;
|
||||
_loc7_.m_angularVelocity += _loc2_ * _loc19_;
|
||||
}
|
||||
else
|
||||
{
|
||||
m_force = 0;
|
||||
m_torque = 0;
|
||||
m_limitForce = 0;
|
||||
m_motorForce = 0;
|
||||
}
|
||||
m_limitPositionImpulse = 0;
|
||||
}
|
||||
|
||||
override public function SolveVelocityConstraints(param1:b2TimeStep) : void
|
||||
{
|
||||
var _loc14_:Number = NaN;
|
||||
var _loc16_:Number = NaN;
|
||||
var _loc15_:Number = NaN;
|
||||
var _loc12_:Number = NaN;
|
||||
var _loc13_:Number = NaN;
|
||||
var _loc8_:Number = NaN;
|
||||
var _loc9_:b2Body = m_body1;
|
||||
var _loc10_:b2Body = m_body2;
|
||||
var _loc5_:Number = _loc9_.m_invMass;
|
||||
var _loc3_:Number = _loc10_.m_invMass;
|
||||
var _loc4_:Number = _loc9_.m_invI;
|
||||
var _loc2_:Number = _loc10_.m_invI;
|
||||
var _loc18_:Number = m_linearJacobian.Compute(_loc9_.m_linearVelocity,_loc9_.m_angularVelocity,_loc10_.m_linearVelocity,_loc10_.m_angularVelocity);
|
||||
var _loc17_:Number = -param1.inv_dt * m_linearMass * _loc18_;
|
||||
m_force += _loc17_;
|
||||
var _loc11_:Number = param1.dt * _loc17_;
|
||||
_loc9_.m_linearVelocity.x += _loc5_ * _loc11_ * m_linearJacobian.linear1.x;
|
||||
_loc9_.m_linearVelocity.y += _loc5_ * _loc11_ * m_linearJacobian.linear1.y;
|
||||
_loc9_.m_angularVelocity += _loc4_ * _loc11_ * m_linearJacobian.angular1;
|
||||
_loc10_.m_linearVelocity.x += _loc3_ * _loc11_ * m_linearJacobian.linear2.x;
|
||||
_loc10_.m_linearVelocity.y += _loc3_ * _loc11_ * m_linearJacobian.linear2.y;
|
||||
_loc10_.m_angularVelocity += _loc2_ * _loc11_ * m_linearJacobian.angular2;
|
||||
var _loc19_:Number = _loc10_.m_angularVelocity - _loc9_.m_angularVelocity;
|
||||
var _loc6_:Number = -param1.inv_dt * m_angularMass * _loc19_;
|
||||
m_torque += _loc6_;
|
||||
var _loc7_:Number = param1.dt * _loc6_;
|
||||
_loc9_.m_angularVelocity -= _loc4_ * _loc7_;
|
||||
_loc10_.m_angularVelocity += _loc2_ * _loc7_;
|
||||
if(m_enableMotor && m_limitState != 3)
|
||||
{
|
||||
_loc16_ = m_motorJacobian.Compute(_loc9_.m_linearVelocity,_loc9_.m_angularVelocity,_loc10_.m_linearVelocity,_loc10_.m_angularVelocity) - m_motorSpeed;
|
||||
_loc15_ = -param1.inv_dt * m_motorMass * _loc16_;
|
||||
_loc12_ = m_motorForce;
|
||||
m_motorForce = b2Math.b2Clamp(m_motorForce + _loc15_,-m_maxMotorForce,m_maxMotorForce);
|
||||
_loc15_ = m_motorForce - _loc12_;
|
||||
_loc11_ = param1.dt * _loc15_;
|
||||
_loc9_.m_linearVelocity.x += _loc5_ * _loc11_ * m_motorJacobian.linear1.x;
|
||||
_loc9_.m_linearVelocity.y += _loc5_ * _loc11_ * m_motorJacobian.linear1.y;
|
||||
_loc9_.m_angularVelocity += _loc4_ * _loc11_ * m_motorJacobian.angular1;
|
||||
_loc10_.m_linearVelocity.x += _loc3_ * _loc11_ * m_motorJacobian.linear2.x;
|
||||
_loc10_.m_linearVelocity.y += _loc3_ * _loc11_ * m_motorJacobian.linear2.y;
|
||||
_loc10_.m_angularVelocity += _loc2_ * _loc11_ * m_motorJacobian.angular2;
|
||||
}
|
||||
if(m_enableLimit && m_limitState != 0)
|
||||
{
|
||||
_loc13_ = m_motorJacobian.Compute(_loc9_.m_linearVelocity,_loc9_.m_angularVelocity,_loc10_.m_linearVelocity,_loc10_.m_angularVelocity);
|
||||
_loc8_ = -param1.inv_dt * m_motorMass * _loc13_;
|
||||
if(m_limitState == 3)
|
||||
{
|
||||
m_limitForce += _loc8_;
|
||||
}
|
||||
else if(m_limitState == 1)
|
||||
{
|
||||
_loc14_ = m_limitForce;
|
||||
m_limitForce = b2Math.b2Max(m_limitForce + _loc8_,0);
|
||||
_loc8_ = m_limitForce - _loc14_;
|
||||
}
|
||||
else if(m_limitState == 2)
|
||||
{
|
||||
_loc14_ = m_limitForce;
|
||||
m_limitForce = b2Math.b2Min(m_limitForce + _loc8_,0);
|
||||
_loc8_ = m_limitForce - _loc14_;
|
||||
}
|
||||
_loc11_ = param1.dt * _loc8_;
|
||||
_loc9_.m_linearVelocity.x += _loc5_ * _loc11_ * m_motorJacobian.linear1.x;
|
||||
_loc9_.m_linearVelocity.y += _loc5_ * _loc11_ * m_motorJacobian.linear1.y;
|
||||
_loc9_.m_angularVelocity += _loc4_ * _loc11_ * m_motorJacobian.angular1;
|
||||
_loc10_.m_linearVelocity.x += _loc3_ * _loc11_ * m_motorJacobian.linear2.x;
|
||||
_loc10_.m_linearVelocity.y += _loc3_ * _loc11_ * m_motorJacobian.linear2.y;
|
||||
_loc10_.m_angularVelocity += _loc2_ * _loc11_ * m_motorJacobian.angular2;
|
||||
}
|
||||
}
|
||||
|
||||
override public function SolvePositionConstraints() : Boolean
|
||||
{
|
||||
var _loc22_:Number = NaN;
|
||||
var _loc13_:Number = NaN;
|
||||
var _loc29_:b2Mat22 = null;
|
||||
var _loc19_:Number = NaN;
|
||||
var _loc12_:Number = NaN;
|
||||
var _loc11_:Number = NaN;
|
||||
var _loc28_:Number = NaN;
|
||||
var _loc18_:Number = NaN;
|
||||
var _loc8_:b2Body = m_body1;
|
||||
var _loc9_:b2Body = m_body2;
|
||||
var _loc5_:Number = _loc8_.m_invMass;
|
||||
var _loc2_:Number = _loc9_.m_invMass;
|
||||
var _loc3_:Number = _loc8_.m_invI;
|
||||
var _loc1_:Number = _loc9_.m_invI;
|
||||
_loc29_ = _loc8_.m_xf.R;
|
||||
var _loc27_:Number = m_localAnchor1.x - _loc8_.m_sweep.localCenter.x;
|
||||
var _loc31_:Number = m_localAnchor1.y - _loc8_.m_sweep.localCenter.y;
|
||||
_loc19_ = _loc29_.col1.x * _loc27_ + _loc29_.col2.x * _loc31_;
|
||||
_loc31_ = _loc29_.col1.y * _loc27_ + _loc29_.col2.y * _loc31_;
|
||||
_loc27_ = _loc19_;
|
||||
_loc29_ = _loc9_.m_xf.R;
|
||||
var _loc17_:Number = m_localAnchor2.x - _loc9_.m_sweep.localCenter.x;
|
||||
var _loc16_:Number = m_localAnchor2.y - _loc9_.m_sweep.localCenter.y;
|
||||
_loc19_ = _loc29_.col1.x * _loc17_ + _loc29_.col2.x * _loc16_;
|
||||
_loc16_ = _loc29_.col1.y * _loc17_ + _loc29_.col2.y * _loc16_;
|
||||
_loc17_ = _loc19_;
|
||||
var _loc26_:Number = _loc8_.m_sweep.c.x + _loc27_;
|
||||
var _loc30_:Number = _loc8_.m_sweep.c.y + _loc31_;
|
||||
var _loc15_:Number = _loc9_.m_sweep.c.x + _loc17_;
|
||||
var _loc14_:Number = _loc9_.m_sweep.c.y + _loc16_;
|
||||
var _loc23_:Number = _loc15_ - _loc26_;
|
||||
var _loc24_:Number = _loc14_ - _loc30_;
|
||||
_loc29_ = _loc8_.m_xf.R;
|
||||
var _loc10_:Number = _loc29_.col1.x * m_localYAxis1.x + _loc29_.col2.x * m_localYAxis1.y;
|
||||
var _loc21_:Number = _loc29_.col1.y * m_localYAxis1.x + _loc29_.col2.y * m_localYAxis1.y;
|
||||
var _loc25_:Number = _loc10_ * _loc23_ + _loc21_ * _loc24_;
|
||||
_loc25_ = b2Math.b2Clamp(_loc25_,-0.2,0.2);
|
||||
var _loc7_:Number = -m_linearMass * _loc25_;
|
||||
_loc8_.m_sweep.c.x += _loc5_ * _loc7_ * m_linearJacobian.linear1.x;
|
||||
_loc8_.m_sweep.c.y += _loc5_ * _loc7_ * m_linearJacobian.linear1.y;
|
||||
_loc8_.m_sweep.a += _loc3_ * _loc7_ * m_linearJacobian.angular1;
|
||||
_loc9_.m_sweep.c.x += _loc2_ * _loc7_ * m_linearJacobian.linear2.x;
|
||||
_loc9_.m_sweep.c.y += _loc2_ * _loc7_ * m_linearJacobian.linear2.y;
|
||||
_loc9_.m_sweep.a += _loc1_ * _loc7_ * m_linearJacobian.angular2;
|
||||
var _loc4_:Number = b2Math.b2Abs(_loc25_);
|
||||
var _loc6_:Number = _loc9_.m_sweep.a - _loc8_.m_sweep.a - m_refAngle;
|
||||
_loc6_ = b2Math.b2Clamp(_loc6_,-0.13962634015954636,0.13962634015954636);
|
||||
var _loc32_:Number = -m_angularMass * _loc6_;
|
||||
_loc8_.m_sweep.a -= _loc8_.m_invI * _loc32_;
|
||||
_loc9_.m_sweep.a += _loc9_.m_invI * _loc32_;
|
||||
_loc8_.SynchronizeTransform();
|
||||
_loc9_.SynchronizeTransform();
|
||||
var _loc20_:Number = b2Math.b2Abs(_loc6_);
|
||||
if(m_enableLimit && m_limitState != 0)
|
||||
{
|
||||
_loc29_ = _loc8_.m_xf.R;
|
||||
_loc27_ = m_localAnchor1.x - _loc8_.m_sweep.localCenter.x;
|
||||
_loc31_ = m_localAnchor1.y - _loc8_.m_sweep.localCenter.y;
|
||||
_loc19_ = _loc29_.col1.x * _loc27_ + _loc29_.col2.x * _loc31_;
|
||||
_loc31_ = _loc29_.col1.y * _loc27_ + _loc29_.col2.y * _loc31_;
|
||||
_loc27_ = _loc19_;
|
||||
_loc29_ = _loc9_.m_xf.R;
|
||||
_loc17_ = m_localAnchor2.x - _loc9_.m_sweep.localCenter.x;
|
||||
_loc16_ = m_localAnchor2.y - _loc9_.m_sweep.localCenter.y;
|
||||
_loc19_ = _loc29_.col1.x * _loc17_ + _loc29_.col2.x * _loc16_;
|
||||
_loc16_ = _loc29_.col1.y * _loc17_ + _loc29_.col2.y * _loc16_;
|
||||
_loc17_ = _loc19_;
|
||||
_loc26_ = _loc8_.m_sweep.c.x + _loc27_;
|
||||
_loc30_ = _loc8_.m_sweep.c.y + _loc31_;
|
||||
_loc15_ = _loc9_.m_sweep.c.x + _loc17_;
|
||||
_loc14_ = _loc9_.m_sweep.c.y + _loc16_;
|
||||
_loc23_ = _loc15_ - _loc26_;
|
||||
_loc24_ = _loc14_ - _loc30_;
|
||||
_loc29_ = _loc8_.m_xf.R;
|
||||
_loc12_ = _loc29_.col1.x * m_localXAxis1.x + _loc29_.col2.x * m_localXAxis1.y;
|
||||
_loc11_ = _loc29_.col1.y * m_localXAxis1.x + _loc29_.col2.y * m_localXAxis1.y;
|
||||
_loc28_ = _loc12_ * _loc23_ + _loc11_ * _loc24_;
|
||||
_loc18_ = 0;
|
||||
if(m_limitState == 3)
|
||||
{
|
||||
_loc22_ = b2Math.b2Clamp(_loc28_,-0.2,0.2);
|
||||
_loc18_ = -m_motorMass * _loc22_;
|
||||
_loc4_ = b2Math.b2Max(_loc4_,b2Math.b2Abs(_loc6_));
|
||||
}
|
||||
else if(m_limitState == 1)
|
||||
{
|
||||
_loc22_ = _loc28_ - m_lowerTranslation;
|
||||
_loc4_ = b2Math.b2Max(_loc4_,-_loc22_);
|
||||
_loc22_ = b2Math.b2Clamp(_loc22_ + 0.005,-0.2,0);
|
||||
_loc18_ = -m_motorMass * _loc22_;
|
||||
_loc13_ = m_limitPositionImpulse;
|
||||
m_limitPositionImpulse = b2Math.b2Max(m_limitPositionImpulse + _loc18_,0);
|
||||
_loc18_ = m_limitPositionImpulse - _loc13_;
|
||||
}
|
||||
else if(m_limitState == 2)
|
||||
{
|
||||
_loc22_ = _loc28_ - m_upperTranslation;
|
||||
_loc4_ = b2Math.b2Max(_loc4_,_loc22_);
|
||||
_loc22_ = b2Math.b2Clamp(_loc22_ - 0.005,0,0.2);
|
||||
_loc18_ = -m_motorMass * _loc22_;
|
||||
_loc13_ = m_limitPositionImpulse;
|
||||
m_limitPositionImpulse = b2Math.b2Min(m_limitPositionImpulse + _loc18_,0);
|
||||
_loc18_ = m_limitPositionImpulse - _loc13_;
|
||||
}
|
||||
_loc8_.m_sweep.c.x += _loc5_ * _loc18_ * m_motorJacobian.linear1.x;
|
||||
_loc8_.m_sweep.c.y += _loc5_ * _loc18_ * m_motorJacobian.linear1.y;
|
||||
_loc8_.m_sweep.a += _loc3_ * _loc18_ * m_motorJacobian.angular1;
|
||||
_loc9_.m_sweep.c.x += _loc2_ * _loc18_ * m_motorJacobian.linear2.x;
|
||||
_loc9_.m_sweep.c.y += _loc2_ * _loc18_ * m_motorJacobian.linear2.y;
|
||||
_loc9_.m_sweep.a += _loc1_ * _loc18_ * m_motorJacobian.angular2;
|
||||
_loc8_.SynchronizeTransform();
|
||||
_loc9_.SynchronizeTransform();
|
||||
}
|
||||
return _loc4_ <= 0.005 && _loc20_ <= 0.03490658503988659;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,54 @@
|
||||
package Box2D.Dynamics.Joints
|
||||
{
|
||||
import Box2D.Common.Math.b2Vec2;
|
||||
import Box2D.Dynamics.b2Body;
|
||||
|
||||
public class b2PrismaticJointDef extends b2JointDef
|
||||
{
|
||||
|
||||
public var localAnchor1:b2Vec2 = new b2Vec2();
|
||||
|
||||
public var localAnchor2:b2Vec2 = new b2Vec2();
|
||||
|
||||
public var localAxis1:b2Vec2 = new b2Vec2();
|
||||
|
||||
public var referenceAngle:Number;
|
||||
|
||||
public var enableLimit:Boolean;
|
||||
|
||||
public var lowerTranslation:Number;
|
||||
|
||||
public var upperTranslation:Number;
|
||||
|
||||
public var enableMotor:Boolean;
|
||||
|
||||
public var maxMotorForce:Number;
|
||||
|
||||
public var motorSpeed:Number;
|
||||
|
||||
public function b2PrismaticJointDef()
|
||||
{
|
||||
super();
|
||||
type = 2;
|
||||
localAxis1.Set(1,0);
|
||||
referenceAngle = 0;
|
||||
enableLimit = false;
|
||||
lowerTranslation = 0;
|
||||
upperTranslation = 0;
|
||||
enableMotor = false;
|
||||
maxMotorForce = 0;
|
||||
motorSpeed = 0;
|
||||
}
|
||||
|
||||
public function Initialize(param1:b2Body, param2:b2Body, param3:b2Vec2, param4:b2Vec2) : void
|
||||
{
|
||||
body1 = param1;
|
||||
body2 = param2;
|
||||
localAnchor1 = body1.GetLocalPoint(param3);
|
||||
localAnchor2 = body2.GetLocalPoint(param3);
|
||||
localAxis1 = body1.GetLocalVector(param4);
|
||||
referenceAngle = body2.GetAngle() - body1.GetAngle();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,491 @@
|
||||
package Box2D.Dynamics.Joints
|
||||
{
|
||||
import Box2D.Common.Math.b2Mat22;
|
||||
import Box2D.Common.Math.b2Math;
|
||||
import Box2D.Common.Math.b2Vec2;
|
||||
import Box2D.Dynamics.b2Body;
|
||||
import Box2D.Dynamics.b2TimeStep;
|
||||
|
||||
public class b2PulleyJoint extends b2Joint
|
||||
{
|
||||
|
||||
public static const b2_minPulleyLength:Number = 2;
|
||||
|
||||
public var m_ground:b2Body;
|
||||
|
||||
public var m_groundAnchor1:b2Vec2 = new b2Vec2();
|
||||
|
||||
public var m_groundAnchor2:b2Vec2 = new b2Vec2();
|
||||
|
||||
public var m_localAnchor1:b2Vec2 = new b2Vec2();
|
||||
|
||||
public var m_localAnchor2:b2Vec2 = new b2Vec2();
|
||||
|
||||
public var m_u1:b2Vec2 = new b2Vec2();
|
||||
|
||||
public var m_u2:b2Vec2 = new b2Vec2();
|
||||
|
||||
public var m_constant:Number;
|
||||
|
||||
public var m_ratio:Number;
|
||||
|
||||
public var m_maxLength1:Number;
|
||||
|
||||
public var m_maxLength2:Number;
|
||||
|
||||
public var m_pulleyMass:Number;
|
||||
|
||||
public var m_limitMass1:Number;
|
||||
|
||||
public var m_limitMass2:Number;
|
||||
|
||||
public var m_force:Number;
|
||||
|
||||
public var m_limitForce1:Number;
|
||||
|
||||
public var m_limitForce2:Number;
|
||||
|
||||
public var m_positionImpulse:Number;
|
||||
|
||||
public var m_limitPositionImpulse1:Number;
|
||||
|
||||
public var m_limitPositionImpulse2:Number;
|
||||
|
||||
public var m_state:int;
|
||||
|
||||
public var m_limitState1:int;
|
||||
|
||||
public var m_limitState2:int;
|
||||
|
||||
public function b2PulleyJoint(param1:b2PulleyJointDef)
|
||||
{
|
||||
var _loc4_:* = null;
|
||||
var _loc2_:Number = NaN;
|
||||
var _loc3_:Number = NaN;
|
||||
super(param1);
|
||||
m_ground = m_body1.m_world.m_groundBody;
|
||||
m_groundAnchor1.x = param1.groundAnchor1.x - m_ground.m_xf.position.x;
|
||||
m_groundAnchor1.y = param1.groundAnchor1.y - m_ground.m_xf.position.y;
|
||||
m_groundAnchor2.x = param1.groundAnchor2.x - m_ground.m_xf.position.x;
|
||||
m_groundAnchor2.y = param1.groundAnchor2.y - m_ground.m_xf.position.y;
|
||||
m_localAnchor1.SetV(param1.localAnchor1);
|
||||
m_localAnchor2.SetV(param1.localAnchor2);
|
||||
m_ratio = param1.ratio;
|
||||
m_constant = param1.length1 + m_ratio * param1.length2;
|
||||
m_maxLength1 = b2Math.b2Min(param1.maxLength1,m_constant - m_ratio * 2);
|
||||
m_maxLength2 = b2Math.b2Min(param1.maxLength2,(m_constant - 2) / m_ratio);
|
||||
m_force = 0;
|
||||
m_limitForce1 = 0;
|
||||
m_limitForce2 = 0;
|
||||
}
|
||||
|
||||
override public function GetAnchor1() : b2Vec2
|
||||
{
|
||||
return m_body1.GetWorldPoint(m_localAnchor1);
|
||||
}
|
||||
|
||||
override public function GetAnchor2() : b2Vec2
|
||||
{
|
||||
return m_body2.GetWorldPoint(m_localAnchor2);
|
||||
}
|
||||
|
||||
override public function GetReactionForce() : b2Vec2
|
||||
{
|
||||
var _loc1_:b2Vec2 = m_u2.Copy();
|
||||
_loc1_.Multiply(m_force);
|
||||
return _loc1_;
|
||||
}
|
||||
|
||||
override public function GetReactionTorque() : Number
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
public function GetGroundAnchor1() : b2Vec2
|
||||
{
|
||||
var _loc1_:b2Vec2 = m_ground.m_xf.position.Copy();
|
||||
_loc1_.Add(m_groundAnchor1);
|
||||
return _loc1_;
|
||||
}
|
||||
|
||||
public function GetGroundAnchor2() : b2Vec2
|
||||
{
|
||||
var _loc1_:b2Vec2 = m_ground.m_xf.position.Copy();
|
||||
_loc1_.Add(m_groundAnchor2);
|
||||
return _loc1_;
|
||||
}
|
||||
|
||||
public function GetLength1() : Number
|
||||
{
|
||||
var _loc1_:b2Vec2 = m_body1.GetWorldPoint(m_localAnchor1);
|
||||
var _loc3_:Number = m_ground.m_xf.position.x + m_groundAnchor1.x;
|
||||
var _loc5_:Number = m_ground.m_xf.position.y + m_groundAnchor1.y;
|
||||
var _loc2_:Number = _loc1_.x - _loc3_;
|
||||
var _loc4_:Number = _loc1_.y - _loc5_;
|
||||
return Math.sqrt(_loc2_ * _loc2_ + _loc4_ * _loc4_);
|
||||
}
|
||||
|
||||
public function GetLength2() : Number
|
||||
{
|
||||
var _loc1_:b2Vec2 = m_body2.GetWorldPoint(m_localAnchor2);
|
||||
var _loc3_:Number = m_ground.m_xf.position.x + m_groundAnchor2.x;
|
||||
var _loc5_:Number = m_ground.m_xf.position.y + m_groundAnchor2.y;
|
||||
var _loc2_:Number = _loc1_.x - _loc3_;
|
||||
var _loc4_:Number = _loc1_.y - _loc5_;
|
||||
return Math.sqrt(_loc2_ * _loc2_ + _loc4_ * _loc4_);
|
||||
}
|
||||
|
||||
public function GetRatio() : Number
|
||||
{
|
||||
return m_ratio;
|
||||
}
|
||||
|
||||
override public function InitVelocityConstraints(param1:b2TimeStep) : void
|
||||
{
|
||||
var _loc22_:b2Mat22 = null;
|
||||
var _loc6_:Number = NaN;
|
||||
var _loc12_:Number = NaN;
|
||||
var _loc20_:Number = NaN;
|
||||
var _loc19_:Number = NaN;
|
||||
var _loc3_:b2Body = m_body1;
|
||||
var _loc4_:b2Body = m_body2;
|
||||
_loc22_ = _loc3_.m_xf.R;
|
||||
var _loc21_:Number = m_localAnchor1.x - _loc3_.m_sweep.localCenter.x;
|
||||
var _loc25_:Number = m_localAnchor1.y - _loc3_.m_sweep.localCenter.y;
|
||||
var _loc14_:Number = _loc22_.col1.x * _loc21_ + _loc22_.col2.x * _loc25_;
|
||||
_loc25_ = _loc22_.col1.y * _loc21_ + _loc22_.col2.y * _loc25_;
|
||||
_loc21_ = _loc14_;
|
||||
_loc22_ = _loc4_.m_xf.R;
|
||||
var _loc10_:Number = m_localAnchor2.x - _loc4_.m_sweep.localCenter.x;
|
||||
var _loc8_:Number = m_localAnchor2.y - _loc4_.m_sweep.localCenter.y;
|
||||
_loc14_ = _loc22_.col1.x * _loc10_ + _loc22_.col2.x * _loc8_;
|
||||
_loc8_ = _loc22_.col1.y * _loc10_ + _loc22_.col2.y * _loc8_;
|
||||
_loc10_ = _loc14_;
|
||||
var _loc18_:Number = _loc3_.m_sweep.c.x + _loc21_;
|
||||
var _loc23_:Number = _loc3_.m_sweep.c.y + _loc25_;
|
||||
var _loc7_:Number = _loc4_.m_sweep.c.x + _loc10_;
|
||||
var _loc5_:Number = _loc4_.m_sweep.c.y + _loc8_;
|
||||
var _loc26_:Number = m_ground.m_xf.position.x + m_groundAnchor1.x;
|
||||
var _loc24_:Number = m_ground.m_xf.position.y + m_groundAnchor1.y;
|
||||
var _loc9_:Number = m_ground.m_xf.position.x + m_groundAnchor2.x;
|
||||
var _loc13_:Number = m_ground.m_xf.position.y + m_groundAnchor2.y;
|
||||
m_u1.Set(_loc18_ - _loc26_,_loc23_ - _loc24_);
|
||||
m_u2.Set(_loc7_ - _loc9_,_loc5_ - _loc13_);
|
||||
var _loc16_:Number = m_u1.Length();
|
||||
var _loc17_:Number = m_u2.Length();
|
||||
if(_loc16_ > 0.005)
|
||||
{
|
||||
m_u1.Multiply(1 / _loc16_);
|
||||
}
|
||||
else
|
||||
{
|
||||
m_u1.SetZero();
|
||||
}
|
||||
if(_loc17_ > 0.005)
|
||||
{
|
||||
m_u2.Multiply(1 / _loc17_);
|
||||
}
|
||||
else
|
||||
{
|
||||
m_u2.SetZero();
|
||||
}
|
||||
var _loc2_:Number = m_constant - _loc16_ - m_ratio * _loc17_;
|
||||
if(_loc2_ > 0)
|
||||
{
|
||||
m_state = 0;
|
||||
m_force = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
m_state = 2;
|
||||
m_positionImpulse = 0;
|
||||
}
|
||||
if(_loc16_ < m_maxLength1)
|
||||
{
|
||||
m_limitState1 = 0;
|
||||
m_limitForce1 = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
m_limitState1 = 2;
|
||||
m_limitPositionImpulse1 = 0;
|
||||
}
|
||||
if(_loc17_ < m_maxLength2)
|
||||
{
|
||||
m_limitState2 = 0;
|
||||
m_limitForce2 = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
m_limitState2 = 2;
|
||||
m_limitPositionImpulse2 = 0;
|
||||
}
|
||||
var _loc11_:Number = _loc21_ * m_u1.y - _loc25_ * m_u1.x;
|
||||
var _loc15_:Number = _loc10_ * m_u2.y - _loc8_ * m_u2.x;
|
||||
m_limitMass1 = _loc3_.m_invMass + _loc3_.m_invI * _loc11_ * _loc11_;
|
||||
m_limitMass2 = _loc4_.m_invMass + _loc4_.m_invI * _loc15_ * _loc15_;
|
||||
m_pulleyMass = m_limitMass1 + m_ratio * m_ratio * m_limitMass2;
|
||||
m_limitMass1 = 1 / m_limitMass1;
|
||||
m_limitMass2 = 1 / m_limitMass2;
|
||||
m_pulleyMass = 1 / m_pulleyMass;
|
||||
if(param1.warmStarting)
|
||||
{
|
||||
_loc6_ = param1.dt * (-m_force - m_limitForce1) * m_u1.x;
|
||||
_loc12_ = param1.dt * (-m_force - m_limitForce1) * m_u1.y;
|
||||
_loc20_ = param1.dt * (-m_ratio * m_force - m_limitForce2) * m_u2.x;
|
||||
_loc19_ = param1.dt * (-m_ratio * m_force - m_limitForce2) * m_u2.y;
|
||||
_loc3_.m_linearVelocity.x += _loc3_.m_invMass * _loc6_;
|
||||
_loc3_.m_linearVelocity.y += _loc3_.m_invMass * _loc12_;
|
||||
_loc3_.m_angularVelocity += _loc3_.m_invI * (_loc21_ * _loc12_ - _loc25_ * _loc6_);
|
||||
_loc4_.m_linearVelocity.x += _loc4_.m_invMass * _loc20_;
|
||||
_loc4_.m_linearVelocity.y += _loc4_.m_invMass * _loc19_;
|
||||
_loc4_.m_angularVelocity += _loc4_.m_invI * (_loc10_ * _loc19_ - _loc8_ * _loc20_);
|
||||
}
|
||||
else
|
||||
{
|
||||
m_force = 0;
|
||||
m_limitForce1 = 0;
|
||||
m_limitForce2 = 0;
|
||||
}
|
||||
}
|
||||
|
||||
override public function SolveVelocityConstraints(param1:b2TimeStep) : void
|
||||
{
|
||||
var _loc11_:b2Mat22 = null;
|
||||
var _loc17_:Number = NaN;
|
||||
var _loc20_:Number = NaN;
|
||||
var _loc19_:Number = NaN;
|
||||
var _loc18_:Number = NaN;
|
||||
var _loc6_:Number = NaN;
|
||||
var _loc13_:Number = NaN;
|
||||
var _loc8_:Number = NaN;
|
||||
var _loc7_:Number = NaN;
|
||||
var _loc14_:Number = NaN;
|
||||
var _loc15_:Number = NaN;
|
||||
var _loc5_:Number = NaN;
|
||||
var _loc3_:b2Body = m_body1;
|
||||
var _loc4_:b2Body = m_body2;
|
||||
_loc11_ = _loc3_.m_xf.R;
|
||||
var _loc9_:Number = m_localAnchor1.x - _loc3_.m_sweep.localCenter.x;
|
||||
var _loc16_:Number = m_localAnchor1.y - _loc3_.m_sweep.localCenter.y;
|
||||
var _loc2_:Number = _loc11_.col1.x * _loc9_ + _loc11_.col2.x * _loc16_;
|
||||
_loc16_ = _loc11_.col1.y * _loc9_ + _loc11_.col2.y * _loc16_;
|
||||
_loc9_ = _loc2_;
|
||||
_loc11_ = _loc4_.m_xf.R;
|
||||
var _loc12_:Number = m_localAnchor2.x - _loc4_.m_sweep.localCenter.x;
|
||||
var _loc10_:Number = m_localAnchor2.y - _loc4_.m_sweep.localCenter.y;
|
||||
_loc2_ = _loc11_.col1.x * _loc12_ + _loc11_.col2.x * _loc10_;
|
||||
_loc10_ = _loc11_.col1.y * _loc12_ + _loc11_.col2.y * _loc10_;
|
||||
_loc12_ = _loc2_;
|
||||
if(m_state == 2)
|
||||
{
|
||||
_loc17_ = _loc3_.m_linearVelocity.x + -_loc3_.m_angularVelocity * _loc16_;
|
||||
_loc20_ = _loc3_.m_linearVelocity.y + _loc3_.m_angularVelocity * _loc9_;
|
||||
_loc19_ = _loc4_.m_linearVelocity.x + -_loc4_.m_angularVelocity * _loc10_;
|
||||
_loc18_ = _loc4_.m_linearVelocity.y + _loc4_.m_angularVelocity * _loc12_;
|
||||
_loc14_ = -(m_u1.x * _loc17_ + m_u1.y * _loc20_) - m_ratio * (m_u2.x * _loc19_ + m_u2.y * _loc18_);
|
||||
_loc15_ = -param1.inv_dt * m_pulleyMass * _loc14_;
|
||||
_loc5_ = m_force;
|
||||
m_force = b2Math.b2Max(0,m_force + _loc15_);
|
||||
_loc15_ = m_force - _loc5_;
|
||||
_loc6_ = -param1.dt * _loc15_ * m_u1.x;
|
||||
_loc13_ = -param1.dt * _loc15_ * m_u1.y;
|
||||
_loc8_ = -param1.dt * m_ratio * _loc15_ * m_u2.x;
|
||||
_loc7_ = -param1.dt * m_ratio * _loc15_ * m_u2.y;
|
||||
_loc3_.m_linearVelocity.x += _loc3_.m_invMass * _loc6_;
|
||||
_loc3_.m_linearVelocity.y += _loc3_.m_invMass * _loc13_;
|
||||
_loc3_.m_angularVelocity += _loc3_.m_invI * (_loc9_ * _loc13_ - _loc16_ * _loc6_);
|
||||
_loc4_.m_linearVelocity.x += _loc4_.m_invMass * _loc8_;
|
||||
_loc4_.m_linearVelocity.y += _loc4_.m_invMass * _loc7_;
|
||||
_loc4_.m_angularVelocity += _loc4_.m_invI * (_loc12_ * _loc7_ - _loc10_ * _loc8_);
|
||||
}
|
||||
if(m_limitState1 == 2)
|
||||
{
|
||||
_loc17_ = _loc3_.m_linearVelocity.x + -_loc3_.m_angularVelocity * _loc16_;
|
||||
_loc20_ = _loc3_.m_linearVelocity.y + _loc3_.m_angularVelocity * _loc9_;
|
||||
_loc14_ = -(m_u1.x * _loc17_ + m_u1.y * _loc20_);
|
||||
_loc15_ = -param1.inv_dt * m_limitMass1 * _loc14_;
|
||||
_loc5_ = m_limitForce1;
|
||||
m_limitForce1 = b2Math.b2Max(0,m_limitForce1 + _loc15_);
|
||||
_loc15_ = m_limitForce1 - _loc5_;
|
||||
_loc6_ = -param1.dt * _loc15_ * m_u1.x;
|
||||
_loc13_ = -param1.dt * _loc15_ * m_u1.y;
|
||||
_loc3_.m_linearVelocity.x += _loc3_.m_invMass * _loc6_;
|
||||
_loc3_.m_linearVelocity.y += _loc3_.m_invMass * _loc13_;
|
||||
_loc3_.m_angularVelocity += _loc3_.m_invI * (_loc9_ * _loc13_ - _loc16_ * _loc6_);
|
||||
}
|
||||
if(m_limitState2 == 2)
|
||||
{
|
||||
_loc19_ = _loc4_.m_linearVelocity.x + -_loc4_.m_angularVelocity * _loc10_;
|
||||
_loc18_ = _loc4_.m_linearVelocity.y + _loc4_.m_angularVelocity * _loc12_;
|
||||
_loc14_ = -(m_u2.x * _loc19_ + m_u2.y * _loc18_);
|
||||
_loc15_ = -param1.inv_dt * m_limitMass2 * _loc14_;
|
||||
_loc5_ = m_limitForce2;
|
||||
m_limitForce2 = b2Math.b2Max(0,m_limitForce2 + _loc15_);
|
||||
_loc15_ = m_limitForce2 - _loc5_;
|
||||
_loc8_ = -param1.dt * _loc15_ * m_u2.x;
|
||||
_loc7_ = -param1.dt * _loc15_ * m_u2.y;
|
||||
_loc4_.m_linearVelocity.x += _loc4_.m_invMass * _loc8_;
|
||||
_loc4_.m_linearVelocity.y += _loc4_.m_invMass * _loc7_;
|
||||
_loc4_.m_angularVelocity += _loc4_.m_invI * (_loc12_ * _loc7_ - _loc10_ * _loc8_);
|
||||
}
|
||||
}
|
||||
|
||||
override public function SolvePositionConstraints() : Boolean
|
||||
{
|
||||
var _loc14_:b2Mat22 = null;
|
||||
var _loc12_:Number = NaN;
|
||||
var _loc22_:Number = NaN;
|
||||
var _loc15_:Number = NaN;
|
||||
var _loc13_:Number = NaN;
|
||||
var _loc8_:Number = NaN;
|
||||
var _loc16_:Number = NaN;
|
||||
var _loc10_:Number = NaN;
|
||||
var _loc9_:Number = NaN;
|
||||
var _loc6_:Number = NaN;
|
||||
var _loc7_:Number = NaN;
|
||||
var _loc1_:Number = NaN;
|
||||
var _loc18_:Number = NaN;
|
||||
var _loc19_:Number = NaN;
|
||||
var _loc23_:Number = NaN;
|
||||
var _loc3_:Number = NaN;
|
||||
var _loc4_:b2Body = m_body1;
|
||||
var _loc5_:b2Body = m_body2;
|
||||
var _loc20_:Number = m_ground.m_xf.position.x + m_groundAnchor1.x;
|
||||
var _loc17_:Number = m_ground.m_xf.position.y + m_groundAnchor1.y;
|
||||
var _loc11_:Number = m_ground.m_xf.position.x + m_groundAnchor2.x;
|
||||
var _loc21_:Number = m_ground.m_xf.position.y + m_groundAnchor2.y;
|
||||
var _loc2_:Number = 0;
|
||||
if(m_state == 2)
|
||||
{
|
||||
_loc14_ = _loc4_.m_xf.R;
|
||||
_loc12_ = m_localAnchor1.x - _loc4_.m_sweep.localCenter.x;
|
||||
_loc22_ = m_localAnchor1.y - _loc4_.m_sweep.localCenter.y;
|
||||
_loc3_ = _loc14_.col1.x * _loc12_ + _loc14_.col2.x * _loc22_;
|
||||
_loc22_ = _loc14_.col1.y * _loc12_ + _loc14_.col2.y * _loc22_;
|
||||
_loc12_ = _loc3_;
|
||||
_loc14_ = _loc5_.m_xf.R;
|
||||
_loc15_ = m_localAnchor2.x - _loc5_.m_sweep.localCenter.x;
|
||||
_loc13_ = m_localAnchor2.y - _loc5_.m_sweep.localCenter.y;
|
||||
_loc3_ = _loc14_.col1.x * _loc15_ + _loc14_.col2.x * _loc13_;
|
||||
_loc13_ = _loc14_.col1.y * _loc15_ + _loc14_.col2.y * _loc13_;
|
||||
_loc15_ = _loc3_;
|
||||
_loc8_ = _loc4_.m_sweep.c.x + _loc12_;
|
||||
_loc16_ = _loc4_.m_sweep.c.y + _loc22_;
|
||||
_loc10_ = _loc5_.m_sweep.c.x + _loc15_;
|
||||
_loc9_ = _loc5_.m_sweep.c.y + _loc13_;
|
||||
m_u1.Set(_loc8_ - _loc20_,_loc16_ - _loc17_);
|
||||
m_u2.Set(_loc10_ - _loc11_,_loc9_ - _loc21_);
|
||||
_loc6_ = m_u1.Length();
|
||||
_loc7_ = m_u2.Length();
|
||||
if(_loc6_ > 0.005)
|
||||
{
|
||||
m_u1.Multiply(1 / _loc6_);
|
||||
}
|
||||
else
|
||||
{
|
||||
m_u1.SetZero();
|
||||
}
|
||||
if(_loc7_ > 0.005)
|
||||
{
|
||||
m_u2.Multiply(1 / _loc7_);
|
||||
}
|
||||
else
|
||||
{
|
||||
m_u2.SetZero();
|
||||
}
|
||||
_loc1_ = m_constant - _loc6_ - m_ratio * _loc7_;
|
||||
_loc2_ = b2Math.b2Max(_loc2_,-_loc1_);
|
||||
_loc1_ = b2Math.b2Clamp(_loc1_ + 0.005,-0.2,0);
|
||||
_loc18_ = -m_pulleyMass * _loc1_;
|
||||
_loc19_ = m_positionImpulse;
|
||||
m_positionImpulse = b2Math.b2Max(0,m_positionImpulse + _loc18_);
|
||||
_loc18_ = m_positionImpulse - _loc19_;
|
||||
_loc8_ = -_loc18_ * m_u1.x;
|
||||
_loc16_ = -_loc18_ * m_u1.y;
|
||||
_loc10_ = -m_ratio * _loc18_ * m_u2.x;
|
||||
_loc9_ = -m_ratio * _loc18_ * m_u2.y;
|
||||
_loc4_.m_sweep.c.x += _loc4_.m_invMass * _loc8_;
|
||||
_loc4_.m_sweep.c.y += _loc4_.m_invMass * _loc16_;
|
||||
_loc4_.m_sweep.a += _loc4_.m_invI * (_loc12_ * _loc16_ - _loc22_ * _loc8_);
|
||||
_loc5_.m_sweep.c.x += _loc5_.m_invMass * _loc10_;
|
||||
_loc5_.m_sweep.c.y += _loc5_.m_invMass * _loc9_;
|
||||
_loc5_.m_sweep.a += _loc5_.m_invI * (_loc15_ * _loc9_ - _loc13_ * _loc10_);
|
||||
_loc4_.SynchronizeTransform();
|
||||
_loc5_.SynchronizeTransform();
|
||||
}
|
||||
if(m_limitState1 == 2)
|
||||
{
|
||||
_loc14_ = _loc4_.m_xf.R;
|
||||
_loc12_ = m_localAnchor1.x - _loc4_.m_sweep.localCenter.x;
|
||||
_loc22_ = m_localAnchor1.y - _loc4_.m_sweep.localCenter.y;
|
||||
_loc3_ = _loc14_.col1.x * _loc12_ + _loc14_.col2.x * _loc22_;
|
||||
_loc22_ = _loc14_.col1.y * _loc12_ + _loc14_.col2.y * _loc22_;
|
||||
_loc12_ = _loc3_;
|
||||
_loc8_ = _loc4_.m_sweep.c.x + _loc12_;
|
||||
_loc16_ = _loc4_.m_sweep.c.y + _loc22_;
|
||||
m_u1.Set(_loc8_ - _loc20_,_loc16_ - _loc17_);
|
||||
_loc6_ = m_u1.Length();
|
||||
if(_loc6_ > 0.005)
|
||||
{
|
||||
m_u1.x *= 1 / _loc6_;
|
||||
m_u1.y *= 1 / _loc6_;
|
||||
}
|
||||
else
|
||||
{
|
||||
m_u1.SetZero();
|
||||
}
|
||||
_loc1_ = m_maxLength1 - _loc6_;
|
||||
_loc2_ = b2Math.b2Max(_loc2_,-_loc1_);
|
||||
_loc1_ = b2Math.b2Clamp(_loc1_ + 0.005,-0.2,0);
|
||||
_loc18_ = -m_limitMass1 * _loc1_;
|
||||
_loc23_ = m_limitPositionImpulse1;
|
||||
m_limitPositionImpulse1 = b2Math.b2Max(0,m_limitPositionImpulse1 + _loc18_);
|
||||
_loc18_ = m_limitPositionImpulse1 - _loc23_;
|
||||
_loc8_ = -_loc18_ * m_u1.x;
|
||||
_loc16_ = -_loc18_ * m_u1.y;
|
||||
_loc4_.m_sweep.c.x += _loc4_.m_invMass * _loc8_;
|
||||
_loc4_.m_sweep.c.y += _loc4_.m_invMass * _loc16_;
|
||||
_loc4_.m_sweep.a += _loc4_.m_invI * (_loc12_ * _loc16_ - _loc22_ * _loc8_);
|
||||
_loc4_.SynchronizeTransform();
|
||||
}
|
||||
if(m_limitState2 == 2)
|
||||
{
|
||||
_loc14_ = _loc5_.m_xf.R;
|
||||
_loc15_ = m_localAnchor2.x - _loc5_.m_sweep.localCenter.x;
|
||||
_loc13_ = m_localAnchor2.y - _loc5_.m_sweep.localCenter.y;
|
||||
_loc3_ = _loc14_.col1.x * _loc15_ + _loc14_.col2.x * _loc13_;
|
||||
_loc13_ = _loc14_.col1.y * _loc15_ + _loc14_.col2.y * _loc13_;
|
||||
_loc15_ = _loc3_;
|
||||
_loc10_ = _loc5_.m_sweep.c.x + _loc15_;
|
||||
_loc9_ = _loc5_.m_sweep.c.y + _loc13_;
|
||||
m_u2.Set(_loc10_ - _loc11_,_loc9_ - _loc21_);
|
||||
_loc7_ = m_u2.Length();
|
||||
if(_loc7_ > 0.005)
|
||||
{
|
||||
m_u2.x *= 1 / _loc7_;
|
||||
m_u2.y *= 1 / _loc7_;
|
||||
}
|
||||
else
|
||||
{
|
||||
m_u2.SetZero();
|
||||
}
|
||||
_loc1_ = m_maxLength2 - _loc7_;
|
||||
_loc2_ = b2Math.b2Max(_loc2_,-_loc1_);
|
||||
_loc1_ = b2Math.b2Clamp(_loc1_ + 0.005,-0.2,0);
|
||||
_loc18_ = -m_limitMass2 * _loc1_;
|
||||
_loc23_ = m_limitPositionImpulse2;
|
||||
m_limitPositionImpulse2 = b2Math.b2Max(0,m_limitPositionImpulse2 + _loc18_);
|
||||
_loc18_ = m_limitPositionImpulse2 - _loc23_;
|
||||
_loc10_ = -_loc18_ * m_u2.x;
|
||||
_loc9_ = -_loc18_ * m_u2.y;
|
||||
_loc5_.m_sweep.c.x += _loc5_.m_invMass * _loc10_;
|
||||
_loc5_.m_sweep.c.y += _loc5_.m_invMass * _loc9_;
|
||||
_loc5_.m_sweep.a += _loc5_.m_invI * (_loc15_ * _loc9_ - _loc13_ * _loc10_);
|
||||
_loc5_.SynchronizeTransform();
|
||||
}
|
||||
return _loc2_ < 0.005;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,64 @@
|
||||
package Box2D.Dynamics.Joints
|
||||
{
|
||||
import Box2D.Common.Math.b2Vec2;
|
||||
import Box2D.Dynamics.b2Body;
|
||||
|
||||
public class b2PulleyJointDef extends b2JointDef
|
||||
{
|
||||
|
||||
public var groundAnchor1:b2Vec2 = new b2Vec2();
|
||||
|
||||
public var groundAnchor2:b2Vec2 = new b2Vec2();
|
||||
|
||||
public var localAnchor1:b2Vec2 = new b2Vec2();
|
||||
|
||||
public var localAnchor2:b2Vec2 = new b2Vec2();
|
||||
|
||||
public var length1:Number;
|
||||
|
||||
public var maxLength1:Number;
|
||||
|
||||
public var length2:Number;
|
||||
|
||||
public var maxLength2:Number;
|
||||
|
||||
public var ratio:Number;
|
||||
|
||||
public function b2PulleyJointDef()
|
||||
{
|
||||
super();
|
||||
type = 4;
|
||||
groundAnchor1.Set(-1,1);
|
||||
groundAnchor2.Set(1,1);
|
||||
localAnchor1.Set(-1,0);
|
||||
localAnchor2.Set(1,0);
|
||||
length1 = 0;
|
||||
maxLength1 = 0;
|
||||
length2 = 0;
|
||||
maxLength2 = 0;
|
||||
ratio = 1;
|
||||
collideConnected = true;
|
||||
}
|
||||
|
||||
public function Initialize(param1:b2Body, param2:b2Body, param3:b2Vec2, param4:b2Vec2, param5:b2Vec2, param6:b2Vec2, param7:Number) : void
|
||||
{
|
||||
body1 = param1;
|
||||
body2 = param2;
|
||||
groundAnchor1.SetV(param3);
|
||||
groundAnchor2.SetV(param4);
|
||||
localAnchor1 = body1.GetLocalPoint(param5);
|
||||
localAnchor2 = body2.GetLocalPoint(param6);
|
||||
var _loc9_:Number = param5.x - param3.x;
|
||||
var _loc12_:Number = param5.y - param3.y;
|
||||
length1 = Math.sqrt(_loc9_ * _loc9_ + _loc12_ * _loc12_);
|
||||
var _loc11_:Number = param6.x - param4.x;
|
||||
var _loc10_:Number = param6.y - param4.y;
|
||||
length2 = Math.sqrt(_loc11_ * _loc11_ + _loc10_ * _loc10_);
|
||||
ratio = param7;
|
||||
var _loc8_:Number = length1 + ratio * length2;
|
||||
maxLength1 = _loc8_ - ratio * 2;
|
||||
maxLength2 = (_loc8_ - 2) / ratio;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,425 @@
|
||||
package Box2D.Dynamics.Joints
|
||||
{
|
||||
import Box2D.Common.Math.b2Mat22;
|
||||
import Box2D.Common.Math.b2Math;
|
||||
import Box2D.Common.Math.b2Vec2;
|
||||
import Box2D.Dynamics.b2Body;
|
||||
import Box2D.Dynamics.b2TimeStep;
|
||||
|
||||
public class b2RevoluteJoint extends b2Joint
|
||||
{
|
||||
|
||||
public static var tImpulse:b2Vec2 = new b2Vec2();
|
||||
|
||||
private var K:b2Mat22 = new b2Mat22();
|
||||
|
||||
private var K1:b2Mat22 = new b2Mat22();
|
||||
|
||||
private var K2:b2Mat22 = new b2Mat22();
|
||||
|
||||
private var K3:b2Mat22 = new b2Mat22();
|
||||
|
||||
public var m_localAnchor1:b2Vec2 = new b2Vec2();
|
||||
|
||||
public var m_localAnchor2:b2Vec2 = new b2Vec2();
|
||||
|
||||
public var m_pivotForce:b2Vec2 = new b2Vec2();
|
||||
|
||||
public var m_motorForce:Number;
|
||||
|
||||
public var m_limitForce:Number;
|
||||
|
||||
public var m_limitPositionImpulse:Number;
|
||||
|
||||
public var m_pivotMass:b2Mat22 = new b2Mat22();
|
||||
|
||||
public var m_motorMass:Number;
|
||||
|
||||
public var m_enableMotor:Boolean;
|
||||
|
||||
public var m_maxMotorTorque:Number;
|
||||
|
||||
public var m_motorSpeed:Number;
|
||||
|
||||
public var m_enableLimit:Boolean;
|
||||
|
||||
public var m_referenceAngle:Number;
|
||||
|
||||
public var m_lowerAngle:Number;
|
||||
|
||||
public var m_upperAngle:Number;
|
||||
|
||||
public var m_limitState:int;
|
||||
|
||||
public function b2RevoluteJoint(param1:b2RevoluteJointDef)
|
||||
{
|
||||
super(param1);
|
||||
m_localAnchor1.SetV(param1.localAnchor1);
|
||||
m_localAnchor2.SetV(param1.localAnchor2);
|
||||
m_referenceAngle = param1.referenceAngle;
|
||||
m_pivotForce.Set(0,0);
|
||||
m_motorForce = 0;
|
||||
m_limitForce = 0;
|
||||
m_limitPositionImpulse = 0;
|
||||
m_lowerAngle = param1.lowerAngle;
|
||||
m_upperAngle = param1.upperAngle;
|
||||
m_maxMotorTorque = param1.maxMotorTorque;
|
||||
m_motorSpeed = param1.motorSpeed;
|
||||
m_enableLimit = param1.enableLimit;
|
||||
m_enableMotor = param1.enableMotor;
|
||||
}
|
||||
|
||||
override public function GetAnchor1() : b2Vec2
|
||||
{
|
||||
return m_body1.GetWorldPoint(m_localAnchor1);
|
||||
}
|
||||
|
||||
override public function GetAnchor2() : b2Vec2
|
||||
{
|
||||
return m_body2.GetWorldPoint(m_localAnchor2);
|
||||
}
|
||||
|
||||
override public function GetReactionForce() : b2Vec2
|
||||
{
|
||||
return m_pivotForce;
|
||||
}
|
||||
|
||||
override public function GetReactionTorque() : Number
|
||||
{
|
||||
return m_limitForce;
|
||||
}
|
||||
|
||||
public function GetJointAngle() : Number
|
||||
{
|
||||
return m_body2.m_sweep.a - m_body1.m_sweep.a - m_referenceAngle;
|
||||
}
|
||||
|
||||
public function GetJointSpeed() : Number
|
||||
{
|
||||
return m_body2.m_angularVelocity - m_body1.m_angularVelocity;
|
||||
}
|
||||
|
||||
public function IsLimitEnabled() : Boolean
|
||||
{
|
||||
return m_enableLimit;
|
||||
}
|
||||
|
||||
public function EnableLimit(param1:Boolean) : void
|
||||
{
|
||||
m_enableLimit = param1;
|
||||
}
|
||||
|
||||
public function GetLowerLimit() : Number
|
||||
{
|
||||
return m_lowerAngle;
|
||||
}
|
||||
|
||||
public function GetUpperLimit() : Number
|
||||
{
|
||||
return m_upperAngle;
|
||||
}
|
||||
|
||||
public function SetLimits(param1:Number, param2:Number) : void
|
||||
{
|
||||
m_lowerAngle = param1;
|
||||
m_upperAngle = param2;
|
||||
}
|
||||
|
||||
public function IsMotorEnabled() : Boolean
|
||||
{
|
||||
return m_enableMotor;
|
||||
}
|
||||
|
||||
public function EnableMotor(param1:Boolean) : void
|
||||
{
|
||||
m_enableMotor = param1;
|
||||
}
|
||||
|
||||
public function SetMotorSpeed(param1:Number) : void
|
||||
{
|
||||
m_motorSpeed = param1;
|
||||
}
|
||||
|
||||
public function GetMotorSpeed() : Number
|
||||
{
|
||||
return m_motorSpeed;
|
||||
}
|
||||
|
||||
public function SetMaxMotorTorque(param1:Number) : void
|
||||
{
|
||||
m_maxMotorTorque = param1;
|
||||
}
|
||||
|
||||
public function GetMotorTorque() : Number
|
||||
{
|
||||
return m_motorForce;
|
||||
}
|
||||
|
||||
override public function InitVelocityConstraints(param1:b2TimeStep) : void
|
||||
{
|
||||
var _loc11_:b2Mat22 = null;
|
||||
var _loc6_:Number = NaN;
|
||||
var _loc14_:Number = NaN;
|
||||
var _loc7_:b2Body = m_body1;
|
||||
var _loc8_:b2Body = m_body2;
|
||||
_loc11_ = _loc7_.m_xf.R;
|
||||
var _loc9_:Number = m_localAnchor1.x - _loc7_.m_sweep.localCenter.x;
|
||||
var _loc13_:Number = m_localAnchor1.y - _loc7_.m_sweep.localCenter.y;
|
||||
_loc6_ = _loc11_.col1.x * _loc9_ + _loc11_.col2.x * _loc13_;
|
||||
_loc13_ = _loc11_.col1.y * _loc9_ + _loc11_.col2.y * _loc13_;
|
||||
_loc9_ = _loc6_;
|
||||
_loc11_ = _loc8_.m_xf.R;
|
||||
var _loc12_:Number = m_localAnchor2.x - _loc8_.m_sweep.localCenter.x;
|
||||
var _loc10_:Number = m_localAnchor2.y - _loc8_.m_sweep.localCenter.y;
|
||||
_loc6_ = _loc11_.col1.x * _loc12_ + _loc11_.col2.x * _loc10_;
|
||||
_loc10_ = _loc11_.col1.y * _loc12_ + _loc11_.col2.y * _loc10_;
|
||||
_loc12_ = _loc6_;
|
||||
var _loc5_:Number = _loc7_.m_invMass;
|
||||
var _loc3_:Number = _loc8_.m_invMass;
|
||||
var _loc4_:Number = _loc7_.m_invI;
|
||||
var _loc2_:Number = _loc8_.m_invI;
|
||||
K1.col1.x = _loc5_ + _loc3_;
|
||||
K1.col2.x = 0;
|
||||
K1.col1.y = 0;
|
||||
K1.col2.y = _loc5_ + _loc3_;
|
||||
K2.col1.x = _loc4_ * _loc13_ * _loc13_;
|
||||
K2.col2.x = -_loc4_ * _loc9_ * _loc13_;
|
||||
K2.col1.y = -_loc4_ * _loc9_ * _loc13_;
|
||||
K2.col2.y = _loc4_ * _loc9_ * _loc9_;
|
||||
K3.col1.x = _loc2_ * _loc10_ * _loc10_;
|
||||
K3.col2.x = -_loc2_ * _loc12_ * _loc10_;
|
||||
K3.col1.y = -_loc2_ * _loc12_ * _loc10_;
|
||||
K3.col2.y = _loc2_ * _loc12_ * _loc12_;
|
||||
K.SetM(K1);
|
||||
K.AddM(K2);
|
||||
K.AddM(K3);
|
||||
K.Invert(m_pivotMass);
|
||||
m_motorMass = 1 / (_loc4_ + _loc2_);
|
||||
if(m_enableMotor == false)
|
||||
{
|
||||
m_motorForce = 0;
|
||||
}
|
||||
if(m_enableLimit)
|
||||
{
|
||||
_loc14_ = _loc8_.m_sweep.a - _loc7_.m_sweep.a - m_referenceAngle;
|
||||
if(b2Math.b2Abs(m_upperAngle - m_lowerAngle) < 2 * 0.03490658503988659)
|
||||
{
|
||||
m_limitState = 3;
|
||||
}
|
||||
else if(_loc14_ <= m_lowerAngle)
|
||||
{
|
||||
if(m_limitState != 1)
|
||||
{
|
||||
m_limitForce = 0;
|
||||
}
|
||||
m_limitState = 1;
|
||||
}
|
||||
else if(_loc14_ >= m_upperAngle)
|
||||
{
|
||||
if(m_limitState != 2)
|
||||
{
|
||||
m_limitForce = 0;
|
||||
}
|
||||
m_limitState = 2;
|
||||
}
|
||||
else
|
||||
{
|
||||
m_limitState = 0;
|
||||
m_limitForce = 0;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
m_limitForce = 0;
|
||||
}
|
||||
if(param1.warmStarting)
|
||||
{
|
||||
_loc7_.m_linearVelocity.x -= param1.dt * _loc5_ * m_pivotForce.x;
|
||||
_loc7_.m_linearVelocity.y -= param1.dt * _loc5_ * m_pivotForce.y;
|
||||
_loc7_.m_angularVelocity -= param1.dt * _loc4_ * (_loc9_ * m_pivotForce.y - _loc13_ * m_pivotForce.x + m_motorForce + m_limitForce);
|
||||
_loc8_.m_linearVelocity.x += param1.dt * _loc3_ * m_pivotForce.x;
|
||||
_loc8_.m_linearVelocity.y += param1.dt * _loc3_ * m_pivotForce.y;
|
||||
_loc8_.m_angularVelocity += param1.dt * _loc2_ * (_loc12_ * m_pivotForce.y - _loc10_ * m_pivotForce.x + m_motorForce + m_limitForce);
|
||||
}
|
||||
else
|
||||
{
|
||||
m_pivotForce.SetZero();
|
||||
m_motorForce = 0;
|
||||
m_limitForce = 0;
|
||||
}
|
||||
m_limitPositionImpulse = 0;
|
||||
}
|
||||
|
||||
override public function SolveVelocityConstraints(param1:b2TimeStep) : void
|
||||
{
|
||||
var _loc18_:b2Mat22 = null;
|
||||
var _loc3_:Number = NaN;
|
||||
var _loc11_:Number = NaN;
|
||||
var _loc15_:Number = NaN;
|
||||
var _loc13_:Number = NaN;
|
||||
var _loc9_:Number = NaN;
|
||||
var _loc10_:Number = NaN;
|
||||
var _loc6_:Number = NaN;
|
||||
var _loc7_:b2Body = m_body1;
|
||||
var _loc8_:b2Body = m_body2;
|
||||
_loc18_ = _loc7_.m_xf.R;
|
||||
var _loc16_:Number = m_localAnchor1.x - _loc7_.m_sweep.localCenter.x;
|
||||
var _loc20_:Number = m_localAnchor1.y - _loc7_.m_sweep.localCenter.y;
|
||||
_loc3_ = _loc18_.col1.x * _loc16_ + _loc18_.col2.x * _loc20_;
|
||||
_loc20_ = _loc18_.col1.y * _loc16_ + _loc18_.col2.y * _loc20_;
|
||||
_loc16_ = _loc3_;
|
||||
_loc18_ = _loc8_.m_xf.R;
|
||||
var _loc19_:Number = m_localAnchor2.x - _loc8_.m_sweep.localCenter.x;
|
||||
var _loc17_:Number = m_localAnchor2.y - _loc8_.m_sweep.localCenter.y;
|
||||
_loc3_ = _loc18_.col1.x * _loc19_ + _loc18_.col2.x * _loc17_;
|
||||
_loc17_ = _loc18_.col1.y * _loc19_ + _loc18_.col2.y * _loc17_;
|
||||
_loc19_ = _loc3_;
|
||||
var _loc12_:Number = _loc8_.m_linearVelocity.x + -_loc8_.m_angularVelocity * _loc17_ - _loc7_.m_linearVelocity.x - -_loc7_.m_angularVelocity * _loc20_;
|
||||
var _loc14_:Number = _loc8_.m_linearVelocity.y + _loc8_.m_angularVelocity * _loc19_ - _loc7_.m_linearVelocity.y - _loc7_.m_angularVelocity * _loc16_;
|
||||
var _loc21_:Number = -param1.inv_dt * (m_pivotMass.col1.x * _loc12_ + m_pivotMass.col2.x * _loc14_);
|
||||
var _loc2_:Number = -param1.inv_dt * (m_pivotMass.col1.y * _loc12_ + m_pivotMass.col2.y * _loc14_);
|
||||
m_pivotForce.x += _loc21_;
|
||||
m_pivotForce.y += _loc2_;
|
||||
var _loc4_:Number = param1.dt * _loc21_;
|
||||
var _loc5_:Number = param1.dt * _loc2_;
|
||||
_loc7_.m_linearVelocity.x -= _loc7_.m_invMass * _loc4_;
|
||||
_loc7_.m_linearVelocity.y -= _loc7_.m_invMass * _loc5_;
|
||||
_loc7_.m_angularVelocity -= _loc7_.m_invI * (_loc16_ * _loc5_ - _loc20_ * _loc4_);
|
||||
_loc8_.m_linearVelocity.x += _loc8_.m_invMass * _loc4_;
|
||||
_loc8_.m_linearVelocity.y += _loc8_.m_invMass * _loc5_;
|
||||
_loc8_.m_angularVelocity += _loc8_.m_invI * (_loc19_ * _loc5_ - _loc17_ * _loc4_);
|
||||
if(m_enableMotor && m_limitState != 3)
|
||||
{
|
||||
_loc15_ = _loc8_.m_angularVelocity - _loc7_.m_angularVelocity - m_motorSpeed;
|
||||
_loc13_ = -param1.inv_dt * m_motorMass * _loc15_;
|
||||
_loc9_ = m_motorForce;
|
||||
m_motorForce = b2Math.b2Clamp(m_motorForce + _loc13_,-m_maxMotorTorque,m_maxMotorTorque);
|
||||
_loc13_ = m_motorForce - _loc9_;
|
||||
_loc7_.m_angularVelocity -= _loc7_.m_invI * param1.dt * _loc13_;
|
||||
_loc8_.m_angularVelocity += _loc8_.m_invI * param1.dt * _loc13_;
|
||||
}
|
||||
if(m_enableLimit && m_limitState != 0)
|
||||
{
|
||||
_loc10_ = _loc8_.m_angularVelocity - _loc7_.m_angularVelocity;
|
||||
_loc6_ = -param1.inv_dt * m_motorMass * _loc10_;
|
||||
if(m_limitState == 3)
|
||||
{
|
||||
m_limitForce += _loc6_;
|
||||
}
|
||||
else if(m_limitState == 1)
|
||||
{
|
||||
_loc11_ = m_limitForce;
|
||||
m_limitForce = b2Math.b2Max(m_limitForce + _loc6_,0);
|
||||
_loc6_ = m_limitForce - _loc11_;
|
||||
}
|
||||
else if(m_limitState == 2)
|
||||
{
|
||||
_loc11_ = m_limitForce;
|
||||
m_limitForce = b2Math.b2Min(m_limitForce + _loc6_,0);
|
||||
_loc6_ = m_limitForce - _loc11_;
|
||||
}
|
||||
_loc7_.m_angularVelocity -= _loc7_.m_invI * param1.dt * _loc6_;
|
||||
_loc8_.m_angularVelocity += _loc8_.m_invI * param1.dt * _loc6_;
|
||||
}
|
||||
}
|
||||
|
||||
override public function SolvePositionConstraints() : Boolean
|
||||
{
|
||||
var _loc10_:Number = NaN;
|
||||
var _loc21_:Number = NaN;
|
||||
var _loc24_:b2Mat22 = null;
|
||||
var _loc15_:Number = NaN;
|
||||
var _loc16_:Number = NaN;
|
||||
var _loc8_:b2Body = m_body1;
|
||||
var _loc9_:b2Body = m_body2;
|
||||
var _loc3_:Number = 0;
|
||||
_loc24_ = _loc8_.m_xf.R;
|
||||
var _loc23_:Number = m_localAnchor1.x - _loc8_.m_sweep.localCenter.x;
|
||||
var _loc26_:Number = m_localAnchor1.y - _loc8_.m_sweep.localCenter.y;
|
||||
var _loc18_:Number = _loc24_.col1.x * _loc23_ + _loc24_.col2.x * _loc26_;
|
||||
_loc26_ = _loc24_.col1.y * _loc23_ + _loc24_.col2.y * _loc26_;
|
||||
_loc23_ = _loc18_;
|
||||
_loc24_ = _loc9_.m_xf.R;
|
||||
var _loc14_:Number = m_localAnchor2.x - _loc9_.m_sweep.localCenter.x;
|
||||
var _loc13_:Number = m_localAnchor2.y - _loc9_.m_sweep.localCenter.y;
|
||||
_loc18_ = _loc24_.col1.x * _loc14_ + _loc24_.col2.x * _loc13_;
|
||||
_loc13_ = _loc24_.col1.y * _loc14_ + _loc24_.col2.y * _loc13_;
|
||||
_loc14_ = _loc18_;
|
||||
var _loc22_:Number = _loc8_.m_sweep.c.x + _loc23_;
|
||||
var _loc25_:Number = _loc8_.m_sweep.c.y + _loc26_;
|
||||
var _loc12_:Number = _loc9_.m_sweep.c.x + _loc14_;
|
||||
var _loc11_:Number = _loc9_.m_sweep.c.y + _loc13_;
|
||||
var _loc1_:Number = _loc12_ - _loc22_;
|
||||
var _loc4_:Number = _loc11_ - _loc25_;
|
||||
_loc3_ = Math.sqrt(_loc1_ * _loc1_ + _loc4_ * _loc4_);
|
||||
var _loc7_:Number = _loc8_.m_invMass;
|
||||
var _loc5_:Number = _loc9_.m_invMass;
|
||||
var _loc6_:Number = _loc8_.m_invI;
|
||||
var _loc2_:Number = _loc9_.m_invI;
|
||||
K1.col1.x = _loc7_ + _loc5_;
|
||||
K1.col2.x = 0;
|
||||
K1.col1.y = 0;
|
||||
K1.col2.y = _loc7_ + _loc5_;
|
||||
K2.col1.x = _loc6_ * _loc26_ * _loc26_;
|
||||
K2.col2.x = -_loc6_ * _loc23_ * _loc26_;
|
||||
K2.col1.y = -_loc6_ * _loc23_ * _loc26_;
|
||||
K2.col2.y = _loc6_ * _loc23_ * _loc23_;
|
||||
K3.col1.x = _loc2_ * _loc13_ * _loc13_;
|
||||
K3.col2.x = -_loc2_ * _loc14_ * _loc13_;
|
||||
K3.col1.y = -_loc2_ * _loc14_ * _loc13_;
|
||||
K3.col2.y = _loc2_ * _loc14_ * _loc14_;
|
||||
K.SetM(K1);
|
||||
K.AddM(K2);
|
||||
K.AddM(K3);
|
||||
K.Solve(tImpulse,-_loc1_,-_loc4_);
|
||||
var _loc19_:Number = tImpulse.x;
|
||||
var _loc17_:Number = tImpulse.y;
|
||||
_loc8_.m_sweep.c.x -= _loc8_.m_invMass * _loc19_;
|
||||
_loc8_.m_sweep.c.y -= _loc8_.m_invMass * _loc17_;
|
||||
_loc8_.m_sweep.a -= _loc8_.m_invI * (_loc23_ * _loc17_ - _loc26_ * _loc19_);
|
||||
_loc9_.m_sweep.c.x += _loc9_.m_invMass * _loc19_;
|
||||
_loc9_.m_sweep.c.y += _loc9_.m_invMass * _loc17_;
|
||||
_loc9_.m_sweep.a += _loc9_.m_invI * (_loc14_ * _loc17_ - _loc13_ * _loc19_);
|
||||
_loc8_.SynchronizeTransform();
|
||||
_loc9_.SynchronizeTransform();
|
||||
var _loc20_:Number = 0;
|
||||
if(m_enableLimit && m_limitState != 0)
|
||||
{
|
||||
_loc15_ = _loc9_.m_sweep.a - _loc8_.m_sweep.a - m_referenceAngle;
|
||||
_loc16_ = 0;
|
||||
if(m_limitState == 3)
|
||||
{
|
||||
_loc21_ = b2Math.b2Clamp(_loc15_,-0.13962634015954636,0.13962634015954636);
|
||||
_loc16_ = -m_motorMass * _loc21_;
|
||||
_loc20_ = b2Math.b2Abs(_loc21_);
|
||||
}
|
||||
else if(m_limitState == 1)
|
||||
{
|
||||
_loc21_ = _loc15_ - m_lowerAngle;
|
||||
_loc20_ = b2Math.b2Max(0,-_loc21_);
|
||||
_loc21_ = b2Math.b2Clamp(_loc21_ + 0.03490658503988659,-0.13962634015954636,0);
|
||||
_loc16_ = -m_motorMass * _loc21_;
|
||||
_loc10_ = m_limitPositionImpulse;
|
||||
m_limitPositionImpulse = b2Math.b2Max(m_limitPositionImpulse + _loc16_,0);
|
||||
_loc16_ = m_limitPositionImpulse - _loc10_;
|
||||
}
|
||||
else if(m_limitState == 2)
|
||||
{
|
||||
_loc21_ = _loc15_ - m_upperAngle;
|
||||
_loc20_ = b2Math.b2Max(0,_loc21_);
|
||||
_loc21_ = b2Math.b2Clamp(_loc21_ - 0.03490658503988659,0,0.13962634015954636);
|
||||
_loc16_ = -m_motorMass * _loc21_;
|
||||
_loc10_ = m_limitPositionImpulse;
|
||||
m_limitPositionImpulse = b2Math.b2Min(m_limitPositionImpulse + _loc16_,0);
|
||||
_loc16_ = m_limitPositionImpulse - _loc10_;
|
||||
}
|
||||
_loc8_.m_sweep.a -= _loc8_.m_invI * _loc16_;
|
||||
_loc9_.m_sweep.a += _loc9_.m_invI * _loc16_;
|
||||
_loc8_.SynchronizeTransform();
|
||||
_loc9_.SynchronizeTransform();
|
||||
}
|
||||
return _loc3_ <= 0.005 && _loc20_ <= 0.03490658503988659;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,52 @@
|
||||
package Box2D.Dynamics.Joints
|
||||
{
|
||||
import Box2D.Common.Math.b2Vec2;
|
||||
import Box2D.Dynamics.b2Body;
|
||||
|
||||
public class b2RevoluteJointDef extends b2JointDef
|
||||
{
|
||||
|
||||
public var localAnchor1:b2Vec2 = new b2Vec2();
|
||||
|
||||
public var localAnchor2:b2Vec2 = new b2Vec2();
|
||||
|
||||
public var referenceAngle:Number;
|
||||
|
||||
public var enableLimit:Boolean;
|
||||
|
||||
public var lowerAngle:Number;
|
||||
|
||||
public var upperAngle:Number;
|
||||
|
||||
public var enableMotor:Boolean;
|
||||
|
||||
public var motorSpeed:Number;
|
||||
|
||||
public var maxMotorTorque:Number;
|
||||
|
||||
public function b2RevoluteJointDef()
|
||||
{
|
||||
super();
|
||||
type = 1;
|
||||
localAnchor1.Set(0,0);
|
||||
localAnchor2.Set(0,0);
|
||||
referenceAngle = 0;
|
||||
lowerAngle = 0;
|
||||
upperAngle = 0;
|
||||
maxMotorTorque = 0;
|
||||
motorSpeed = 0;
|
||||
enableLimit = false;
|
||||
enableMotor = false;
|
||||
}
|
||||
|
||||
public function Initialize(param1:b2Body, param2:b2Body, param3:b2Vec2) : void
|
||||
{
|
||||
body1 = param1;
|
||||
body2 = param2;
|
||||
localAnchor1 = body1.GetLocalPoint(param3);
|
||||
localAnchor2 = body2.GetLocalPoint(param3);
|
||||
referenceAngle = body2.GetAngle() - body1.GetAngle();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,679 @@
|
||||
package Box2D.Dynamics
|
||||
{
|
||||
import Box2D.Collision.Shapes.b2MassData;
|
||||
import Box2D.Collision.Shapes.b2Shape;
|
||||
import Box2D.Collision.Shapes.b2ShapeDef;
|
||||
import Box2D.Common.Math.b2Mat22;
|
||||
import Box2D.Common.Math.b2Math;
|
||||
import Box2D.Common.Math.b2Sweep;
|
||||
import Box2D.Common.Math.b2Vec2;
|
||||
import Box2D.Common.Math.b2XForm;
|
||||
import Box2D.Dynamics.Contacts.b2ContactEdge;
|
||||
import Box2D.Dynamics.Joints.b2JointEdge;
|
||||
|
||||
public class b2Body
|
||||
{
|
||||
|
||||
public static var e_frozenFlag:uint = 2;
|
||||
|
||||
public static var e_islandFlag:uint = 4;
|
||||
|
||||
public static var e_sleepFlag:uint = 8;
|
||||
|
||||
public static var e_allowSleepFlag:uint = 16;
|
||||
|
||||
public static var e_bulletFlag:uint = 32;
|
||||
|
||||
public static var e_fixedRotationFlag:uint = 64;
|
||||
|
||||
public static var e_staticType:uint = 1;
|
||||
|
||||
public static var e_dynamicType:uint = 2;
|
||||
|
||||
public static var e_maxTypes:uint = 3;
|
||||
|
||||
private static var s_massData:b2MassData = new b2MassData();
|
||||
|
||||
private static var s_xf1:b2XForm = new b2XForm();
|
||||
|
||||
public var m_flags:uint;
|
||||
|
||||
public var m_type:int;
|
||||
|
||||
public var m_xf:b2XForm = new b2XForm();
|
||||
|
||||
public var m_sweep:b2Sweep = new b2Sweep();
|
||||
|
||||
public var m_linearVelocity:b2Vec2 = new b2Vec2();
|
||||
|
||||
public var m_angularVelocity:Number;
|
||||
|
||||
public var m_force:b2Vec2 = new b2Vec2();
|
||||
|
||||
public var m_torque:Number;
|
||||
|
||||
public var m_world:b2World;
|
||||
|
||||
public var m_prev:b2Body;
|
||||
|
||||
public var m_next:b2Body;
|
||||
|
||||
public var m_shapeList:b2Shape;
|
||||
|
||||
public var m_shapeCount:int;
|
||||
|
||||
public var m_jointList:b2JointEdge;
|
||||
|
||||
public var m_contactList:b2ContactEdge;
|
||||
|
||||
public var m_mass:Number;
|
||||
|
||||
public var m_invMass:Number;
|
||||
|
||||
public var m_I:Number;
|
||||
|
||||
public var m_invI:Number;
|
||||
|
||||
public var m_linearDamping:Number;
|
||||
|
||||
public var m_angularDamping:Number;
|
||||
|
||||
public var m_sleepTime:Number;
|
||||
|
||||
public var m_userData:*;
|
||||
|
||||
public function b2Body(param1:b2BodyDef, param2:b2World)
|
||||
{
|
||||
super();
|
||||
m_flags = 0;
|
||||
if(param1.isBullet)
|
||||
{
|
||||
m_flags |= e_bulletFlag;
|
||||
}
|
||||
if(param1.fixedRotation)
|
||||
{
|
||||
m_flags |= e_fixedRotationFlag;
|
||||
}
|
||||
if(param1.allowSleep)
|
||||
{
|
||||
m_flags |= e_allowSleepFlag;
|
||||
}
|
||||
if(param1.isSleeping)
|
||||
{
|
||||
m_flags |= e_sleepFlag;
|
||||
}
|
||||
m_world = param2;
|
||||
m_xf.position.SetV(param1.position);
|
||||
m_xf.R.Set(param1.angle);
|
||||
m_sweep.localCenter.SetV(param1.massData.center);
|
||||
m_sweep.t0 = 1;
|
||||
m_sweep.a0 = m_sweep.a = param1.angle;
|
||||
var _loc4_:b2Mat22 = m_xf.R;
|
||||
var _loc3_:b2Vec2 = m_sweep.localCenter;
|
||||
m_sweep.c.x = _loc4_.col1.x * _loc3_.x + _loc4_.col2.x * _loc3_.y;
|
||||
m_sweep.c.y = _loc4_.col1.y * _loc3_.x + _loc4_.col2.y * _loc3_.y;
|
||||
m_sweep.c.x += m_xf.position.x;
|
||||
m_sweep.c.y += m_xf.position.y;
|
||||
m_sweep.c0.SetV(m_sweep.c);
|
||||
m_jointList = null;
|
||||
m_contactList = null;
|
||||
m_prev = null;
|
||||
m_next = null;
|
||||
m_linearDamping = param1.linearDamping;
|
||||
m_angularDamping = param1.angularDamping;
|
||||
m_force.Set(0,0);
|
||||
m_torque = 0;
|
||||
m_linearVelocity.SetZero();
|
||||
m_angularVelocity = 0;
|
||||
m_sleepTime = 0;
|
||||
m_invMass = 0;
|
||||
m_I = 0;
|
||||
m_invI = 0;
|
||||
m_mass = param1.massData.mass;
|
||||
if(m_mass > 0)
|
||||
{
|
||||
m_invMass = 1 / m_mass;
|
||||
}
|
||||
if((m_flags & b2Body.e_fixedRotationFlag) == 0)
|
||||
{
|
||||
m_I = param1.massData.I;
|
||||
}
|
||||
if(m_I > 0)
|
||||
{
|
||||
m_invI = 1 / m_I;
|
||||
}
|
||||
if(m_invMass == 0 && m_invI == 0)
|
||||
{
|
||||
m_type = e_staticType;
|
||||
}
|
||||
else
|
||||
{
|
||||
m_type = e_dynamicType;
|
||||
}
|
||||
m_userData = param1.userData;
|
||||
m_shapeList = null;
|
||||
m_shapeCount = 0;
|
||||
}
|
||||
|
||||
public function CreateShape(param1:b2ShapeDef) : b2Shape
|
||||
{
|
||||
if(m_world.m_lock == true)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
var _loc2_:b2Shape = b2Shape.Create(param1,m_world.m_blockAllocator);
|
||||
_loc2_.m_next = m_shapeList;
|
||||
m_shapeList = _loc2_;
|
||||
m_shapeCount = m_shapeCount + 1;
|
||||
_loc2_.m_body = this;
|
||||
_loc2_.CreateProxy(m_world.m_broadPhase,m_xf);
|
||||
_loc2_.UpdateSweepRadius(m_sweep.localCenter);
|
||||
return _loc2_;
|
||||
}
|
||||
|
||||
public function DestroyShape(param1:b2Shape) : void
|
||||
{
|
||||
if(m_world.m_lock == true)
|
||||
{
|
||||
return;
|
||||
}
|
||||
param1.DestroyProxy(m_world.m_broadPhase);
|
||||
var _loc2_:b2Shape = m_shapeList;
|
||||
var _loc3_:b2Shape = null;
|
||||
var _loc4_:Boolean = false;
|
||||
while(_loc2_ != null)
|
||||
{
|
||||
if(_loc2_ == param1)
|
||||
{
|
||||
if(_loc3_)
|
||||
{
|
||||
_loc3_.m_next = param1.m_next;
|
||||
}
|
||||
else
|
||||
{
|
||||
m_shapeList = param1.m_next;
|
||||
}
|
||||
_loc4_ = true;
|
||||
break;
|
||||
}
|
||||
_loc3_ = _loc2_;
|
||||
_loc2_ = _loc2_.m_next;
|
||||
}
|
||||
param1.m_body = null;
|
||||
param1.m_next = null;
|
||||
m_shapeCount = m_shapeCount - 1;
|
||||
b2Shape.Destroy(param1,m_world.m_blockAllocator);
|
||||
}
|
||||
|
||||
public function SetMass(param1:b2MassData) : void
|
||||
{
|
||||
var _loc2_:b2Shape = null;
|
||||
if(m_world.m_lock == true)
|
||||
{
|
||||
return;
|
||||
}
|
||||
m_invMass = 0;
|
||||
m_I = 0;
|
||||
m_invI = 0;
|
||||
m_mass = param1.mass;
|
||||
if(m_mass > 0)
|
||||
{
|
||||
m_invMass = 1 / m_mass;
|
||||
}
|
||||
if((m_flags & b2Body.e_fixedRotationFlag) == 0)
|
||||
{
|
||||
m_I = param1.I;
|
||||
}
|
||||
if(m_I > 0)
|
||||
{
|
||||
m_invI = 1 / m_I;
|
||||
}
|
||||
m_sweep.localCenter.SetV(param1.center);
|
||||
var _loc4_:b2Mat22 = m_xf.R;
|
||||
var _loc3_:b2Vec2 = m_sweep.localCenter;
|
||||
m_sweep.c.x = _loc4_.col1.x * _loc3_.x + _loc4_.col2.x * _loc3_.y;
|
||||
m_sweep.c.y = _loc4_.col1.y * _loc3_.x + _loc4_.col2.y * _loc3_.y;
|
||||
m_sweep.c.x += m_xf.position.x;
|
||||
m_sweep.c.y += m_xf.position.y;
|
||||
m_sweep.c0.SetV(m_sweep.c);
|
||||
_loc2_ = m_shapeList;
|
||||
while(_loc2_)
|
||||
{
|
||||
_loc2_.UpdateSweepRadius(m_sweep.localCenter);
|
||||
_loc2_ = _loc2_.m_next;
|
||||
}
|
||||
var _loc5_:int = m_type;
|
||||
if(m_invMass == 0 && m_invI == 0)
|
||||
{
|
||||
m_type = e_staticType;
|
||||
}
|
||||
else
|
||||
{
|
||||
m_type = e_dynamicType;
|
||||
}
|
||||
if(_loc5_ != m_type)
|
||||
{
|
||||
_loc2_ = m_shapeList;
|
||||
while(_loc2_)
|
||||
{
|
||||
_loc2_.RefilterProxy(m_world.m_broadPhase,m_xf);
|
||||
_loc2_ = _loc2_.m_next;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public function SetMassFromShapes() : void
|
||||
{
|
||||
var _loc3_:b2Shape = null;
|
||||
if(m_world.m_lock == true)
|
||||
{
|
||||
return;
|
||||
}
|
||||
m_mass = 0;
|
||||
m_invMass = 0;
|
||||
m_I = 0;
|
||||
m_invI = 0;
|
||||
var _loc4_:Number = 0;
|
||||
var _loc2_:Number = 0;
|
||||
var _loc1_:b2MassData = s_massData;
|
||||
_loc3_ = m_shapeList;
|
||||
while(_loc3_)
|
||||
{
|
||||
_loc3_.ComputeMass(_loc1_);
|
||||
m_mass += _loc1_.mass;
|
||||
_loc4_ += _loc1_.mass * _loc1_.center.x;
|
||||
_loc2_ += _loc1_.mass * _loc1_.center.y;
|
||||
m_I += _loc1_.I;
|
||||
_loc3_ = _loc3_.m_next;
|
||||
}
|
||||
if(m_mass > 0)
|
||||
{
|
||||
m_invMass = 1 / m_mass;
|
||||
_loc4_ *= m_invMass;
|
||||
_loc2_ *= m_invMass;
|
||||
}
|
||||
if(m_I > 0 && (m_flags & e_fixedRotationFlag) == 0)
|
||||
{
|
||||
m_I -= m_mass * (_loc4_ * _loc4_ + _loc2_ * _loc2_);
|
||||
m_invI = 1 / m_I;
|
||||
}
|
||||
else
|
||||
{
|
||||
m_I = 0;
|
||||
m_invI = 0;
|
||||
}
|
||||
m_sweep.localCenter.Set(_loc4_,_loc2_);
|
||||
var _loc6_:b2Mat22 = m_xf.R;
|
||||
var _loc5_:b2Vec2 = m_sweep.localCenter;
|
||||
m_sweep.c.x = _loc6_.col1.x * _loc5_.x + _loc6_.col2.x * _loc5_.y;
|
||||
m_sweep.c.y = _loc6_.col1.y * _loc5_.x + _loc6_.col2.y * _loc5_.y;
|
||||
m_sweep.c.x += m_xf.position.x;
|
||||
m_sweep.c.y += m_xf.position.y;
|
||||
m_sweep.c0.SetV(m_sweep.c);
|
||||
_loc3_ = m_shapeList;
|
||||
while(_loc3_)
|
||||
{
|
||||
_loc3_.UpdateSweepRadius(m_sweep.localCenter);
|
||||
_loc3_ = _loc3_.m_next;
|
||||
}
|
||||
var _loc7_:int = m_type;
|
||||
if(m_invMass == 0 && m_invI == 0)
|
||||
{
|
||||
m_type = e_staticType;
|
||||
}
|
||||
else
|
||||
{
|
||||
m_type = e_dynamicType;
|
||||
}
|
||||
if(_loc7_ != m_type)
|
||||
{
|
||||
_loc3_ = m_shapeList;
|
||||
while(_loc3_)
|
||||
{
|
||||
_loc3_.RefilterProxy(m_world.m_broadPhase,m_xf);
|
||||
_loc3_ = _loc3_.m_next;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public function SetXForm(param1:b2Vec2, param2:Number) : Boolean
|
||||
{
|
||||
var _loc3_:b2Shape = null;
|
||||
var _loc7_:Boolean = false;
|
||||
if(m_world.m_lock == true)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
if(IsFrozen())
|
||||
{
|
||||
return false;
|
||||
}
|
||||
m_xf.R.Set(param2);
|
||||
m_xf.position.SetV(param1);
|
||||
var _loc6_:b2Mat22 = m_xf.R;
|
||||
var _loc5_:b2Vec2 = m_sweep.localCenter;
|
||||
m_sweep.c.x = _loc6_.col1.x * _loc5_.x + _loc6_.col2.x * _loc5_.y;
|
||||
m_sweep.c.y = _loc6_.col1.y * _loc5_.x + _loc6_.col2.y * _loc5_.y;
|
||||
m_sweep.c.x += m_xf.position.x;
|
||||
m_sweep.c.y += m_xf.position.y;
|
||||
m_sweep.c0.SetV(m_sweep.c);
|
||||
m_sweep.a0 = m_sweep.a = param2;
|
||||
var _loc4_:Boolean = false;
|
||||
_loc3_ = m_shapeList;
|
||||
while(_loc3_)
|
||||
{
|
||||
_loc7_ = _loc3_.Synchronize(m_world.m_broadPhase,m_xf,m_xf);
|
||||
if(_loc7_ == false)
|
||||
{
|
||||
_loc4_ = true;
|
||||
break;
|
||||
}
|
||||
_loc3_ = _loc3_.m_next;
|
||||
}
|
||||
if(_loc4_ == true)
|
||||
{
|
||||
m_flags |= e_frozenFlag;
|
||||
m_linearVelocity.SetZero();
|
||||
m_angularVelocity = 0;
|
||||
_loc3_ = m_shapeList;
|
||||
while(_loc3_)
|
||||
{
|
||||
_loc3_.DestroyProxy(m_world.m_broadPhase);
|
||||
_loc3_ = _loc3_.m_next;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
m_world.m_broadPhase.Commit();
|
||||
return true;
|
||||
}
|
||||
|
||||
public function GetXForm() : b2XForm
|
||||
{
|
||||
return m_xf;
|
||||
}
|
||||
|
||||
public function GetPosition() : b2Vec2
|
||||
{
|
||||
return m_xf.position;
|
||||
}
|
||||
|
||||
public function GetAngle() : Number
|
||||
{
|
||||
return m_sweep.a;
|
||||
}
|
||||
|
||||
public function GetWorldCenter() : b2Vec2
|
||||
{
|
||||
return m_sweep.c;
|
||||
}
|
||||
|
||||
public function GetLocalCenter() : b2Vec2
|
||||
{
|
||||
return m_sweep.localCenter;
|
||||
}
|
||||
|
||||
public function SetLinearVelocity(param1:b2Vec2) : void
|
||||
{
|
||||
m_linearVelocity.SetV(param1);
|
||||
}
|
||||
|
||||
public function GetLinearVelocity() : b2Vec2
|
||||
{
|
||||
return m_linearVelocity;
|
||||
}
|
||||
|
||||
public function SetAngularVelocity(param1:Number) : void
|
||||
{
|
||||
m_angularVelocity = param1;
|
||||
}
|
||||
|
||||
public function GetAngularVelocity() : Number
|
||||
{
|
||||
return m_angularVelocity;
|
||||
}
|
||||
|
||||
public function ApplyForce(param1:b2Vec2, param2:b2Vec2) : void
|
||||
{
|
||||
if(IsSleeping())
|
||||
{
|
||||
WakeUp();
|
||||
}
|
||||
m_force.x += param1.x;
|
||||
m_force.y += param1.y;
|
||||
m_torque += (param2.x - m_sweep.c.x) * param1.y - (param2.y - m_sweep.c.y) * param1.x;
|
||||
}
|
||||
|
||||
public function ApplyTorque(param1:Number) : void
|
||||
{
|
||||
if(IsSleeping())
|
||||
{
|
||||
WakeUp();
|
||||
}
|
||||
m_torque += param1;
|
||||
}
|
||||
|
||||
public function ApplyImpulse(param1:b2Vec2, param2:b2Vec2) : void
|
||||
{
|
||||
if(IsSleeping())
|
||||
{
|
||||
WakeUp();
|
||||
}
|
||||
m_linearVelocity.x += m_invMass * param1.x;
|
||||
m_linearVelocity.y += m_invMass * param1.y;
|
||||
m_angularVelocity += m_invI * ((param2.x - m_sweep.c.x) * param1.y - (param2.y - m_sweep.c.y) * param1.x);
|
||||
}
|
||||
|
||||
public function GetMass() : Number
|
||||
{
|
||||
return m_mass;
|
||||
}
|
||||
|
||||
public function GetInertia() : Number
|
||||
{
|
||||
return m_I;
|
||||
}
|
||||
|
||||
public function GetWorldPoint(param1:b2Vec2) : b2Vec2
|
||||
{
|
||||
var _loc2_:b2Mat22 = m_xf.R;
|
||||
var _loc3_:b2Vec2 = new b2Vec2(_loc2_.col1.x * param1.x + _loc2_.col2.x * param1.y,_loc2_.col1.y * param1.x + _loc2_.col2.y * param1.y);
|
||||
_loc3_.x += m_xf.position.x;
|
||||
_loc3_.y += m_xf.position.y;
|
||||
return _loc3_;
|
||||
}
|
||||
|
||||
public function GetWorldVector(param1:b2Vec2) : b2Vec2
|
||||
{
|
||||
return b2Math.b2MulMV(m_xf.R,param1);
|
||||
}
|
||||
|
||||
public function GetLocalPoint(param1:b2Vec2) : b2Vec2
|
||||
{
|
||||
return b2Math.b2MulXT(m_xf,param1);
|
||||
}
|
||||
|
||||
public function GetLocalVector(param1:b2Vec2) : b2Vec2
|
||||
{
|
||||
return b2Math.b2MulTMV(m_xf.R,param1);
|
||||
}
|
||||
|
||||
public function GetLinearVelocityFromWorldPoint(param1:b2Vec2) : b2Vec2
|
||||
{
|
||||
return new b2Vec2(m_linearVelocity.x - m_angularVelocity * (param1.y - m_sweep.c.y),m_linearVelocity.y + m_angularVelocity * (param1.x - m_sweep.c.x));
|
||||
}
|
||||
|
||||
public function GetLinearVelocityFromLocalPoint(param1:b2Vec2) : b2Vec2
|
||||
{
|
||||
var _loc2_:b2Mat22 = m_xf.R;
|
||||
var _loc3_:b2Vec2 = new b2Vec2(_loc2_.col1.x * param1.x + _loc2_.col2.x * param1.y,_loc2_.col1.y * param1.x + _loc2_.col2.y * param1.y);
|
||||
_loc3_.x += m_xf.position.x;
|
||||
_loc3_.y += m_xf.position.y;
|
||||
return new b2Vec2(m_linearVelocity.x + m_angularVelocity * (_loc3_.y - m_sweep.c.y),m_linearVelocity.x - m_angularVelocity * (_loc3_.x - m_sweep.c.x));
|
||||
}
|
||||
|
||||
public function IsBullet() : Boolean
|
||||
{
|
||||
return (m_flags & e_bulletFlag) == e_bulletFlag;
|
||||
}
|
||||
|
||||
public function SetBullet(param1:Boolean) : void
|
||||
{
|
||||
if(param1)
|
||||
{
|
||||
m_flags |= e_bulletFlag;
|
||||
}
|
||||
else
|
||||
{
|
||||
m_flags &= ~e_bulletFlag;
|
||||
}
|
||||
}
|
||||
|
||||
public function IsStatic() : Boolean
|
||||
{
|
||||
return m_type == e_staticType;
|
||||
}
|
||||
|
||||
public function IsDynamic() : Boolean
|
||||
{
|
||||
return m_type == e_dynamicType;
|
||||
}
|
||||
|
||||
public function IsFrozen() : Boolean
|
||||
{
|
||||
return (m_flags & e_frozenFlag) == e_frozenFlag;
|
||||
}
|
||||
|
||||
public function IsSleeping() : Boolean
|
||||
{
|
||||
return (m_flags & e_sleepFlag) == e_sleepFlag;
|
||||
}
|
||||
|
||||
public function AllowSleeping(param1:Boolean) : void
|
||||
{
|
||||
if(param1)
|
||||
{
|
||||
m_flags |= e_allowSleepFlag;
|
||||
}
|
||||
else
|
||||
{
|
||||
m_flags &= ~e_allowSleepFlag;
|
||||
WakeUp();
|
||||
}
|
||||
}
|
||||
|
||||
public function WakeUp() : void
|
||||
{
|
||||
m_flags &= ~e_sleepFlag;
|
||||
m_sleepTime = 0;
|
||||
}
|
||||
|
||||
public function PutToSleep() : void
|
||||
{
|
||||
m_flags |= e_sleepFlag;
|
||||
m_sleepTime = 0;
|
||||
m_linearVelocity.SetZero();
|
||||
m_angularVelocity = 0;
|
||||
m_force.SetZero();
|
||||
m_torque = 0;
|
||||
}
|
||||
|
||||
public function GetShapeList() : b2Shape
|
||||
{
|
||||
return m_shapeList;
|
||||
}
|
||||
|
||||
public function GetJointList() : b2JointEdge
|
||||
{
|
||||
return m_jointList;
|
||||
}
|
||||
|
||||
public function GetNext() : b2Body
|
||||
{
|
||||
return m_next;
|
||||
}
|
||||
|
||||
public function GetUserData() : *
|
||||
{
|
||||
return m_userData;
|
||||
}
|
||||
|
||||
public function SetUserData(param1:*) : void
|
||||
{
|
||||
m_userData = param1;
|
||||
}
|
||||
|
||||
public function GetWorld() : b2World
|
||||
{
|
||||
return m_world;
|
||||
}
|
||||
|
||||
public function SynchronizeShapes() : Boolean
|
||||
{
|
||||
var _loc2_:b2Shape = null;
|
||||
var _loc1_:b2XForm = s_xf1;
|
||||
_loc1_.R.Set(m_sweep.a0);
|
||||
var _loc4_:b2Mat22 = _loc1_.R;
|
||||
var _loc3_:b2Vec2 = m_sweep.localCenter;
|
||||
_loc1_.position.x = m_sweep.c0.x - (_loc4_.col1.x * _loc3_.x + _loc4_.col2.x * _loc3_.y);
|
||||
_loc1_.position.y = m_sweep.c0.y - (_loc4_.col1.y * _loc3_.x + _loc4_.col2.y * _loc3_.y);
|
||||
var _loc5_:Boolean = true;
|
||||
_loc2_ = m_shapeList;
|
||||
while(_loc2_)
|
||||
{
|
||||
_loc5_ = _loc2_.Synchronize(m_world.m_broadPhase,_loc1_,m_xf);
|
||||
if(_loc5_ == false)
|
||||
{
|
||||
break;
|
||||
}
|
||||
_loc2_ = _loc2_.m_next;
|
||||
}
|
||||
if(_loc5_ == false)
|
||||
{
|
||||
m_flags |= e_frozenFlag;
|
||||
m_linearVelocity.SetZero();
|
||||
m_angularVelocity = 0;
|
||||
_loc2_ = m_shapeList;
|
||||
while(_loc2_)
|
||||
{
|
||||
_loc2_.DestroyProxy(m_world.m_broadPhase);
|
||||
_loc2_ = _loc2_.m_next;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
public function SynchronizeTransform() : void
|
||||
{
|
||||
m_xf.R.Set(m_sweep.a);
|
||||
var _loc2_:b2Mat22 = m_xf.R;
|
||||
var _loc1_:b2Vec2 = m_sweep.localCenter;
|
||||
m_xf.position.x = m_sweep.c.x - (_loc2_.col1.x * _loc1_.x + _loc2_.col2.x * _loc1_.y);
|
||||
m_xf.position.y = m_sweep.c.y - (_loc2_.col1.y * _loc1_.x + _loc2_.col2.y * _loc1_.y);
|
||||
}
|
||||
|
||||
public function IsConnected(param1:b2Body) : Boolean
|
||||
{
|
||||
var _loc2_:b2JointEdge = null;
|
||||
_loc2_ = m_jointList;
|
||||
while(_loc2_)
|
||||
{
|
||||
if(_loc2_.other == param1)
|
||||
{
|
||||
return _loc2_.joint.m_collideConnected == false;
|
||||
}
|
||||
_loc2_ = _loc2_.next;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
public function Advance(param1:Number) : void
|
||||
{
|
||||
m_sweep.Advance(param1);
|
||||
m_sweep.c.SetV(m_sweep.c0);
|
||||
m_sweep.a = m_sweep.a0;
|
||||
SynchronizeTransform();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,47 @@
|
||||
package Box2D.Dynamics
|
||||
{
|
||||
import Box2D.Collision.Shapes.b2MassData;
|
||||
import Box2D.Common.Math.b2Vec2;
|
||||
|
||||
public class b2BodyDef
|
||||
{
|
||||
|
||||
public var massData:b2MassData = new b2MassData();
|
||||
|
||||
public var userData:*;
|
||||
|
||||
public var position:b2Vec2 = new b2Vec2();
|
||||
|
||||
public var angle:Number;
|
||||
|
||||
public var linearDamping:Number;
|
||||
|
||||
public var angularDamping:Number;
|
||||
|
||||
public var allowSleep:Boolean;
|
||||
|
||||
public var isSleeping:Boolean;
|
||||
|
||||
public var fixedRotation:Boolean;
|
||||
|
||||
public var isBullet:Boolean;
|
||||
|
||||
public function b2BodyDef()
|
||||
{
|
||||
super();
|
||||
massData.center.SetZero();
|
||||
massData.mass = 0;
|
||||
massData.I = 0;
|
||||
userData = null;
|
||||
position.Set(0,0);
|
||||
angle = 0;
|
||||
linearDamping = 0;
|
||||
angularDamping = 0;
|
||||
allowSleep = true;
|
||||
isSleeping = false;
|
||||
fixedRotation = false;
|
||||
isBullet = false;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,16 @@
|
||||
package Box2D.Dynamics
|
||||
{
|
||||
public class b2BoundaryListener
|
||||
{
|
||||
|
||||
public function b2BoundaryListener()
|
||||
{
|
||||
super();
|
||||
}
|
||||
|
||||
public function Violation(param1:b2Body) : void
|
||||
{
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,28 @@
|
||||
package Box2D.Dynamics
|
||||
{
|
||||
import Box2D.Collision.Shapes.b2FilterData;
|
||||
import Box2D.Collision.Shapes.b2Shape;
|
||||
|
||||
public class b2ContactFilter
|
||||
{
|
||||
|
||||
public static var b2_defaultFilter:b2ContactFilter = new b2ContactFilter();
|
||||
|
||||
public function b2ContactFilter()
|
||||
{
|
||||
super();
|
||||
}
|
||||
|
||||
public function ShouldCollide(param1:b2Shape, param2:b2Shape) : Boolean
|
||||
{
|
||||
var _loc3_:b2FilterData = param1.GetFilterData();
|
||||
var _loc5_:b2FilterData = param2.GetFilterData();
|
||||
if(_loc3_.groupIndex == _loc5_.groupIndex && _loc3_.groupIndex != 0)
|
||||
{
|
||||
return _loc3_.groupIndex > 0;
|
||||
}
|
||||
return (_loc3_.maskBits & _loc5_.categoryBits) != 0 && (_loc3_.categoryBits & _loc5_.maskBits) != 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,31 @@
|
||||
package Box2D.Dynamics
|
||||
{
|
||||
import Box2D.Collision.b2ContactPoint;
|
||||
import Box2D.Dynamics.Contacts.b2ContactResult;
|
||||
|
||||
public class b2ContactListener
|
||||
{
|
||||
|
||||
public function b2ContactListener()
|
||||
{
|
||||
super();
|
||||
}
|
||||
|
||||
public function Add(param1:b2ContactPoint) : void
|
||||
{
|
||||
}
|
||||
|
||||
public function Persist(param1:b2ContactPoint) : void
|
||||
{
|
||||
}
|
||||
|
||||
public function Remove(param1:b2ContactPoint) : void
|
||||
{
|
||||
}
|
||||
|
||||
public function Result(param1:b2ContactResult) : void
|
||||
{
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,208 @@
|
||||
package Box2D.Dynamics
|
||||
{
|
||||
import Box2D.Collision.*;
|
||||
import Box2D.Collision.Shapes.*;
|
||||
import Box2D.Common.*;
|
||||
import Box2D.Common.Math.*;
|
||||
import Box2D.Dynamics.Contacts.*;
|
||||
|
||||
public class b2ContactManager extends b2PairCallback
|
||||
{
|
||||
|
||||
private static const s_evalCP:b2ContactPoint = new b2ContactPoint();
|
||||
|
||||
public var m_world:b2World;
|
||||
|
||||
public var m_nullContact:b2NullContact = new b2NullContact();
|
||||
|
||||
public var m_destroyImmediate:Boolean;
|
||||
|
||||
public function b2ContactManager()
|
||||
{
|
||||
super();
|
||||
m_world = null;
|
||||
m_destroyImmediate = false;
|
||||
}
|
||||
|
||||
override public function PairAdded(param1:*, param2:*) : *
|
||||
{
|
||||
var _loc4_:b2Shape = param1 as b2Shape;
|
||||
var _loc5_:b2Shape = param2 as b2Shape;
|
||||
var _loc6_:b2Body = _loc4_.m_body;
|
||||
var _loc7_:b2Body = _loc5_.m_body;
|
||||
if(_loc6_.IsStatic() && _loc7_.IsStatic())
|
||||
{
|
||||
return m_nullContact;
|
||||
}
|
||||
if(_loc4_.m_body == _loc5_.m_body)
|
||||
{
|
||||
return m_nullContact;
|
||||
}
|
||||
if(_loc7_.IsConnected(_loc6_))
|
||||
{
|
||||
return m_nullContact;
|
||||
}
|
||||
if(m_world.m_contactFilter != null && m_world.m_contactFilter.ShouldCollide(_loc4_,_loc5_) == false)
|
||||
{
|
||||
return m_nullContact;
|
||||
}
|
||||
var _loc3_:b2Contact = b2Contact.Create(_loc4_,_loc5_,m_world.m_blockAllocator);
|
||||
if(_loc3_ == null)
|
||||
{
|
||||
return m_nullContact;
|
||||
}
|
||||
_loc4_ = _loc3_.m_shape1;
|
||||
_loc5_ = _loc3_.m_shape2;
|
||||
_loc6_ = _loc4_.m_body;
|
||||
_loc7_ = _loc5_.m_body;
|
||||
_loc3_.m_prev = null;
|
||||
_loc3_.m_next = m_world.m_contactList;
|
||||
if(m_world.m_contactList != null)
|
||||
{
|
||||
m_world.m_contactList.m_prev = _loc3_;
|
||||
}
|
||||
m_world.m_contactList = _loc3_;
|
||||
_loc3_.m_node1.contact = _loc3_;
|
||||
_loc3_.m_node1.other = _loc7_;
|
||||
_loc3_.m_node1.prev = null;
|
||||
_loc3_.m_node1.next = _loc6_.m_contactList;
|
||||
if(_loc6_.m_contactList != null)
|
||||
{
|
||||
_loc6_.m_contactList.prev = _loc3_.m_node1;
|
||||
}
|
||||
_loc6_.m_contactList = _loc3_.m_node1;
|
||||
_loc3_.m_node2.contact = _loc3_;
|
||||
_loc3_.m_node2.other = _loc6_;
|
||||
_loc3_.m_node2.prev = null;
|
||||
_loc3_.m_node2.next = _loc7_.m_contactList;
|
||||
if(_loc7_.m_contactList != null)
|
||||
{
|
||||
_loc7_.m_contactList.prev = _loc3_.m_node2;
|
||||
}
|
||||
_loc7_.m_contactList = _loc3_.m_node2;
|
||||
++m_world.m_contactCount;
|
||||
return _loc3_;
|
||||
}
|
||||
|
||||
override public function PairRemoved(param1:*, param2:*, param3:*) : void
|
||||
{
|
||||
if(param3 == null)
|
||||
{
|
||||
return;
|
||||
}
|
||||
var _loc4_:b2Contact = param3 as b2Contact;
|
||||
if(_loc4_ == m_nullContact)
|
||||
{
|
||||
return;
|
||||
}
|
||||
Destroy(_loc4_);
|
||||
}
|
||||
|
||||
public function Destroy(param1:b2Contact) : void
|
||||
{
|
||||
var _loc8_:b2Body = null;
|
||||
var _loc9_:b2Body = null;
|
||||
var _loc2_:Array = null;
|
||||
var _loc7_:b2ContactPoint = null;
|
||||
var _loc5_:int = 0;
|
||||
var _loc14_:b2Manifold = null;
|
||||
var _loc6_:int = 0;
|
||||
var _loc3_:b2ManifoldPoint = null;
|
||||
var _loc15_:b2Vec2 = null;
|
||||
var _loc16_:b2Vec2 = null;
|
||||
var _loc11_:b2Shape = param1.m_shape1;
|
||||
var _loc12_:b2Shape = param1.m_shape2;
|
||||
var _loc10_:int = param1.m_manifoldCount;
|
||||
if(_loc10_ > 0 && m_world.m_contactListener)
|
||||
{
|
||||
_loc8_ = _loc11_.m_body;
|
||||
_loc9_ = _loc12_.m_body;
|
||||
_loc2_ = param1.GetManifolds();
|
||||
_loc7_ = s_evalCP;
|
||||
_loc7_.shape1 = param1.m_shape1;
|
||||
_loc7_.shape2 = param1.m_shape2;
|
||||
_loc7_.friction = param1.m_friction;
|
||||
_loc7_.restitution = param1.m_restitution;
|
||||
_loc5_ = 0;
|
||||
while(_loc5_ < _loc10_)
|
||||
{
|
||||
_loc14_ = _loc2_[_loc5_];
|
||||
_loc7_.normal.SetV(_loc14_.normal);
|
||||
_loc6_ = 0;
|
||||
while(_loc6_ < _loc14_.pointCount)
|
||||
{
|
||||
_loc3_ = _loc14_.points[_loc6_];
|
||||
_loc7_.position = _loc8_.GetWorldPoint(_loc3_.localPoint1);
|
||||
_loc15_ = _loc8_.GetLinearVelocityFromLocalPoint(_loc3_.localPoint1);
|
||||
_loc16_ = _loc9_.GetLinearVelocityFromLocalPoint(_loc3_.localPoint2);
|
||||
_loc7_.velocity.Set(_loc16_.x - _loc15_.x,_loc16_.y - _loc15_.y);
|
||||
_loc7_.separation = _loc3_.separation;
|
||||
_loc7_.id.key = _loc3_.id._key;
|
||||
m_world.m_contactListener.Remove(_loc7_);
|
||||
_loc6_++;
|
||||
}
|
||||
_loc5_++;
|
||||
}
|
||||
}
|
||||
if(param1.m_prev)
|
||||
{
|
||||
param1.m_prev.m_next = param1.m_next;
|
||||
}
|
||||
if(param1.m_next)
|
||||
{
|
||||
param1.m_next.m_prev = param1.m_prev;
|
||||
}
|
||||
if(param1 == m_world.m_contactList)
|
||||
{
|
||||
m_world.m_contactList = param1.m_next;
|
||||
}
|
||||
var _loc13_:b2Body = _loc11_.m_body;
|
||||
var _loc4_:b2Body = _loc12_.m_body;
|
||||
if(param1.m_node1.prev)
|
||||
{
|
||||
param1.m_node1.prev.next = param1.m_node1.next;
|
||||
}
|
||||
if(param1.m_node1.next)
|
||||
{
|
||||
param1.m_node1.next.prev = param1.m_node1.prev;
|
||||
}
|
||||
if(param1.m_node1 == _loc13_.m_contactList)
|
||||
{
|
||||
_loc13_.m_contactList = param1.m_node1.next;
|
||||
}
|
||||
if(param1.m_node2.prev)
|
||||
{
|
||||
param1.m_node2.prev.next = param1.m_node2.next;
|
||||
}
|
||||
if(param1.m_node2.next)
|
||||
{
|
||||
param1.m_node2.next.prev = param1.m_node2.prev;
|
||||
}
|
||||
if(param1.m_node2 == _loc4_.m_contactList)
|
||||
{
|
||||
_loc4_.m_contactList = param1.m_node2.next;
|
||||
}
|
||||
b2Contact.Destroy(param1,m_world.m_blockAllocator);
|
||||
--m_world.m_contactCount;
|
||||
}
|
||||
|
||||
public function Collide() : void
|
||||
{
|
||||
var _loc1_:b2Contact = null;
|
||||
var _loc2_:b2Body = null;
|
||||
var _loc3_:b2Body = null;
|
||||
_loc1_ = m_world.m_contactList;
|
||||
while(_loc1_)
|
||||
{
|
||||
_loc2_ = _loc1_.m_shape1.m_body;
|
||||
_loc3_ = _loc1_.m_shape2.m_body;
|
||||
if(!(_loc2_.IsSleeping() && _loc3_.IsSleeping()))
|
||||
{
|
||||
_loc1_.Update(m_world.m_contactListener);
|
||||
}
|
||||
_loc1_ = _loc1_.m_next;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,132 @@
|
||||
package Box2D.Dynamics
|
||||
{
|
||||
import Box2D.Collision.*;
|
||||
import Box2D.Collision.Shapes.*;
|
||||
import Box2D.Common.*;
|
||||
import Box2D.Common.Math.*;
|
||||
import Box2D.Dynamics.Contacts.*;
|
||||
import flash.display.Sprite;
|
||||
|
||||
public class b2DebugDraw
|
||||
{
|
||||
|
||||
public static var e_shapeBit:uint = 1;
|
||||
|
||||
public static var e_jointBit:uint = 2;
|
||||
|
||||
public static var e_coreShapeBit:uint = 4;
|
||||
|
||||
public static var e_aabbBit:uint = 8;
|
||||
|
||||
public static var e_obbBit:uint = 16;
|
||||
|
||||
public static var e_pairBit:uint = 32;
|
||||
|
||||
public static var e_centerOfMassBit:uint = 64;
|
||||
|
||||
public var m_drawFlags:uint;
|
||||
|
||||
public var m_sprite:Sprite;
|
||||
|
||||
public var m_drawScale:Number = 1;
|
||||
|
||||
public var m_lineThickness:Number = 1;
|
||||
|
||||
public var m_alpha:Number = 1;
|
||||
|
||||
public var m_fillAlpha:Number = 1;
|
||||
|
||||
public var m_xformScale:Number = 1;
|
||||
|
||||
public function b2DebugDraw()
|
||||
{
|
||||
super();
|
||||
m_drawFlags = 0;
|
||||
}
|
||||
|
||||
public function SetFlags(param1:uint) : void
|
||||
{
|
||||
m_drawFlags = param1;
|
||||
}
|
||||
|
||||
public function GetFlags() : uint
|
||||
{
|
||||
return m_drawFlags;
|
||||
}
|
||||
|
||||
public function AppendFlags(param1:uint) : void
|
||||
{
|
||||
m_drawFlags |= param1;
|
||||
}
|
||||
|
||||
public function ClearFlags(param1:uint) : void
|
||||
{
|
||||
m_drawFlags &= ~param1;
|
||||
}
|
||||
|
||||
public function DrawPolygon(param1:Array, param2:int, param3:b2Color) : void
|
||||
{
|
||||
var _loc4_:int = 0;
|
||||
m_sprite.graphics.lineStyle(m_lineThickness,param3.color,m_alpha);
|
||||
m_sprite.graphics.moveTo(param1[0].x * m_drawScale,param1[0].y * m_drawScale);
|
||||
_loc4_ = 1;
|
||||
while(_loc4_ < param2)
|
||||
{
|
||||
m_sprite.graphics.lineTo(param1[_loc4_].x * m_drawScale,param1[_loc4_].y * m_drawScale);
|
||||
_loc4_++;
|
||||
}
|
||||
m_sprite.graphics.lineTo(param1[0].x * m_drawScale,param1[0].y * m_drawScale);
|
||||
}
|
||||
|
||||
public function DrawSolidPolygon(param1:Array, param2:int, param3:b2Color) : void
|
||||
{
|
||||
var _loc4_:int = 0;
|
||||
m_sprite.graphics.lineStyle(m_lineThickness,param3.color,m_alpha);
|
||||
m_sprite.graphics.moveTo(param1[0].x * m_drawScale,param1[0].y * m_drawScale);
|
||||
m_sprite.graphics.beginFill(param3.color,m_fillAlpha);
|
||||
_loc4_ = 1;
|
||||
while(_loc4_ < param2)
|
||||
{
|
||||
m_sprite.graphics.lineTo(param1[_loc4_].x * m_drawScale,param1[_loc4_].y * m_drawScale);
|
||||
_loc4_++;
|
||||
}
|
||||
m_sprite.graphics.lineTo(param1[0].x * m_drawScale,param1[0].y * m_drawScale);
|
||||
m_sprite.graphics.endFill();
|
||||
}
|
||||
|
||||
public function DrawCircle(param1:b2Vec2, param2:Number, param3:b2Color) : void
|
||||
{
|
||||
m_sprite.graphics.lineStyle(m_lineThickness,param3.color,m_alpha);
|
||||
m_sprite.graphics.drawCircle(param1.x * m_drawScale,param1.y * m_drawScale,param2 * m_drawScale);
|
||||
}
|
||||
|
||||
public function DrawSolidCircle(param1:b2Vec2, param2:Number, param3:b2Vec2, param4:b2Color) : void
|
||||
{
|
||||
m_sprite.graphics.lineStyle(m_lineThickness,param4.color,m_alpha);
|
||||
m_sprite.graphics.moveTo(0,0);
|
||||
m_sprite.graphics.beginFill(param4.color,m_fillAlpha);
|
||||
m_sprite.graphics.drawCircle(param1.x * m_drawScale,param1.y * m_drawScale,param2 * m_drawScale);
|
||||
m_sprite.graphics.endFill();
|
||||
m_sprite.graphics.moveTo(param1.x * m_drawScale,param1.y * m_drawScale);
|
||||
m_sprite.graphics.lineTo((param1.x + param3.x * param2) * m_drawScale,(param1.y + param3.y * param2) * m_drawScale);
|
||||
}
|
||||
|
||||
public function DrawSegment(param1:b2Vec2, param2:b2Vec2, param3:b2Color) : void
|
||||
{
|
||||
m_sprite.graphics.lineStyle(m_lineThickness,param3.color,m_alpha);
|
||||
m_sprite.graphics.moveTo(param1.x * m_drawScale,param1.y * m_drawScale);
|
||||
m_sprite.graphics.lineTo(param2.x * m_drawScale,param2.y * m_drawScale);
|
||||
}
|
||||
|
||||
public function DrawXForm(param1:b2XForm) : void
|
||||
{
|
||||
m_sprite.graphics.lineStyle(m_lineThickness,16711680,m_alpha);
|
||||
m_sprite.graphics.moveTo(param1.position.x * m_drawScale,param1.position.y * m_drawScale);
|
||||
m_sprite.graphics.lineTo((param1.position.x + m_xformScale * param1.R.col1.x) * m_drawScale,(param1.position.y + m_xformScale * param1.R.col1.y) * m_drawScale);
|
||||
m_sprite.graphics.lineStyle(m_lineThickness,65280,m_alpha);
|
||||
m_sprite.graphics.moveTo(param1.position.x * m_drawScale,param1.position.y * m_drawScale);
|
||||
m_sprite.graphics.lineTo((param1.position.x + m_xformScale * param1.R.col2.x) * m_drawScale,(param1.position.y + m_xformScale * param1.R.col2.y) * m_drawScale);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,23 @@
|
||||
package Box2D.Dynamics
|
||||
{
|
||||
import Box2D.Collision.Shapes.b2Shape;
|
||||
import Box2D.Dynamics.Joints.b2Joint;
|
||||
|
||||
public class b2DestructionListener
|
||||
{
|
||||
|
||||
public function b2DestructionListener()
|
||||
{
|
||||
super();
|
||||
}
|
||||
|
||||
public function SayGoodbyeJoint(param1:b2Joint) : void
|
||||
{
|
||||
}
|
||||
|
||||
public function SayGoodbyeShape(param1:b2Shape) : void
|
||||
{
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,349 @@
|
||||
package Box2D.Dynamics
|
||||
{
|
||||
import Box2D.Collision.*;
|
||||
import Box2D.Common.*;
|
||||
import Box2D.Common.Math.*;
|
||||
import Box2D.Dynamics.Contacts.*;
|
||||
import Box2D.Dynamics.Joints.*;
|
||||
|
||||
public class b2Island
|
||||
{
|
||||
|
||||
private static var s_reportCR:b2ContactResult = new b2ContactResult();
|
||||
|
||||
public var m_allocator:*;
|
||||
|
||||
public var m_listener:b2ContactListener;
|
||||
|
||||
public var m_bodies:Array;
|
||||
|
||||
public var m_contacts:Array;
|
||||
|
||||
public var m_joints:Array;
|
||||
|
||||
public var m_bodyCount:int;
|
||||
|
||||
public var m_jointCount:int;
|
||||
|
||||
public var m_contactCount:int;
|
||||
|
||||
public var m_bodyCapacity:int;
|
||||
|
||||
public var m_contactCapacity:int;
|
||||
|
||||
public var m_jointCapacity:int;
|
||||
|
||||
public var m_positionIterationCount:int;
|
||||
|
||||
public function b2Island(param1:int, param2:int, param3:int, param4:*, param5:b2ContactListener)
|
||||
{
|
||||
var _loc6_:int = 0;
|
||||
super();
|
||||
m_bodyCapacity = param1;
|
||||
m_contactCapacity = param2;
|
||||
m_jointCapacity = param3;
|
||||
m_bodyCount = 0;
|
||||
m_contactCount = 0;
|
||||
m_jointCount = 0;
|
||||
m_allocator = param4;
|
||||
m_listener = param5;
|
||||
m_bodies = new Array(param1);
|
||||
_loc6_ = 0;
|
||||
while(_loc6_ < param1)
|
||||
{
|
||||
m_bodies[_loc6_] = null;
|
||||
_loc6_++;
|
||||
}
|
||||
m_contacts = new Array(param2);
|
||||
_loc6_ = 0;
|
||||
while(_loc6_ < param2)
|
||||
{
|
||||
m_contacts[_loc6_] = null;
|
||||
_loc6_++;
|
||||
}
|
||||
m_joints = new Array(param3);
|
||||
_loc6_ = 0;
|
||||
while(_loc6_ < param3)
|
||||
{
|
||||
m_joints[_loc6_] = null;
|
||||
_loc6_++;
|
||||
}
|
||||
m_positionIterationCount = 0;
|
||||
}
|
||||
|
||||
public function Clear() : void
|
||||
{
|
||||
m_bodyCount = 0;
|
||||
m_contactCount = 0;
|
||||
m_jointCount = 0;
|
||||
}
|
||||
|
||||
public function Solve(param1:b2TimeStep, param2:b2Vec2, param3:Boolean, param4:Boolean) : void
|
||||
{
|
||||
var _loc7_:int = 0;
|
||||
var _loc5_:b2Body = null;
|
||||
var _loc6_:b2Joint = null;
|
||||
var _loc8_:int = 0;
|
||||
var _loc10_:Boolean = false;
|
||||
var _loc12_:Boolean = false;
|
||||
var _loc14_:Boolean = false;
|
||||
var _loc15_:Number = NaN;
|
||||
var _loc13_:Number = NaN;
|
||||
var _loc9_:Number = NaN;
|
||||
_loc7_ = 0;
|
||||
while(_loc7_ < m_bodyCount)
|
||||
{
|
||||
_loc5_ = m_bodies[_loc7_];
|
||||
if(!_loc5_.IsStatic())
|
||||
{
|
||||
_loc5_.m_linearVelocity.x += param1.dt * (param2.x + _loc5_.m_invMass * _loc5_.m_force.x);
|
||||
_loc5_.m_linearVelocity.y += param1.dt * (param2.y + _loc5_.m_invMass * _loc5_.m_force.y);
|
||||
_loc5_.m_angularVelocity += param1.dt * _loc5_.m_invI * _loc5_.m_torque;
|
||||
_loc5_.m_force.SetZero();
|
||||
_loc5_.m_torque = 0;
|
||||
_loc5_.m_linearVelocity.Multiply(b2Math.b2Clamp(1 - param1.dt * _loc5_.m_linearDamping,0,1));
|
||||
_loc5_.m_angularVelocity *= b2Math.b2Clamp(1 - param1.dt * _loc5_.m_angularDamping,0,1);
|
||||
if(_loc5_.m_linearVelocity.LengthSquared() > 40000)
|
||||
{
|
||||
_loc5_.m_linearVelocity.Normalize();
|
||||
_loc5_.m_linearVelocity.x *= 200;
|
||||
_loc5_.m_linearVelocity.y *= 200;
|
||||
}
|
||||
if(_loc5_.m_angularVelocity * _loc5_.m_angularVelocity > 62500)
|
||||
{
|
||||
if(_loc5_.m_angularVelocity < 0)
|
||||
{
|
||||
_loc5_.m_angularVelocity = -250;
|
||||
}
|
||||
else
|
||||
{
|
||||
_loc5_.m_angularVelocity = 250;
|
||||
}
|
||||
}
|
||||
}
|
||||
_loc7_++;
|
||||
}
|
||||
var _loc11_:b2ContactSolver = new b2ContactSolver(param1,m_contacts,m_contactCount,m_allocator);
|
||||
_loc11_.InitVelocityConstraints(param1);
|
||||
_loc7_ = 0;
|
||||
while(_loc7_ < m_jointCount)
|
||||
{
|
||||
_loc6_ = m_joints[_loc7_];
|
||||
_loc6_.InitVelocityConstraints(param1);
|
||||
_loc7_++;
|
||||
}
|
||||
_loc7_ = 0;
|
||||
while(_loc7_ < param1.maxIterations)
|
||||
{
|
||||
_loc11_.SolveVelocityConstraints();
|
||||
_loc8_ = 0;
|
||||
while(_loc8_ < m_jointCount)
|
||||
{
|
||||
_loc6_ = m_joints[_loc8_];
|
||||
_loc6_.SolveVelocityConstraints(param1);
|
||||
_loc8_++;
|
||||
}
|
||||
_loc7_++;
|
||||
}
|
||||
_loc11_.FinalizeVelocityConstraints();
|
||||
_loc7_ = 0;
|
||||
while(_loc7_ < m_bodyCount)
|
||||
{
|
||||
_loc5_ = m_bodies[_loc7_];
|
||||
if(!_loc5_.IsStatic())
|
||||
{
|
||||
_loc5_.m_sweep.c0.SetV(_loc5_.m_sweep.c);
|
||||
_loc5_.m_sweep.a0 = _loc5_.m_sweep.a;
|
||||
_loc5_.m_sweep.c.x += param1.dt * _loc5_.m_linearVelocity.x;
|
||||
_loc5_.m_sweep.c.y += param1.dt * _loc5_.m_linearVelocity.y;
|
||||
_loc5_.m_sweep.a += param1.dt * _loc5_.m_angularVelocity;
|
||||
_loc5_.SynchronizeTransform();
|
||||
}
|
||||
_loc7_++;
|
||||
}
|
||||
if(param3)
|
||||
{
|
||||
_loc7_ = 0;
|
||||
while(_loc7_ < m_jointCount)
|
||||
{
|
||||
_loc6_ = m_joints[_loc7_];
|
||||
_loc6_.InitPositionConstraints();
|
||||
_loc7_++;
|
||||
}
|
||||
m_positionIterationCount = 0;
|
||||
while(m_positionIterationCount < param1.maxIterations)
|
||||
{
|
||||
_loc10_ = _loc11_.SolvePositionConstraints(0.2);
|
||||
_loc12_ = true;
|
||||
_loc7_ = 0;
|
||||
while(_loc7_ < m_jointCount)
|
||||
{
|
||||
_loc6_ = m_joints[_loc7_];
|
||||
_loc14_ = _loc6_.SolvePositionConstraints();
|
||||
_loc12_ &&= _loc14_;
|
||||
_loc7_++;
|
||||
}
|
||||
if(_loc10_ && _loc12_)
|
||||
{
|
||||
break;
|
||||
}
|
||||
m_positionIterationCount = m_positionIterationCount + 1;
|
||||
}
|
||||
}
|
||||
Report(_loc11_.m_constraints);
|
||||
if(param4)
|
||||
{
|
||||
_loc15_ = 1.7976931348623157e+308;
|
||||
_loc13_ = 0.0001;
|
||||
_loc9_ = 0.0001234567901234568;
|
||||
_loc7_ = 0;
|
||||
while(_loc7_ < m_bodyCount)
|
||||
{
|
||||
_loc5_ = m_bodies[_loc7_];
|
||||
if(_loc5_.m_invMass != 0)
|
||||
{
|
||||
if((_loc5_.m_flags & b2Body.e_allowSleepFlag) == 0)
|
||||
{
|
||||
_loc5_.m_sleepTime = 0;
|
||||
_loc15_ = 0;
|
||||
}
|
||||
if((_loc5_.m_flags & b2Body.e_allowSleepFlag) == 0 || _loc5_.m_angularVelocity * _loc5_.m_angularVelocity > _loc9_ || b2Math.b2Dot(_loc5_.m_linearVelocity,_loc5_.m_linearVelocity) > _loc13_)
|
||||
{
|
||||
_loc5_.m_sleepTime = 0;
|
||||
_loc15_ = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
_loc5_.m_sleepTime += param1.dt;
|
||||
_loc15_ = b2Math.b2Min(_loc15_,_loc5_.m_sleepTime);
|
||||
}
|
||||
}
|
||||
_loc7_++;
|
||||
}
|
||||
if(_loc15_ >= 0.5)
|
||||
{
|
||||
_loc7_ = 0;
|
||||
while(_loc7_ < m_bodyCount)
|
||||
{
|
||||
_loc5_ = m_bodies[_loc7_];
|
||||
_loc5_.m_flags = _loc5_.m_flags | b2Body.e_sleepFlag;
|
||||
_loc5_.m_linearVelocity.SetZero();
|
||||
_loc5_.m_angularVelocity = 0;
|
||||
_loc7_++;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public function SolveTOI(param1:b2TimeStep) : void
|
||||
{
|
||||
var _loc5_:int = 0;
|
||||
var _loc2_:b2Body = null;
|
||||
var _loc3_:Boolean = false;
|
||||
var _loc4_:b2ContactSolver = new b2ContactSolver(param1,m_contacts,m_contactCount,m_allocator);
|
||||
_loc5_ = 0;
|
||||
while(_loc5_ < param1.maxIterations)
|
||||
{
|
||||
_loc4_.SolveVelocityConstraints();
|
||||
_loc5_++;
|
||||
}
|
||||
_loc5_ = 0;
|
||||
while(_loc5_ < m_bodyCount)
|
||||
{
|
||||
_loc2_ = m_bodies[_loc5_];
|
||||
if(!_loc2_.IsStatic())
|
||||
{
|
||||
_loc2_.m_sweep.c0.SetV(_loc2_.m_sweep.c);
|
||||
_loc2_.m_sweep.a0 = _loc2_.m_sweep.a;
|
||||
_loc2_.m_sweep.c.x += param1.dt * _loc2_.m_linearVelocity.x;
|
||||
_loc2_.m_sweep.c.y += param1.dt * _loc2_.m_linearVelocity.y;
|
||||
_loc2_.m_sweep.a += param1.dt * _loc2_.m_angularVelocity;
|
||||
_loc2_.SynchronizeTransform();
|
||||
}
|
||||
_loc5_++;
|
||||
}
|
||||
var _loc6_:Number = 0.75;
|
||||
_loc5_ = 0;
|
||||
while(_loc5_ < param1.maxIterations)
|
||||
{
|
||||
_loc3_ = _loc4_.SolvePositionConstraints(_loc6_);
|
||||
if(_loc3_)
|
||||
{
|
||||
break;
|
||||
}
|
||||
_loc5_++;
|
||||
}
|
||||
Report(_loc4_.m_constraints);
|
||||
}
|
||||
|
||||
public function Report(param1:Array) : void
|
||||
{
|
||||
var _loc14_:* = null;
|
||||
var _loc13_:* = null;
|
||||
var _loc5_:int = 0;
|
||||
var _loc4_:b2Contact = null;
|
||||
var _loc2_:b2ContactConstraint = null;
|
||||
var _loc9_:b2ContactResult = null;
|
||||
var _loc10_:b2Body = null;
|
||||
var _loc11_:int = 0;
|
||||
var _loc3_:Array = null;
|
||||
var _loc6_:int = 0;
|
||||
var _loc15_:b2Manifold = null;
|
||||
var _loc7_:int = 0;
|
||||
var _loc8_:b2ManifoldPoint = null;
|
||||
var _loc12_:b2ContactConstraintPoint = null;
|
||||
if(m_listener == null)
|
||||
{
|
||||
return;
|
||||
}
|
||||
_loc5_ = 0;
|
||||
while(_loc5_ < m_contactCount)
|
||||
{
|
||||
_loc4_ = m_contacts[_loc5_];
|
||||
_loc2_ = param1[_loc5_];
|
||||
_loc9_ = s_reportCR;
|
||||
_loc9_.shape1 = _loc4_.m_shape1;
|
||||
_loc9_.shape2 = _loc4_.m_shape2;
|
||||
_loc10_ = _loc9_.shape1.m_body;
|
||||
_loc11_ = _loc4_.m_manifoldCount;
|
||||
_loc3_ = _loc4_.GetManifolds();
|
||||
_loc6_ = 0;
|
||||
while(_loc6_ < _loc11_)
|
||||
{
|
||||
_loc15_ = _loc3_[_loc6_];
|
||||
_loc9_.normal.SetV(_loc15_.normal);
|
||||
_loc7_ = 0;
|
||||
while(_loc7_ < _loc15_.pointCount)
|
||||
{
|
||||
_loc8_ = _loc15_.points[_loc7_];
|
||||
_loc12_ = _loc2_.points[_loc7_];
|
||||
_loc9_.position = _loc10_.GetWorldPoint(_loc8_.localPoint1);
|
||||
_loc9_.normalImpulse = _loc12_.normalImpulse;
|
||||
_loc9_.tangentImpulse = _loc12_.tangentImpulse;
|
||||
_loc9_.id.key = _loc8_.id.key;
|
||||
m_listener.Result(_loc9_);
|
||||
_loc7_++;
|
||||
}
|
||||
_loc6_++;
|
||||
}
|
||||
_loc5_++;
|
||||
}
|
||||
}
|
||||
|
||||
public function AddBody(param1:b2Body) : void
|
||||
{
|
||||
m_bodies[m_bodyCount++] = param1;
|
||||
}
|
||||
|
||||
public function AddContact(param1:b2Contact) : void
|
||||
{
|
||||
m_contacts[m_contactCount++] = param1;
|
||||
}
|
||||
|
||||
public function AddJoint(param1:b2Joint) : void
|
||||
{
|
||||
m_joints[m_jointCount++] = param1;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,24 @@
|
||||
package Box2D.Dynamics
|
||||
{
|
||||
public class b2TimeStep
|
||||
{
|
||||
|
||||
public var dt:Number;
|
||||
|
||||
public var inv_dt:Number;
|
||||
|
||||
public var dtRatio:Number;
|
||||
|
||||
public var maxIterations:int;
|
||||
|
||||
public var warmStarting:Boolean;
|
||||
|
||||
public var positionCorrection:Boolean;
|
||||
|
||||
public function b2TimeStep()
|
||||
{
|
||||
super();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
File diff suppressed because it is too large.
Load diff
Reference in new issue
Block a user