/** https://github.com/kripken/box2d.js v2.3.1 */
var performance = {
now: function () {
return +new Date()
}
}
Function.prototype._extend = function (parent) {
this.prototype.parent = parent;
for (var x in parent.prototype) {
if (!this.prototype[x]) {
this.prototype[x] = parent.prototype[x]
}
}
};
Function.prototype._implement = function (parent) {
return this._extend(parent)
};
var b2Profiler = (function () {
function profileStruct(name, parent) {
this.name = name;
this.parent = parent;
this.children = {};
this.startTime = 0;
this.elapsedTime = 0;
this.totalTime = 0;
this.running = false;
this.childrenCount = 0
}
profileStruct.prototype = {
start: function () {
this.startTime = performance.now();
this.running = true
},
stop: function (reset) {
if (!this.running) {
return
}
this.running = false;
this.elapsedTime += performance.now() - this.startTime;
if (reset) {
this.start()
}
for (var x in this.children) {
this.children[x].stop()
}
},
reset: function (dontRun) {
if (!dontRun) {
this.running = true;
this.totalTime += this.elapsedTime;
this.start()
}
this.elapsedTime = 0;
for (var x in this.children) {
this.children[x].reset(true)
}
}
};
var profiles = [];
var root = new profileStruct("root");
function create(name, parent) {
if (!profiles) {
throw new Error("late profile creation not allowed")
}
var s = new profileStruct(name, parent || "root");
profiles.push(s);
return s
}
function destroy(profile) {
profile.childrenCount--;
delete profile.children[profile.name]
}
function recursiveParentCheck(node, profile) {
if (node.name === profile.parent) {
return node
}
for (var x in node.children) {
var n;
if (n = recursiveParentCheck(node.children[x], profile)) {
return n
}
}
return null
}
function init() {
while (profiles.length) {
var p = profiles.pop();
if (!(p.parentNode = recursiveParentCheck(root, p))) {
profiles.unshift(p)
} else {
p.parentNode.children[p.name] = p;
p.parentNode.childrenCount++
}
}
profiles = null
}
function resetAll() {
root.reset(true)
}
return {
create: create,
destroy: destroy,
init: init,
reset: resetAll,
profileRoot: root
}
}());
"use strict";
var b2_maxFloat = Number.MAX_VALUE;
var b2_epsilon = 2.220446049250313e-16;
var b2_pi = Math.PI;
var b2_maxManifoldPoints = 2;
var b2_maxPolygonVertices = 8;
var b2_aabbExtension = 0.1;
var b2_aabbMultiplier = 2;
var b2_linearSlop = 0.005;
var b2_angularSlop = (2 / 180 * b2_pi);
var b2_polygonRadius = (2 * b2_linearSlop);
var b2_maxSubSteps = 8;
var b2_maxTOIContacts = 32;
var b2_velocityThreshold = 1;
var b2_maxLinearCorrection = 0.2;
var b2_maxAngularCorrection = (8 / 180 * b2_pi);
var b2_maxTranslation = 2;
var b2_maxTranslationSquared = (b2_maxTranslation * b2_maxTranslation);
var b2_maxRotation = (0.5 * b2_pi);
var b2_maxRotationSquared = (b2_maxRotation * b2_maxRotation);
var b2_baumgarte = 0.2;
var b2_toiBaugarte = 0.75;
var b2_timeToSleep = 0.5;
var b2_linearSleepTolerance = 0.01;
var b2_angularSleepTolerance = (2 / 180 * b2_pi);
function b2Version(ma, mi, re) {
this.major = ma;
this.minor = mi;
this.revision = re
}
b2Version.prototype = {
toString: function () {
return this.major + "." + this.minor + "." + this.revision
}
};
var b2_version = new b2Version(2, 3, 1);
"use strict";
function b2IsValid(x) {
return isFinite(x) && !isNaN(x)
}
var sqrtf = Math.sqrt;
var atan2f = Math.atan2;
var sinf = Math.sin;
var cosf = Math.cos;
var floorf = Math.floor;
var ceilf = Math.ceil;
var b2Sqrt = sqrtf;
var b2Atan2 = atan2f;
function b2InvSqrt(x) {
return 1 / sqrtf(x)
}
function b2Vec2(x, y) {
if (typeof (x) !== "undefined") {
this.x = x;
this.y = y
} else {
this.x = this.y = 0
}
}
b2Vec2.prototype = {
Clone: function () {
return new b2Vec2(this.x, this.y)
},
SetZero: function () {
this.x = 0;
this.y = 0;
return this
},
Set: function (x_, y_) {
this.x = x_;
this.y = y_;
return this
},
Assign: function (l) {
this.x = l.x;
this.y = l.y;
return this
},
Negate: function () {
var v = new b2Vec2();
v.Set(-this.x, -this.y);
return v
},
get_i: function (i) {
switch (i) {
case 0:
return this.x;
case 1:
return this.y
}
},
set_i: function (i, v) {
switch (i) {
case 0:
return this.x = v;
case 1:
return this.y = v
}
},
Add: function (v) {
this.x += v.x;
this.y += v.y;
return this
},
Subtract: function (v) {
this.x -= v.x;
this.y -= v.y;
return this
},
Multiply: function (a) {
this.x *= a;
this.y *= a;
return this
},
Length: function () {
return b2Sqrt(this.x * this.x + this.y * this.y)
},
LengthSquared: function () {
return this.x * this.x + this.y * this.y
},
Normalize: function () {
var length = this.Length();
if (length < b2_epsilon) {
return 0
}
var invLength = 1 / length;
this.x *= invLength;
this.y *= invLength;
return length
},
IsValid: function () {
return b2IsValid(this.x) && b2IsValid(this.y)
},
Skew: function () {
return new b2Vec2(-this.y, this.x)
},
_serialize: function (out) {
var obj = out || [];
obj[0] = this.x;
obj[1] = this.y;
return obj
},
_deserialize: function (data) {
this.x = data[0];
this.y = data[1]
}
};
b2Vec2.Add = function (a, b) {
return new b2Vec2(a.x + b.x, a.y + b.y)
};
b2Vec2.Subtract = function (a, b) {
return new b2Vec2(a.x - b.x, a.y - b.y)
};
b2Vec2.Equals = function (a, b) {
return a.x == b.x && a.y == b.y
};
b2Vec2.Multiply = function (s, a) {
return new b2Vec2(s * a.x, s * a.y)
};
b2Vec2.Negate = function (a) {
return new b2Vec2(-a.x, -a.y)
};
function b2Vec3(x, y, z) {
if (typeof (x) !== "undefined") {
this.x = x;
this.y = y;
this.z = z
}
}
b2Vec3.prototype = {
Clone: function () {
return new b2Vec3(this.x, this.y, this.z)
},
SetZero: function () {
this.x = 0;
this.y = 0;
this.z = 0
},
Set: function (x_, y_, z_) {
this.x = x_;
this.y = y_;
this.z = z_
},
Negate: function () {
var v = new b2Vec3();
v.Set(-this.x, -this.y, -this.z);
return v
},
Add: function (v) {
this.x += v.x;
this.y += v.y;
this.z += v.z
},
Subtract: function (v) {
this.x -= v.x;
this.y -= v.y;
this.z -= v.z
},
Multiply: function (s) {
this.x *= s;
this.y *= s;
this.z *= s
},
x: 0,
y: 0,
z: 0
};
b2Vec3.Multiply = function (s, a) {
return new b2Vec3(s * a.x, s * a.y, s * a.z)
};
b2Vec3.Add = function (a, b) {
return new b2Vec3(a.x + b.x, a.y + b.y, a.z + b.z)
};
b2Vec3.Subtract = function (a, b) {
return new b2Vec3(a.x - b.x, a.y - b.y, a.z - b.z)
};
function b2Mat22(c1, c2) {
this.ex = c1 ? c1.Clone() : new b2Vec2();
this.ey = c2 ? c2.Clone() : new b2Vec2()
}
b2Mat22.prototype = {
Set: function (c1, c2) {
this.ex.Assign(c1);
this.ey.Assign(c2)
},
Assign: function (mat) {
this.ex.Assign(mat.ex);
this.ey.Assign(mat.ey)
},
SetIdentity: function () {
this.ex.x = 1;
this.ey.x = 0;
this.ex.y = 0;
this.ey.y = 1
},
SetZero: function () {
this.ex.x = 0;
this.ey.x = 0;
this.ex.y = 0;
this.ey.y = 0
},
GetInverse: function () {
var a = this.ex.x,
b = this.ey.x,
c = this.ex.y,
d = this.ey.y;
var B = new b2Mat22();
var det = a * d - b * c;
if (det != 0) {
det = 1 / det
}
B.ex.x = det * d;
B.ey.x = -det * b;
B.ex.y = -det * c;
B.ey.y = det * a;
return B
},
Solve: function (b) {
var a11 = this.ex.x,
a12 = this.ey.x,
a21 = this.ex.y,
a22 = this.ey.y;
var det = a11 * a22 - a12 * a21;
if (det != 0) {
det = 1 / det
}
var x = new b2Vec2();
x.x = det * (a22 * b.x - a12 * b.y);
x.y = det * (a11 * b.y - a21 * b.x);
return x
}
};
b2Mat22.Add = function (A, B) {
return new b2Mat22(b2Vec2.Add(A.ex, B.ex), b2Vec2.Add(A.ey, B.ey))
};
function b2Mat33(c1, c2, c3) {
this.ex = c1 ? c1.Clone() : new b2Vec3();
this.ey = c2 ? c2.Clone() : new b2Vec3();
this.ez = c3 ? c3.Clone() : new b2Vec3()
}
b2Mat33.prototype = {
SetZero: function () {
this.ex.SetZero();
this.ey.SetZero();
this.ez.SetZero()
},
Solve33: function (b) {
var det = b2Dot_v3_v3(this.ex, b2Cross_v3_v3(this.ey, this.ez));
if (det != 0) {
det = 1 / det
}
var x = new b2Vec3();
x.x = det * b2Dot_v3_v3(b, b2Cross_v3_v3(this.ey, this.ez));
x.y = det * b2Dot_v3_v3(this.ex, b2Cross_v3_v3(b, this.ez));
x.z = det * b2Dot_v3_v3(this.ex, b2Cross_v3_v3(this.ey, b));
return x
},
Solve22: function (b) {
var a11 = this.ex.x,
a12 = this.ey.x,
a21 = this.ex.y,
a22 = this.ey.y;
var det = a11 * a22 - a12 * a21;
if (det != 0) {
det = 1 / det
}
var x = new b2Vec2();
x.x = det * (a22 * b.x - a12 * b.y);
x.y = det * (a11 * b.y - a21 * b.x);
return x
},
GetInverse22: function (M) {
var a = this.ex.x,
b = this.ey.x,
c = this.ex.y,
d = this.ey.y;
var det = a * d - b * c;
if (det != 0) {
det = 1 / det
}
M.ex.x = det * d;
M.ey.x = -det * b;
M.ex.z = 0;
M.ex.y = -det * c;
M.ey.y = det * a;
M.ey.z = 0;
M.ez.x = 0;
M.ez.y = 0;
M.ez.z = 0
},
GetSymInverse33: function (M) {
var det = b2Dot_v3_v3(this.ex, b2Cross_v3_v3(this.ey, this.ez));
if (det != 0) {
det = 1 / det
}
var a11 = this.ex.x,
a12 = this.ey.x,
a13 = this.ez.x;
var a22 = this.ey.y,
a23 = this.ez.y;
var a33 = this.ez.z;
M.ex.x = det * (a22 * a33 - a23 * a23);
M.ex.y = det * (a13 * a23 - a12 * a33);
M.ex.z = det * (a12 * a23 - a13 * a22);
M.ey.x = M.ex.y;
M.ey.y = det * (a11 * a33 - a13 * a13);
M.ey.z = det * (a13 * a12 - a11 * a23);
M.ez.x = M.ex.z;
M.ez.y = M.ey.z;
M.ez.z = det * (a11 * a22 - a12 * a12)
}
};
function b2Rot(angle, c) {
if (typeof (c) !== "undefined") {
this.s = angle;
this.c = c
} else {
if (typeof (angle) !== "undefined") {
this.Set(angle)
}
}
}
b2Rot.prototype = {
Clone: function () {
return new b2Rot(this.s, this.c)
},
Assign: function (l) {
this.s = l.s;
this.c = l.c
},
Set: function (x) {
this.s = sinf(x);
this.c = cosf(x)
},
SetIdentity: function () {
this.s = 0;
this.c = 1
},
GetAngle: function () {
return b2Atan2(this.s, this.c)
},
GetXAxis: function () {
return new b2Vec2(this.c, this.s)
},
GetYAxis: function () {
return new b2Vec2(-this.s, this.c)
},
s: 0,
c: 1
};
function b2Transform(position, rotation) {
this.p = new b2Vec2();
this.q = new b2Rot();
if (position) {
this.p.Assign(position);
this.q.Assign(rotation)
}
}
b2Transform.prototype = {
Clone: function () {
var xf = new b2Transform(this.p, this.q);
return xf
},
Assign: function (xf) {
this.p.Assign(xf.p);
this.q.Assign(xf.q)
},
SetIdentity: function () {
this.p.SetZero();
this.q.SetIdentity()
},
Set: function (position, angle) {
this.p.Assign(position);
this.q.Set(angle)
}
};
function b2Sweep() {
this.localCenter = new b2Vec2();
this.c0 = new b2Vec2();
this.c = new b2Vec2()
}
b2Sweep.prototype = {
Assign: function (sweep) {
this.localCenter.Assign(sweep.localCenter);
this.c0.Assign(sweep.c0);
this.c.Assign(sweep.c);
this.a = sweep.a;
this.a0 = sweep.a0;
this.alpha0 = sweep.alpha0
},
Clone: function () {
var sweep = new b2Sweep();
sweep.localCenter.Assign(this.localCenter);
sweep.c0.Assign(this.c0);
sweep.c.Assign(this.c);
sweep.a = this.a;
sweep.a0 = this.a0;
sweep.alpha0 = this.alpha0;
return sweep
},
GetTransform: function (xf, beta) {
xf.p.x = ((1 - beta) * this.c0.x) + (beta * this.c.x);
xf.p.y = ((1 - beta) * this.c0.y) + (beta * this.c.y);
var angle = (1 - beta) * this.a0 + beta * this.a;
xf.q.Set(angle);
xf.p.x -= xf.q.c * this.localCenter.x - xf.q.s * this.localCenter.y;
xf.p.y -= xf.q.s * this.localCenter.x + xf.q.c * this.localCenter.y
},
Advance: function (alpha) {
var beta = (alpha - this.alpha0) / (1 - this.alpha0);
this.c0.Add(b2Vec2.Multiply(beta, b2Vec2.Subtract(this.c, this.c0)));
this.a0 += beta * (this.a - this.a0);
this.alpha0 = alpha
},
Normalize: function () {
var twoPi = 2 * b2_pi;
var d = twoPi * floorf(this.a0 / twoPi);
this.a0 -= d;
this.a -= d
},
a0: 0,
a: 0,
alpha0: 0
};
function b2Dot_v2_v2(a, b) {
return a.x * b.x + a.y * b.y
}
function b2Cross_v2_v2(a, b) {
return a.x * b.y - a.y * b.x
}
function b2Cross_v2_f(a, s) {
return new b2Vec2(s * a.y, -s * a.x)
}
function b2Cross_f_v2(s, a) {
return new b2Vec2(-s * a.y, s * a.x)
}
function b2Mul_m22_v2(A, v) {
return new b2Vec2(A.ex.x * v.x + A.ey.x * v.y, A.ex.y * v.x + A.ey.y * v.y)
}
function b2MulT_m22_v2(A, v) {
return new b2Vec2(b2Dot_v2_v2(v, A.ex), b2Dot_v2_v2(v, A.ey))
}
function b2Distance(a, b) {
var c = b2Vec2.Subtract(a, b);
return c.Length()
}
function b2DistanceSquared(a, b) {
var c = b2Vec2.Subtract(a, b);
return b2Dot_v2_v2(c, c)
}
function b2Dot_v3_v3(a, b) {
return a.x * b.x + a.y * b.y + a.z * b.z
}
function b2Cross_v3_v3(a, b) {
return new b2Vec3(a.y * b.z - a.z * b.y, a.z * b.x - a.x * b.z, a.x * b.y - a.y * b.x)
}
function b2Mul_m22_m22(A, B) {
return new b2Mat22(b2Mul_m22_v2(A, B.ex), b2Mul_m22_v2(A, B.ey))
}
function b2MulT_m22_m22(A, B) {
var c1 = new b2Vec2(b2Dot_v2_v2(A.ex, B.ex), b2Dot_v2_v2(A.ey, B.ex));
var c2 = new b2Vec2(b2Dot_v2_v2(A.ex, B.ey), b2Dot_v2_v2(A.ey, B.ey));
return new b2Mat22(c1, c2)
}
function b2Mul_m33_v3(A, v) {
return b2Vec3.Add(b2Vec3.Add(b2Vec3.Multiply(v.x, A.ex), b2Vec3.Multiply(v.y, A.ey)), b2Vec3.Multiply(v.z, A.ez))
}
function b2Mul22_m33_v2(A, v) {
return new b2Vec2(A.ex.x * v.x + A.ey.x * v.y, A.ex.y * v.x + A.ey.y * v.y)
}
function b2Mul_r_r(q, r) {
var qr = new b2Rot();
qr.s = q.s * r.c + q.c * r.s;
qr.c = q.c * r.c - q.s * r.s;
return qr
}
function b2MulT_r_r(q, r) {
var qr = new b2Rot();
qr.s = q.c * r.s - q.s * r.c;
qr.c = q.c * r.c + q.s * r.s;
return qr
}
function b2Mul_r_v2(q, v) {
return new b2Vec2(q.c * v.x - q.s * v.y, q.s * v.x + q.c * v.y)
}
function b2MulT_r_v2(q, v) {
return new b2Vec2(q.c * v.x + q.s * v.y, -q.s * v.x + q.c * v.y)
}
function b2Mul_t_v2(T, v) {
return new b2Vec2((T.q.c * v.x - T.q.s * v.y) + T.p.x, (T.q.s * v.x + T.q.c * v.y) + T.p.y)
}
function b2MulT_t_v2(T, v) {
var px = v.x - T.p.x;
var py = v.y - T.p.y;
var x = (T.q.c * px + T.q.s * py);
var y = (-T.q.s * px + T.q.c * py);
return new b2Vec2(x, y)
}
function b2Mul_t_t(A, B) {
var C = new b2Transform();
C.q = b2Mul_r_r(A.q, B.q);
C.p = b2Vec2.Add(b2Mul_r_v2(A.q, B.p), A.p);
return C
}
function b2MulT_t_t(A, B) {
var C = new b2Transform();
C.q = b2MulT_r_r(A.q, B.q);
var tvx = B.p.x - A.p.x;
var tvy = B.p.y - A.p.y;
C.p.x = A.q.c * tvx + A.q.s * tvy;
C.p.y = -A.q.s * tvx + A.q.c * tvy;
return C
}
var b2Abs = Math.abs;
function b2Abs_v2(a) {
return new b2Vec2(b2Abs(a.x), b2Abs(a.y))
}
function b2Abs_m22(A) {
return new b2Mat22(b2Abs_v2(A.ex), b2Abs_v2(A.ey))
}
var b2Min = Math.min;
function b2Min_v2(a, b) {
return new b2Vec2(b2Min(a.x, b.x), b2Min(a.y, b.y))
}
var b2Max = Math.max;
function b2Max_v2(a, b) {
return new b2Vec2(b2Max(a.x, b.x), b2Max(a.y, b.y))
}
function b2Clamp(a, low, high) {
return b2Max(low, b2Min(a, high))
}
function b2Clamp_v2(a, low, high) {
return b2Max_v2(low, b2Min_v2(a, high))
}
function b2NextPowerOfTwo(x) {
x |= (x >> 1);
x |= (x >> 2);
x |= (x >> 4);
x |= (x >> 8);
x |= (x >> 16);
return x + 1
}
function b2IsPowerOfTwo(x) {
var result = x > 0 && (x & (x - 1)) == 0;
return result
}
var RAND_LIMIT = 32767;
function b2RandomFloat(lo, hi) {
var r = Math.random();
if (typeof (lo) !== "undefined") {
r = (hi - lo) * r + lo
} else {
r = 2 * r - 1
}
return r
}
"use strict";
function b2Color(r, g, b) {
this.r = r || 0;
this.g = g || 0;
this.b = b || 0
}
b2Color.prototype = {
Set: function (r, g, b) {
this.r = r;
this.g = g;
this.b = b
}
};
function b2Draw() {}
b2Draw.prototype = {
SetFlags: function (flags) {
this.m_drawFlags = flags
},
GetFlags: function () {
return this.m_drawFlags
},
AppendFlags: function (flags) {
this.m_drawFlags |= flags
},
ClearFlags: function (flags) {
this.m_drawFlags &= ~flags
},
ToggleFlags: function (flags) {
this.m_drawFlags ^= flags
},
DrawPolygon: function (vertices, vertexCount, color) {},
DrawSolidPolygon: function (vertices, vertexCount, color) {},
DrawCircle: function (center, radius, color) {},
DrawSolidCircle: function (center, radius, axis, color) {},
DrawSegment: function (p1, p2, color) {},
DrawTransform: function (xf) {},
m_drawFlags: 0
};
b2Draw.e_shapeBit = 1;
b2Draw.e_jointBit = 2;
b2Draw.e_aabbBit = 4;
b2Draw.e_centerOfMassBit = 8;
b2Draw.e_contactPoints = 16;
b2Draw.e_contactNormals = 32;
b2Draw.e_contactImpulses = 64;
b2Draw.e_frictionImpulses = 128;
b2Draw.e_statistics = 256;
b2Draw.e_profile = 512;
b2Draw.e_pairBit = 1024;
"use strict";
function b2Timer() {
this.Reset()
}
b2Timer.prototype = {
Reset: function () {
this.m_start = performance.now()
},
GetMilliseconds: function () {
return performance.now() - this.m_start
}
};
"use strict";
function b2MassData() {
this.mass = 0;
this.center = new b2Vec2();
this.I = 0
}
function b2Shape() {
this.m_type = 0;
this.m_radius = 0
}
b2Shape.prototype = {
Clone: function () {},
GetType: function () {
return this.m_type
},
GetChildCount: function () {},
TestPoint: function (xf, p) {},
RayCast: function (output, input, transform, childIndex) {},
ComputeAABB: function (aabb, xf, childIndex) {},
ComputeMass: function (massData, density) {},
_serialize: function (out) {
var obj = out || {};
obj.m_type = this.m_type;
obj.m_radius = this.m_radius;
return obj
},
_deserialize: function (data) {
this.m_radius = data.m_radius
}
};
b2Shape.e_circle = 0;
b2Shape.e_edge = 1;
b2Shape.e_polygon = 2;
b2Shape.e_chain = 3;
b2Shape.e_typeCount = 4;
"use strict";
function b2CircleShape() {
this.parent.call(this);
this.m_type = b2Shape.e_circle;
this.m_radius = 0;
this.m_p = new b2Vec2();
Object.seal(this)
}
b2CircleShape.prototype = {
Clone: function () {
var shape = new b2CircleShape();
shape.m_radius = this.m_radius;
shape.m_p = this.m_p.Clone();
return shape
},
GetChildCount: function () {
return 1
},
TestPoint: function (transform, p) {
var center = b2Vec2.Add(transform.p, b2Mul_r_v2(transform.q, this.m_p));
var d = b2Vec2.Subtract(p, center);
return b2Dot_v2_v2(d, d) <= this.m_radius * this.m_radius
},
RayCast: function (output, input, transform, childIndex) {
var position = b2Vec2.Add(transform.p, b2Mul_r_v2(transform.q, this.m_p));
var s = b2Vec2.Subtract(input.p1, position);
var b = b2Dot_v2_v2(s, s) - this.m_radius * this.m_radius;
var r = b2Vec2.Subtract(input.p2, input.p1);
var c = b2Dot_v2_v2(s, r);
var rr = b2Dot_v2_v2(r, r);
var sigma = c * c - rr * b;
if (sigma < 0 || rr < b2_epsilon) {
return false
}
var a = -(c + b2Sqrt(sigma));
if (0 <= a && a <= input.maxFraction * rr) {
a /= rr;
output.fraction = a;
output.normal = b2Vec2.Add(s, b2Vec2.Multiply(a, r));
output.normal.Normalize();
return true
}
return false
},
ComputeAABB: function (aabb, transform, childIndex) {
var px = transform.p.x + (transform.q.c * this.m_p.x - transform.q.s * this.m_p.y);
var py = transform.p.y + (transform.q.s * this.m_p.x + transform.q.c * this.m_p.y);
aabb.lowerBound.x = px - this.m_radius;
aabb.lowerBound.y = py - this.m_radius;
aabb.upperBound.x = px + this.m_radius;
aabb.upperBound.y = py + this.m_radius
},
ComputeMass: function (massData, density) {
massData.mass = density * b2_pi * this.m_radius * this.m_radius;
massData.center = this.m_p;
massData.I = massData.mass * (0.5 * this.m_radius * this.m_radius + b2Dot_v2_v2(this.m_p, this.m_p))
},
GetSupport: function (d) {
return 0
},
GetSupportVertex: function (d) {
return this.m_p
},
GetVertexCount: function () {
return 1
},
GetVertex: function (index) {
return this.m_p
},
_serialize: function (out) {
var obj = out || {};
this.parent.prototype._serialize.call(this, obj);
obj.m_p = this.m_p._serialize();
return obj
},
_deserialize: function (data) {
this.parent.prototype._deserialize.call(this, data);
this.m_p._deserialize(data.m_p)
}
};
b2CircleShape._extend(b2Shape);
"use strict";
function b2EdgeShape() {
this.parent.call(this);
this.m_type = b2Shape.e_edge;
this.m_radius = b2_polygonRadius;
this.m_vertex0 = new b2Vec2();
this.m_vertex1 = new b2Vec2();
this.m_vertex2 = new b2Vec2();
this.m_vertex3 = new b2Vec2();
this.m_hasVertex0 = false;
this.m_hasVertex3 = false;
Object.seal(this)
}
b2EdgeShape.prototype = {
Set: function (v1, v2) {
this.m_vertex1.Assign(v1);
this.m_vertex2.Assign(v2);
this.m_hasVertex0 = false;
this.m_hasVertex3 = false
},
Clone: function () {
var shape = new b2EdgeShape();
shape.m_vertex0 = this.m_vertex0.Clone();
shape.m_vertex1 = this.m_vertex1.Clone();
shape.m_vertex2 = this.m_vertex2.Clone();
shape.m_vertex3 = this.m_vertex3.Clone();
shape.m_hasVertex0 = this.m_hasVertex0;
shape.m_hasVertex3 = this.m_hasVertex3;
return shape
},
GetChildCount: function () {
return 1
},
TestPoint: function (transform, p) {
return false
},
RayCast: function (output, input, xf, childIndex) {
var p1 = b2MulT_r_v2(xf.q, b2Vec2.Subtract(input.p1, xf.p));
var p2 = b2MulT_r_v2(xf.q, b2Vec2.Subtract(input.p2, xf.p));
var d = b2Vec2.Subtract(p2, p1);
var v1 = this.m_vertex1;
var v2 = this.m_vertex2;
var e = b2Vec2.Subtract(v2, v1);
var normal = new b2Vec2(e.y, -e.x);
normal.Normalize();
var numerator = b2Dot_v2_v2(normal, b2Vec2.Subtract(v1, p1));
var denominator = b2Dot_v2_v2(normal, d);
if (denominator == 0) {
return false
}
var t = numerator / denominator;
if (t < 0 || input.maxFraction < t) {
return false
}
var q = b2Vec2.Add(p1, b2Vec2.Multiply(t, d));
var r = b2Vec2.Subtract(v2, v1);
var rr = b2Dot_v2_v2(r, r);
if (rr == 0) {
return false
}
var s = b2Dot_v2_v2(b2Vec2.Subtract(q, v1), r) / rr;
if (s < 0 || 1 < s) {
return false
}
output.fraction = t;
if (numerator > 0) {
output.normal = b2Mul_r_v2(xf.q, normal).Negate()
} else {
output.normal = b2Mul_r_v2(xf.q, normal)
}
return true
},
ComputeAABB: function (aabb, xf, childIndex) {
var v1x = (xf.q.c * this.m_vertex1.x - xf.q.s * this.m_vertex1.y) + xf.p.x;
var v1y = (xf.q.s * this.m_vertex1.x + xf.q.c * this.m_vertex1.y) + xf.p.y;
var v2x = (xf.q.c * this.m_vertex2.x - xf.q.s * this.m_vertex2.y) + xf.p.x;
var v2y = (xf.q.s * this.m_vertex2.x + xf.q.c * this.m_vertex2.y) + xf.p.y;
var lowerx = b2Min(v1x, v2x);
var lowery = b2Min(v1y, v2y);
var upperx = b2Max(v1x, v2x);
var uppery = b2Max(v1y, v2y);
aabb.lowerBound.x = lowerx - this.m_radius;
aabb.lowerBound.y = lowery - this.m_radius;
aabb.upperBound.x = upperx + this.m_radius;
aabb.upperBound.y = uppery + this.m_radius
},
ComputeMass: function (massData, density) {
massData.mass = 0;
massData.center = b2Vec2.Multiply(0.5, b2Vec2.Add(this.m_vertex1, this.m_vertex2));
massData.I = 0
},
_serialize: function (out) {
var obj = out || {};
this.parent.prototype._serialize.call(this, obj);
obj.m_vertex1 = this.m_vertex1._serialize();
obj.m_vertex2 = this.m_vertex2._serialize();
obj.m_hasVertex0 = this.m_hasVertex0;
if (this.m_hasVertex0) {
obj.m_vertex0 = this.m_vertex0._serialize()
}
obj.m_hasVertex3 = this.m_hasVertex3;
if (this.m_hasVertex3) {
obj.m_vertex3 = this.m_vertex3._serialize()
}
return obj
},
_deserialize: function (data) {
this.parent.prototype._deserialize.call(this, data);
this.m_vertex1._deserialize(data.m_vertex1);
this.m_vertex2._deserialize(data.m_vertex2);
this.m_hasVertex0 = data.m_hasVertex0;
if (this.m_hasVertex0) {
this.m_vertex0._deserialize(data.m_vertex0)
}
this.m_hasVertex3 = data.m_hasVertex3;
if (this.m_hasVertex3) {
this.m_vertex3._deserialize(data.m_vertex3)
}
}
};
b2EdgeShape._extend(b2Shape);
"use strict";
function b2ChainShape() {
this.parent.call(this);
this.m_type = b2Shape.e_chain;
this.m_radius = b2_polygonRadius;
this.m_vertices = null;
this.m_count = 0;
this.m_prevVertex = new b2Vec2();
this.m_nextVertex = new b2Vec2();
this.m_hasPrevVertex = false;
this.m_hasNextVertex = false;
Object.seal(this)
}
b2ChainShape.prototype = {
CreateLoop: function (vertices, count) {
for (var i = 1; i < count; ++i) {
var v1 = vertices[i - 1];
var v2 = vertices[i]
}
this.m_count = count + 1;
this.m_vertices = new Array(this.m_count);
for (var i = 0; i < count; ++i) {
this.m_vertices[i] = vertices[i].Clone()
}
this.m_vertices[count] = this.m_vertices[0].Clone();
this.m_prevVertex.Assign(this.m_vertices[this.m_count - 2]);
this.m_nextVertex.Assign(this.m_vertices[1]);
this.m_hasPrevVertex = true;
this.m_hasNextVertex = true
},
CreateChain: function (vertices, count) {
for (var i = 1; i < count; ++i) {
var v1 = vertices[i - 1];
var v2 = vertices[i]
}
this.m_count = count;
this.m_vertices = new Array(count);
for (var i = 0; i < count; ++i) {
this.m_vertices[i] = vertices[i].Clone()
}
this.m_hasPrevVertex = false;
this.m_hasNextVertex = false;
this.m_prevVertex.SetZero();
this.m_nextVertex.SetZero()
},
SetPrevVertex: function (prevVertex) {
this.m_prevVertex.Assign(prevVertex);
this.m_hasPrevVertex = true
},
SetNextVertex: function (nextVertex) {
this.m_nextVertex.Assign(nextVertex);
this.m_hasNextVertex = true
},
Clone: function () {
var shape = new b2ChainShape();
shape.m_count = this.m_count;
shape.m_vertices = new Array(this.m_count);
for (var i = 0; i < this.m_count; ++i) {
shape.m_vertices[i] = this.m_vertices[i].Clone()
}
shape.m_prevVertex = this.m_prevVertex.Clone();
shape.m_nextVertex = this.m_nextVertex.Clone();
shape.m_hasPrevVertex = this.m_hasPrevVertex;
shape.m_hasNextVertex = this.m_hasNextVertex;
return shape
},
GetChildCount: function () {
return this.m_count - 1
},
GetChildEdge: function (edge, index) {
edge.m_type = b2Shape.e_edge;
edge.m_radius = this.m_radius;
edge.m_vertex1 = this.m_vertices[index + 0];
edge.m_vertex2 = this.m_vertices[index + 1];
if (index > 0) {
edge.m_vertex0 = this.m_vertices[index - 1];
edge.m_hasVertex0 = true
} else {
edge.m_vertex0 = this.m_prevVertex;
edge.m_hasVertex0 = this.m_hasPrevVertex
}
if (index < this.m_count - 2) {
edge.m_vertex3 = this.m_vertices[index + 2];
edge.m_hasVertex3 = true
} else {
edge.m_vertex3 = this.m_nextVertex;
edge.m_hasVertex3 = this.m_hasNextVertex
}
},
TestPoint: function (transform, p) {
return false
},
RayCast: function (output, input, xf, childIndex) {
var edgeShape = new b2EdgeShape();
var i1 = childIndex;
var i2 = childIndex + 1;
if (i2 == this.m_count) {
i2 = 0
}
edgeShape.m_vertex1 = this.m_vertices[i1].Clone();
edgeShape.m_vertex2 = this.m_vertices[i2].Clone();
return edgeShape.RayCast(output, input, xf, 0)
},
ComputeAABB: function (aabb, xf, childIndex) {
var i1 = childIndex;
var i2 = childIndex + 1;
if (i2 == this.m_count) {
i2 = 0
}
var v1x = (xf.q.c * this.m_vertices[i1].x - xf.q.s * this.m_vertices[i1].y) + xf.p.x;
var v1y = (xf.q.s * this.m_vertices[i1].x + xf.q.c * this.m_vertices[i1].y) + xf.p.y;
var v2x = (xf.q.c * this.m_vertices[i2].x - xf.q.s * this.m_vertices[i2].y) + xf.p.x;
var v2y = (xf.q.s * this.m_vertices[i2].x + xf.q.c * this.m_vertices[i2].y) + xf.p.y;
aabb.lowerBound.x = b2Min(v1x, v2x);
aabb.lowerBound.y = b2Min(v1y, v2y);
aabb.upperBound.x = b2Max(v1x, v2x);
aabb.upperBound.y = b2Max(v1y, v2y)
},
ComputeMass: function (massData, density) {
massData.mass = 0;
massData.center.SetZero();
massData.I = 0
},
_serialize: function (out) {
var obj = out || {};
this.parent.prototype._serialize.call(this, obj);
obj.m_count = this.m_count;
obj.m_vertices = [];
for (var i = 0; i < this.m_count; ++i) {
obj.m_vertices.push(this.m_vertices[i]._serialize())
}
obj.m_hasPrevVertex = this.m_hasPrevVertex;
if (this.m_hasPrevVertex) {
obj.m_prevVertex = this.m_prevVertex._serialize()
}
obj.m_hasNextVertex = this.m_hasNextVertex;
if (this.m_hasNextVertex) {
obj.m_nextVertex = this.m_nextVertex._serialize()
}
return obj
},
_deserialize: function (data) {
this.parent.prototype._deserialize.call(this, data);
this.m_count = data.m_count;
this.m_vertices = [];
for (var i = 0; i < this.m_count; ++i) {
this.m_vertices[i] = new b2Vec2();
this.m_vertices[i]._deserialize(data.m_vertices[i])
}
this.m_hasPrevVertex = data.m_hasPrevVertex;
if (this.m_hasPrevVertex) {
this.m_prevVertex._deserialize(data.m_prevVertex)
}
this.m_hasNextVertex = data.m_hasNextVertex;
if (this.m_hasNextVertex) {
this.m_nextVertex._deserialize(data.m_nextVertex)
}
}
};
b2ChainShape._extend(b2Shape);
"use strict";
function b2PolygonShape() {
this.parent.call(this);
this.m_type = b2Shape.e_polygon;
this.m_radius = b2_polygonRadius;
this.m_count = 0;
this.m_centroid = new b2Vec2();
this.m_vertices = new Array(b2_maxPolygonVertices);
this.m_normals = new Array(b2_maxPolygonVertices);
Object.seal(this)
}
b2PolygonShape.prototype = {
Clone: function () {
var shape = new b2PolygonShape();
shape.m_count = this.m_count;
shape.m_centroid = this.m_centroid.Clone();
for (var i = 0; i < this.m_count; ++i) {
shape.m_vertices[i] = this.m_vertices[i].Clone();
shape.m_normals[i] = this.m_normals[i].Clone()
}
return shape
},
GetChildCount: function () {
return 1
},
Set: function (vertices, count) {
if (count < 3) {
this.SetAsBox(1, 1);
return
}
var n = b2Min(count, b2_maxPolygonVertices);
var ps = new Array(b2_maxPolygonVertices);
var tempCount = 0;
for (var i = 0; i < n; ++i) {
var v = vertices[i];
var unique = true;
for (var j = 0; j < tempCount; ++j) {
if (b2DistanceSquared(v, ps[j]) < 0.5 * b2_linearSlop) {
unique = false;
break
}
}
if (unique) {
ps[tempCount++] = v.Clone()
}
}
n = tempCount;
if (n < 3) {
this.SetAsBox(1, 1);
return
}
var i0 = 0;
var x0 = ps[0].x;
for (i = 1; i < n; ++i) {
var x = ps[i].x;
if (x > x0 || (x == x0 && ps[i].y < ps[i0].y)) {
i0 = i;
x0 = x
}
}
var hull = new Array(b2_maxPolygonVertices);
var m = 0;
var ih = i0;
for (;;) {
hull[m] = ih;
var ie = 0;
for (j = 1; j < n; ++j) {
if (ie == ih) {
ie = j;
continue
}
var r = b2Vec2.Subtract(ps[ie], ps[hull[m]]);
var v = b2Vec2.Subtract(ps[j], ps[hull[m]]);
var c = b2Cross_v2_v2(r, v);
if (c < 0) {
ie = j
}
if (c == 0 && v.LengthSquared() > r.LengthSquared()) {
ie = j
}
}++m;
ih = ie;
if (ie == i0) {
break
}
}
this.m_count = m;
for (i = 0; i < m; ++i) {
this.m_vertices[i] = ps[hull[i]].Clone()
}
for (i = 0; i < m; ++i) {
var i1 = i;
var i2 = i + 1 < m ? i + 1 : 0;
var edge = b2Vec2.Subtract(this.m_vertices[i2], this.m_vertices[i1]);
this.m_normals[i] = b2Cross_v2_f(edge, 1).Clone();
this.m_normals[i].Normalize()
}
this.m_centroid = b2PolygonShape.ComputeCentroid(this.m_vertices, m)
},
SetAsBox: function (hx, hy, center, angle) {
this.m_count = 4;
this.m_vertices[0] = new b2Vec2(-hx, -hy);
this.m_vertices[1] = new b2Vec2(hx, -hy);
this.m_vertices[2] = new b2Vec2(hx, hy);
this.m_vertices[3] = new b2Vec2(-hx, hy);
this.m_normals[0] = new b2Vec2(0, -1);
this.m_normals[1] = new b2Vec2(1, 0);
this.m_normals[2] = new b2Vec2(0, 1);
this.m_normals[3] = new b2Vec2(-1, 0);
if (!center) {
return
}
this.m_centroid.Assign(center);
var xf = new b2Transform();
xf.p = center;
xf.q.Set(angle);
for (var i = 0; i < this.m_count; ++i) {
this.m_vertices[i].Assign(b2Mul_t_v2(xf, this.m_vertices[i]));
this.m_normals[i].Assign(b2Mul_r_v2(xf.q, this.m_normals[i]))
}
},
TestPoint: function (xf, p) {
var pLocal = b2MulT_r_v2(xf.q, b2Vec2.Subtract(p, xf.p));
for (var i = 0; i < this.m_count; ++i) {
var dot = b2Dot_v2_v2(this.m_normals[i], b2Vec2.Subtract(pLocal, this.m_vertices[i]));
if (dot > 0) {
return false
}
}
return true
},
RayCast: function (output, input, xf, childIndex) {
var p1 = b2MulT_r_v2(xf.q, b2Vec2.Subtract(input.p1, xf.p));
var p2 = b2MulT_r_v2(xf.q, b2Vec2.Subtract(input.p2, xf.p));
var d = b2Vec2.Subtract(p2, p1);
var lower = 0,
upper = input.maxFraction;
var index = -1;
for (var i = 0; i < this.m_count; ++i) {
var numerator = b2Dot_v2_v2(this.m_normals[i], b2Vec2.Subtract(this.m_vertices[i], p1));
var denominator = b2Dot_v2_v2(this.m_normals[i], d);
if (denominator == 0) {
if (numerator < 0) {
return false
}
} else {
if (denominator < 0 && numerator < lower * denominator) {
lower = numerator / denominator;
index = i
} else {
if (denominator > 0 && numerator < upper * denominator) {
upper = numerator / denominator
}
}
}
if (upper < lower) {
return false
}
}
if (index >= 0) {
output.fraction = lower;
output.normal = b2Mul_r_v2(xf.q, this.m_normals[index]);
return true
}
return false
},
ComputeAABB: function (aabb, xf, childIndex) {
var lowerx = (xf.q.c * this.m_vertices[0].x - xf.q.s * this.m_vertices[0].y) + xf.p.x;
var lowery = (xf.q.s * this.m_vertices[0].x + xf.q.c * this.m_vertices[0].y) + xf.p.y;
var upperx = lowerx;
var uppery = lowery;
for (var i = 1; i < this.m_count; ++i) {
var vx = (xf.q.c * this.m_vertices[i].x - xf.q.s * this.m_vertices[i].y) + xf.p.x;
var vy = (xf.q.s * this.m_vertices[i].x + xf.q.c * this.m_vertices[i].y) + xf.p.y;
lowerx = b2Min(lowerx, vx);
lowery = b2Min(lowery, vy);
upperx = b2Max(upperx, vx);
uppery = b2Max(uppery, vy)
}
aabb.lowerBound.x = lowerx - this.m_radius;
aabb.lowerBound.y = lowery - this.m_radius;
aabb.upperBound.x = upperx + this.m_radius;
aabb.upperBound.y = uppery + this.m_radius
},
ComputeMass: function (massData, density) {
var center = new b2Vec2(0, 0);
var area = 0;
var I = 0;
var s = new b2Vec2(0, 0);
for (var i = 0; i < this.m_count; ++i) {
s.Add(this.m_vertices[i])
}
s.Multiply(1 / this.m_count);
var k_inv3 = 1 / 3;
for (var i = 0; i < this.m_count; ++i) {
var e1 = b2Vec2.Subtract(this.m_vertices[i], s);
var e2 = i + 1 < this.m_count ? b2Vec2.Subtract(this.m_vertices[i + 1], s) : b2Vec2.Subtract(this.m_vertices[0], s);
var D = b2Cross_v2_v2(e1, e2);
var triangleArea = 0.5 * D;
area += triangleArea;
center.Add(b2Vec2.Multiply(triangleArea * k_inv3, b2Vec2.Add(e1, e2)));
var ex1 = e1.x,
ey1 = e1.y;
var ex2 = e2.x,
ey2 = e2.y;
var intx2 = ex1 * ex1 + ex2 * ex1 + ex2 * ex2;
var inty2 = ey1 * ey1 + ey2 * ey1 + ey2 * ey2;
I += (0.25 * k_inv3 * D) * (intx2 + inty2)
}
massData.mass = density * area;
center.Multiply(1 / area);
massData.center = b2Vec2.Add(center, s);
massData.I = density * I;
massData.I += massData.mass * (b2Dot_v2_v2(massData.center, massData.center) - b2Dot_v2_v2(center, center))
},
GetVertexCount: function () {
return this.m_count
},
GetVertex: function (index) {
return this.m_vertices[index]
},
Validate: function () {
for (var i = 0; i < this.m_count; ++i) {
var i1 = i;
var i2 = i < this.m_count - 1 ? i1 + 1 : 0;
var p = this.m_vertices[i1];
var e = b2Vec2.Subtract(this.m_vertices[i2], p);
for (var j = 0; j < this.m_count; ++j) {
if (j == i1 || j == i2) {
continue
}
var v = b2Vec2.Subtract(this.m_vertices[j], p);
var c = b2Cross_v2_v2(e, v);
if (c < 0) {
return false
}
}
}
return true
},
_serialize: function (out) {
var obj = out || {};
this.parent.prototype._serialize.call(this, obj);
obj.m_count = this.m_count;
obj.m_centroid = this.m_centroid._serialize();
obj.m_vertices = [];
obj.m_normals = [];
for (var i = 0; i < this.m_count; ++i) {
obj.m_vertices.push(this.m_vertices[i]._serialize());
obj.m_normals.push(this.m_normals[i]._serialize())
}
return obj
},
_deserialize: function (data) {
this.parent.prototype._deserialize.call(this, data);
this.m_count = data.m_count;
this.m_centroid._deserialize(data.m_centroid);
this.m_vertices = [];
this.m_normals = [];
for (var i = 0; i < this.m_count; ++i) {
this.m_vertices[i] = new b2Vec2();
this.m_vertices[i]._deserialize(data.m_vertices[i]);
this.m_normals[i] = new b2Vec2();
this.m_normals[i]._deserialize(data.m_normals[i])
}
}
};
b2PolygonShape.ComputeCentroid = function (vs, count) {
var c = new b2Vec2();
var area = 0;
var pRef = new b2Vec2(0, 0);
var inv3 = 1 / 3;
for (var i = 0; i < count; ++i) {
var p1 = pRef;
var p2 = vs[i];
var p3 = i + 1 < count ? vs[i + 1] : vs[0];
var e1 = b2Vec2.Subtract(p2, p1);
var e2 = b2Vec2.Subtract(p3, p1);
var D = b2Cross_v2_v2(e1, e2);
var triangleArea = 0.5 * D;
area += triangleArea;
c.Add(b2Vec2.Multiply(triangleArea, b2Vec2.Multiply(inv3, b2Vec2.Add(b2Vec2.Add(p1, p2), p3))))
}
c.Multiply(1 / area);
return c
};
b2PolygonShape._extend(b2Shape);
"use strict";
function b2Pair() {
this.proxyIdA = 0;
this.proxyIdB = 0
}
function b2PairLessThan(pair1, pair2) {
if (pair1.proxyIdA == pair2.proxyIdA) {
return pair1.proxyIdB - pair2.proxyIdB
}
return pair1.proxyIdA - pair2.proxyIdA
}
function b2BroadPhase() {
this.m_tree = new b2DynamicTree();
this.m_queryProxyId = 0;
this.m_proxyCount = 0;
this.m_pairCount = 0;
this.m_pairBuffer = [];
this.m_moveCount = 0;
this.m_moveBuffer = []
}
b2BroadPhase.prototype = {
CreateProxy: function (aabb, userData) {
var proxyId = this.m_tree.CreateProxy(aabb, userData);
++this.m_proxyCount;
this.BufferMove(proxyId);
return proxyId
},
DestroyProxy: function (proxyId) {
this.UnBufferMove(proxyId);
--this.m_proxyCount;
this.m_tree.DestroyProxy(proxyId)
},
MoveProxy: function (proxyId, aabb, displacement) {
var buffer = this.m_tree.MoveProxy(proxyId, aabb, displacement);
if (buffer) {
this.BufferMove(proxyId)
}
},
TouchProxy: function (proxyId) {
this.BufferMove(proxyId)
},
GetFatAABB: function (proxyId) {
return this.m_tree.GetFatAABB(proxyId)
},
GetUserData: function (proxyId) {
return this.m_tree.GetUserData(proxyId)
},
TestOverlap: function (proxyIdA, proxyIdB) {
var aabbA = this.m_tree.GetFatAABB(proxyIdA);
var aabbB = this.m_tree.GetFatAABB(proxyIdB);
return b2TestOverlap(aabbA, aabbB)
},
GetProxyCount: function () {
return this.m_proxyCount
},
UpdatePairs: function (callback) {
this.m_pairCount = 0;
this.m_pairBuffer.length = 0;
for (var i = 0; i < this.m_moveCount; ++i) {
this.m_queryProxyId = this.m_moveBuffer[i];
if (this.m_queryProxyId == b2BroadPhase.e_nullProxy) {
continue
}
var fatAABB = this.m_tree.GetFatAABB(this.m_queryProxyId);
this.m_tree.Query(this, fatAABB)
}
this.m_moveCount = 0;
this.m_pairBuffer.sort(b2PairLessThan);
var i = 0;
while (i < this.m_pairCount) {
var primaryPair = this.m_pairBuffer[i];
var userDataA = this.m_tree.GetUserData(primaryPair.proxyIdA);
var userDataB = this.m_tree.GetUserData(primaryPair.proxyIdB);
callback.AddPair(userDataA, userDataB);
++i;
while (i < this.m_pairCount) {
var pair = this.m_pairBuffer[i];
if (pair.proxyIdA != primaryPair.proxyIdA || pair.proxyIdB != primaryPair.proxyIdB) {
break
}++i
}
}
},
Query: function (callback, aabb) {
this.m_tree.Query(callback, aabb)
},
RayCast: function (callback, input) {
this.m_tree.RayCast(callback, input)
},
GetTreeHeight: function () {
return this.m_tree.GetHeight()
},
GetTreeBalance: function () {
return this.m_tree.GetMaxBalance()
},
GetTreeQuality: function () {
return this.m_tree.GetAreaRatio()
},
ShiftOrigin: function (newOrigin) {
this.m_tree.ShiftOrigin(newOrigin)
},
BufferMove: function (proxyId) {
this.m_moveBuffer[this.m_moveCount] = proxyId;
++this.m_moveCount
},
UnBufferMove: function (proxyId) {
for (var i = 0; i < this.m_moveCount; ++i) {
if (this.m_moveBuffer[i] == proxyId) {
this.m_moveBuffer[i] = b2BroadPhase.e_nullProxy
}
}
},
QueryCallback: function (proxyId) {
if (proxyId == this.m_queryProxyId) {
return true
}
this.m_pairBuffer[this.m_pairCount] = new b2Pair();
this.m_pairBuffer[this.m_pairCount].proxyIdA = b2Min(proxyId, this.m_queryProxyId);
this.m_pairBuffer[this.m_pairCount].proxyIdB = b2Max(proxyId, this.m_queryProxyId);
++this.m_pairCount;
return true
}
};
b2BroadPhase.e_nullProxy = -1;
"use strict";
function b2DistanceProxy() {
this.m_vertices = null;
this.m_count = 0;
this.m_radius = 0
}
b2DistanceProxy.prototype = {
Assign: function (l) {
this.m_vertices = l.m_vertices;
this.m_count = l.m_count;
this.m_radius = l.m_radius
},
Set: function (shape, index) {
switch (shape.GetType()) {
case b2Shape.e_circle:
var circle = shape;
this.m_vertices = [circle.m_p];
this.m_count = 1;
this.m_radius = circle.m_radius;
break;
case b2Shape.e_polygon:
var polygon = shape;
this.m_vertices = polygon.m_vertices;
this.m_count = polygon.m_count;
this.m_radius = polygon.m_radius;
break;
case b2Shape.e_chain:
var chain = shape;
this.m_vertices = [chain.m_vertices[index]];
if (index + 1 < chain.m_count) {
this.m_vertices[1] = chain.m_vertices[index + 1]
} else {
this.m_vertices[1] = chain.m_vertices[0]
}
this.m_count = 2;
this.m_radius = chain.m_radius;
break;
case b2Shape.e_edge:
var edge = shape;
this.m_vertices = [edge.m_vertex1, edge.m_vertex2];
this.m_count = 2;
this.m_radius = edge.m_radius;
break
}
},
GetSupport: function (dx, dy) {
var bestIndex = 0;
var bestValue = this.m_vertices[0].x * dx + this.m_vertices[0].y * dy;
for (var i = 1; i < this.m_count; ++i) {
var value = this.m_vertices[i].x * dx + this.m_vertices[i].y * dy;
if (value > bestValue) {
bestIndex = i;
bestValue = value
}
}
return bestIndex
},
GetSupportVertex: function (dx, dy) {
return this.m_vertices[this.GetSupport(dx, dy)]
},
GetVertexCount: function () {
return this.m_count
},
GetVertex: function (index) {
return this.m_vertices[index]
}
};
function b2SimplexCache() {
this.metric = 0;
this.count = 0;
this.indexA = [0, 0, 0];
this.indexB = [0, 0, 0]
}
function b2DistanceInput() {
this.proxyA = new b2DistanceProxy();
this.proxyB = new b2DistanceProxy();
this.transformA = new b2Transform();
this.transformB = new b2Transform();
this.useRadii = false
}
function b2DistanceOutput() {
this.pointA = new b2Vec2();
this.pointB = new b2Vec2();
this.distance = 0;
this.iterations = 0
}
function b2SimplexVertex() {
this.wA = new b2Vec2();
this.wB = new b2Vec2();
this.w = new b2Vec2();
this.a = 0;
this.indexA = 0;
this.indexB = 0
}
b2SimplexVertex.prototype = {
Assign: function (l) {
this.wA.x = l.wA.x;
this.wA.y = l.wA.y;
this.wB.x = l.wB.x;
this.wB.y = l.wB.y;
this.w.x = l.w.x;
this.w.y = l.w.y;
this.a = l.a;
this.indexA = l.indexA;
this.indexB = l.indexB
}
};
function b2Simplex() {
this.m_v = [new b2SimplexVertex(), new b2SimplexVertex(), new b2SimplexVertex()];
this.m_count = 0
}
b2Simplex.prototype = {
ReadCache: function (cache, proxyA, transformA, proxyB, transformB) {
this.m_count = cache.count;
var vertices = this.m_v;
for (var i = 0; i < this.m_count; ++i) {
var v = vertices[i];
v.indexA = cache.indexA[i];
v.indexB = cache.indexB[i];
var wALocal = proxyA.GetVertex(v.indexA);
var wBLocal = proxyB.GetVertex(v.indexB);
v.wA.x = (transformA.q.c * wALocal.x - transformA.q.s * wALocal.y) + transformA.p.x;
v.wA.y = (transformA.q.s * wALocal.x + transformA.q.c * wALocal.y) + transformA.p.y;
v.wB.x = (transformB.q.c * wBLocal.x - transformB.q.s * wBLocal.y) + transformB.p.x;
v.wB.y = (transformB.q.s * wBLocal.x + transformB.q.c * wBLocal.y) + transformB.p.y;
v.w.x = v.wB.x - v.wA.x;
v.w.y = v.wB.y - v.wA.y;
v.a = 0
}
if (this.m_count > 1) {
var metric1 = cache.metric;
var metric2 = this.GetMetric();
if (metric2 < 0.5 * metric1 || 2 * metric1 < metric2 || metric2 < b2_epsilon) {
this.m_count = 0
}
}
if (this.m_count == 0) {
var v = vertices[0];
v.indexA = 0;
v.indexB = 0;
var wALocal = proxyA.GetVertex(0);
var wBLocal = proxyB.GetVertex(0);
v.wA.x = (transformA.q.c * wALocal.x - transformA.q.s * wALocal.y) + transformA.p.x;
v.wA.y = (transformA.q.s * wALocal.x + transformA.q.c * wALocal.y) + transformA.p.y;
v.wB.x = (transformB.q.c * wBLocal.x - transformB.q.s * wBLocal.y) + transformB.p.x;
v.wB.y = (transformB.q.s * wBLocal.x + transformB.q.c * wBLocal.y) + transformB.p.y;
v.w.x = v.wB.x - v.wA.x;
v.w.y = v.wB.y - v.wA.y;
v.a = 1;
this.m_count = 1
}
},
WriteCache: function (cache) {
cache.metric = this.GetMetric();
cache.count = this.m_count;
var vertices = this.m_v;
for (var i = 0; i < this.m_count; ++i) {
cache.indexA[i] = vertices[i].indexA;
cache.indexB[i] = vertices[i].indexB
}
},
GetSearchDirection: function (p) {
switch (this.m_count) {
case 1:
p.x = -this.m_v[0].w.x;
p.y = -this.m_v[0].w.y;
break;
case 2:
var e12x = this.m_v[1].w.x - this.m_v[0].w.x;
var e12y = this.m_v[1].w.y - this.m_v[0].w.y;
var sgn = e12x * -this.m_v[0].w.y - e12y * -this.m_v[0].w.x;
if (sgn > 0) {
p.x = -1 * e12y;
p.y = 1 * e12x
} else {
p.x = 1 * e12y;
p.y = -1 * e12x
}
break
}
},
GetClosestPoint: function (p) {
switch (this.m_count) {
case 1:
p.x = this.m_v[0].w.x;
p.y = this.m_v[0].w.y;
break;
case 2:
p.x = (this.m_v[0].a * this.m_v[0].w.x) + (this.m_v[1].a * this.m_v[1].w.x);
p.y = (this.m_v[0].a * this.m_v[0].w.y) + (this.m_v[1].a * this.m_v[1].w.y);
break;
case 3:
p.x = p.y = 0;
break
}
},
GetWitnessPoints: function (pA, pB) {
switch (this.m_count) {
case 1:
pA.x = this.m_v[0].wA.x;
pA.y = this.m_v[0].wA.y;
pB.x = this.m_v[0].wB.x;
pB.y = this.m_v[0].wB.y;
break;
case 2:
pA.x = (this.m_v[0].a * this.m_v[0].wA.x) + (this.m_v[1].a * this.m_v[1].wA.x);
pA.y = (this.m_v[0].a * this.m_v[0].wA.y) + (this.m_v[1].a * this.m_v[1].wA.y);
pB.x = (this.m_v[0].a * this.m_v[0].wB.x) + (this.m_v[1].a * this.m_v[1].wB.x);
pB.y = (this.m_v[0].a * this.m_v[0].wB.y) + (this.m_v[1].a * this.m_v[1].wB.y);
break;
case 3:
pA.x = (this.m_v[0].a, this.m_v[0].wA.x) + (this.m_v[1].a, this.m_v[1].wA.x) + (this.m_v[2].a, this.m_v[2].wA.x);
pA.y = (this.m_v[0].a, this.m_v[0].wA.y) + (this.m_v[1].a, this.m_v[1].wA.y) + (this.m_v[2].a, this.m_v[2].wA.y);
pB.x = pA.x;
pB.y = pA.y;
break
}
},
GetMetric: function () {
switch (this.m_count) {
case 1:
return 0;
case 2:
return b2Distance(this.m_v[0].w, this.m_v[1].w);
case 3:
return (this.m_v[1].w.x - this.m_v[0].w.x) * (this.m_v[2].w.y - this.m_v[0].w.y) - (this.m_v[1].w.y - this.m_v[0].w.y) * (this.m_v[2].w.x - this.m_v[0].w.x)
}
},
Solve2: function () {
var w1 = this.m_v[0].w;
var w2 = this.m_v[1].w;
var e12x = w2.x - w1.x;
var e12y = w2.y - w1.y;
var d12_2 = -(w1.x * e12x + w1.y * e12y);
if (d12_2 <= 0) {
this.m_v[0].a = 1;
this.m_count = 1;
return
}
var d12_1 = w2.x * e12x + w2.y * e12y;
if (d12_1 <= 0) {
this.m_v[1].a = 1;
this.m_count = 1;
this.m_v[0].Assign(this.m_v[1]);
return
}
var inv_d12 = 1 / (d12_1 + d12_2);
this.m_v[0].a = d12_1 * inv_d12;
this.m_v[1].a = d12_2 * inv_d12;
this.m_count = 2
},
Solve3: function () {
var w1 = this.m_v[0].w;
var w2 = this.m_v[1].w;
var w3 = this.m_v[2].w;
var e12x = w2.x - w1.x;
var e12y = w2.y - w1.y;
var w1e12 = w1.x * e12x + w1.y * e12y;
var w2e12 = w2.x * e12x + w2.y * e12y;
var d12_1 = w2e12;
var d12_2 = -w1e12;
var e13x = w3.x - w1.x;
var e13y = w3.y - w1.y;
var w1e13 = w1.x * e13x + w1.y * e13y;
var w3e13 = w3.x * e13x + w3.y * e13y;
var d13_1 = w3e13;
var d13_2 = -w1e13;
var e23x = w3.x - w2.x;
var e23y = w3.y - w2.y;
var w2e23 = w2.x * e23x + w2.y * e23y;
var w3e23 = w3.x * e23x + w3.y * e23y;
var d23_1 = w3e23;
var d23_2 = -w2e23;
var n123 = e12x * e13y - e12y * e13x;
var d123_1 = n123 * (w2.x * w3.y - w2.y * w3.x);
var d123_2 = n123 * (w3.x * w1.y - w3.y * w1.x);
var d123_3 = n123 * (w1.x * w2.y - w1.y * w2.x);
if (d12_2 <= 0 && d13_2 <= 0) {
this.m_v[0].a = 1;
this.m_count = 1;
return
}
if (d12_1 > 0 && d12_2 > 0 && d123_3 <= 0) {
var inv_d12 = 1 / (d12_1 + d12_2);
this.m_v[0].a = d12_1 * inv_d12;
this.m_v[1].a = d12_2 * inv_d12;
this.m_count = 2;
return
}
if (d13_1 > 0 && d13_2 > 0 && d123_2 <= 0) {
var inv_d13 = 1 / (d13_1 + d13_2);
this.m_v[0].a = d13_1 * inv_d13;
this.m_v[2].a = d13_2 * inv_d13;
this.m_count = 2;
this.m_v[1].Assign(this.m_v[2]);
return
}
if (d12_1 <= 0 && d23_2 <= 0) {
this.m_v[1].a = 1;
this.m_count = 1;
this.m_v[0].Assign(this.m_v[1]);
return
}
if (d13_1 <= 0 && d23_1 <= 0) {
this.m_v[2].a = 1;
this.m_count = 1;
this.m_v[0].Assign(this.m_v[2]);
return
}
if (d23_1 > 0 && d23_2 > 0 && d123_1 <= 0) {
var inv_d23 = 1 / (d23_1 + d23_2);
this.m_v[1].a = d23_1 * inv_d23;
this.m_v[2].a = d23_2 * inv_d23;
this.m_count = 2;
this.m_v[0].Assign(this.m_v[2]);
return
}
var inv_d123 = 1 / (d123_1 + d123_2 + d123_3);
this.m_v[0].a = d123_1 * inv_d123;
this.m_v[1].a = d123_2 * inv_d123;
this.m_v[2].a = d123_3 * inv_d123;
this.m_count = 3
}
};
var _b2Distance_simplex = new b2Simplex();
var _b2Distance_normal = new b2Vec2();
var _b2Distance_p = new b2Vec2();
function b2DistanceFunc(output, cache, input) {
++b2DistanceFunc.b2_gjkCalls;
var proxyA = input.proxyA;
var proxyB = input.proxyB;
var transformA = input.transformA;
var transformB = input.transformB;
_b2Distance_simplex.ReadCache(cache, proxyA, transformA, proxyB, transformB);
var vertices = _b2Distance_simplex.m_v;
var k_maxIters = 20;
var saveA = [0, 0, 0],
saveB = [0, 0, 0];
var saveCount = 0;
var distanceSqr1 = b2_maxFloat;
var distanceSqr2 = distanceSqr1;
var iter = 0;
while (iter < k_maxIters) {
saveCount = _b2Distance_simplex.m_count;
for (var i = 0; i < saveCount; ++i) {
saveA[i] = vertices[i].indexA;
saveB[i] = vertices[i].indexB
}
switch (_b2Distance_simplex.m_count) {
case 1:
break;
case 2:
_b2Distance_simplex.Solve2();
break;
case 3:
_b2Distance_simplex.Solve3();
break
}
if (_b2Distance_simplex.m_count == 3) {
break
}
_b2Distance_simplex.GetClosestPoint(_b2Distance_p);
distanceSqr2 = _b2Distance_p.LengthSquared();
if (distanceSqr2 >= distanceSqr1) {}
distanceSqr1 = distanceSqr2;
_b2Distance_simplex.GetSearchDirection(_b2Distance_p);
if (_b2Distance_p.LengthSquared() < b2_epsilon * b2_epsilon) {
break
}
var vertex = vertices[_b2Distance_simplex.m_count];
vertex.indexA = proxyA.GetSupport(transformA.q.c * -_b2Distance_p.x + transformA.q.s * -_b2Distance_p.y, -transformA.q.s * -_b2Distance_p.x + transformA.q.c * -_b2Distance_p.y);
var pva = proxyA.GetVertex(vertex.indexA);
vertex.wA.x = (transformA.q.c * pva.x - transformA.q.s * pva.y) + transformA.p.x;
vertex.wA.y = (transformA.q.s * pva.x + transformA.q.c * pva.y) + transformA.p.y;
vertex.indexB = proxyB.GetSupport(transformB.q.c * _b2Distance_p.x + transformB.q.s * _b2Distance_p.y, -transformB.q.s * _b2Distance_p.x + transformB.q.c * _b2Distance_p.y);
var pvb = proxyB.GetVertex(vertex.indexB);
vertex.wB.x = (transformB.q.c * pvb.x - transformB.q.s * pvb.y) + transformB.p.x;
vertex.wB.y = (transformB.q.s * pvb.x + transformB.q.c * pvb.y) + transformB.p.y;
vertex.w.x = vertex.wB.x - vertex.wA.x;
vertex.w.y = vertex.wB.y - vertex.wA.y;
++iter;
++b2DistanceFunc.b2_gjkIters;
var duplicate = false;
for (var i = 0; i < saveCount; ++i) {
if (vertex.indexA == saveA[i] && vertex.indexB == saveB[i]) {
duplicate = true;
break
}
}
if (duplicate) {
break
}++_b2Distance_simplex.m_count
}
b2DistanceFunc.b2_gjkMaxIters = b2Max(b2DistanceFunc.b2_gjkMaxIters, iter);
_b2Distance_simplex.GetWitnessPoints(output.pointA, output.pointB);
output.distance = b2Distance(output.pointA, output.pointB);
output.iterations = iter;
_b2Distance_simplex.WriteCache(cache);
if (input.useRadii) {
var rA = proxyA.m_radius;
var rB = proxyB.m_radius;
if (output.distance > rA + rB && output.distance > b2_epsilon) {
output.distance -= rA + rB;
_b2Distance_normal.x = output.pointB.x - output.pointA.x;
_b2Distance_normal.y = output.pointB.y - output.pointA.y;
_b2Distance_normal.Normalize();
output.pointA.x += (rA * _b2Distance_normal.x);
output.pointA.y += (rA * _b2Distance_normal.y);
output.pointB.x -= (rB * _b2Distance_normal.x);
output.pointB.y -= (rB * _b2Distance_normal.y)
} else {
var px = (0.5 * (output.pointA.x + output.pointB.x));
var py = (0.5 * (output.pointA.y + output.pointB.y));
output.pointA.x = px;
output.pointA.y = py;
output.pointB.x = px;
output.pointB.y = py;
output.distance = 0
}
}
}
b2DistanceFunc.b2_gjkCalls = 0;
b2DistanceFunc.b2_gjkIters = 0;
b2DistanceFunc.b2_gjkMaxIters = 0;
"use strict";
var b2_nullFeature = 255;
function b2ContactID() {}
b2ContactID.prototype = {
indexA: 0,
indexB: 0,
typeA: 0,
typeB: 0,
Reset: function () {
this.indexA = this.indexB = this.typeA = this.typeB = 0
},
Get: function () {
return this.indexA | (this.indexB << 8) | (this.typeA << 16) | (this.typeB << 24)
},
Assign: function (k) {
this.indexA = k.indexA;
this.indexB = k.indexB;
this.typeA = k.typeA;
this.typeB = k.typeB
}
};
b2ContactID.e_vertex = 0;
b2ContactID.e_face = 1;
function b2ManifoldPoint() {
this.localPoint = new b2Vec2();
this.normalImpulse = 0;
this.tangentImpulse = 0;
this.id = new b2ContactID()
}
b2ManifoldPoint.prototype = {
Clone: function () {
var point = new b2ManifoldPoint();
point.localPoint.x = this.localPoint.x;
point.localPoint.y = this.localPoint.y;
point.normalImpulse = this.normalImpulse;
point.tangentImpulse = this.tangentImpulse;
point.id.Assign(this.id);
return point
}
};
function b2Manifold() {
this.points = new Array(b2_maxManifoldPoints);
this.localNormal = new b2Vec2();
this.localPoint = new b2Vec2();
this.type = 0;
this.pointCount = 0
}
b2Manifold.prototype = {
Clone: function () {
var manifold = new b2Manifold();
manifold.pointCount = this.pointCount;
manifold.type = this.type;
manifold.localPoint.x = this.localPoint.x;
manifold.localPoint.y = this.localPoint.y;
manifold.localNormal.x = this.localNormal.x;
manifold.localNormal.y = this.localNormal.y;
for (var i = 0; i < this.pointCount; ++i) {
manifold.points[i] = this.points[i].Clone()
}
return manifold
},
Assign: function (manifold) {
this.pointCount = manifold.pointCount;
this.type = manifold.type;
this.localPoint.x = manifold.localPoint.x;
this.localPoint.y = manifold.localPoint.y;
this.localNormal.x = manifold.localNormal.x;
this.localNormal.y = manifold.localNormal.y;
for (var i = 0; i < this.pointCount; ++i) {
this.points[i] = manifold.points[i].Clone()
}
}
};
b2Manifold.e_circles = 0;
b2Manifold.e_faceA = 1;
b2Manifold.e_faceB = 2;
b2Manifold.b2_nullState = 0;
b2Manifold.b2_addState = 1;
b2Manifold.b2_persistState = 2;
b2Manifold.b2_removeState = 3;
function b2WorldManifold() {
this.normal = new b2Vec2();
this.points = new Array(b2_maxManifoldPoints);
this.separations = new Array(b2_maxManifoldPoints)
}
b2WorldManifold.prototype = {
Initialize: function (manifold, xfA, radiusA, xfB, radiusB) {
if (manifold.pointCount == 0) {
return
}
switch (manifold.type) {
case b2Manifold.e_circles:
this.normal.x = 1;
this.normal.y = 0;
var pointAx = (xfA.q.c * manifold.localPoint.x - xfA.q.s * manifold.localPoint.y) + xfA.p.x;
var pointAy = (xfA.q.s * manifold.localPoint.x + xfA.q.c * manifold.localPoint.y) + xfA.p.y;
var pointBx = (xfB.q.c * manifold.points[0].localPoint.x - xfB.q.s * manifold.points[0].localPoint.y) + xfB.p.x;
var pointBy = (xfB.q.s * manifold.points[0].localPoint.x + xfB.q.c * manifold.points[0].localPoint.y) + xfB.p.y;
var cx = pointAx - pointBx;
var cy = pointAy - pointBy;
if ((cx * cx + cy * cy) > b2_epsilon * b2_epsilon) {
this.normal.x = pointBx - pointAx;
this.normal.y = pointBy - pointAy;
this.normal.Normalize()
}
var cAx = pointAx + (radiusA * this.normal.x);
var cAy = pointAy + (radiusA * this.normal.y);
var cBx = pointBx - (radiusB * this.normal.x);
var cBy = pointBy - (radiusB * this.normal.y);
this.points[0] = new b2Vec2(0.5 * (cAx + cBx), 0.5 * (cAy + cBy));
this.separations[0] = (cBx - cAx) * this.normal.x + (cBy - cAy) * this.normal.y;
break;
case b2Manifold.e_faceA:
this.normal.x = xfA.q.c * manifold.localNormal.x - xfA.q.s * manifold.localNormal.y;
this.normal.y = xfA.q.s * manifold.localNormal.x + xfA.q.c * manifold.localNormal.y;
var planePointx = (xfA.q.c * manifold.localPoint.x - xfA.q.s * manifold.localPoint.y) + xfA.p.x;
var planePointy = (xfA.q.s * manifold.localPoint.x + xfA.q.c * manifold.localPoint.y) + xfA.p.y;
for (var i = 0; i < manifold.pointCount; ++i) {
var clipPointx = (xfB.q.c * manifold.points[i].localPoint.x - xfB.q.s * manifold.points[i].localPoint.y) + xfB.p.x;
var clipPointy = (xfB.q.s * manifold.points[i].localPoint.x + xfB.q.c * manifold.points[i].localPoint.y) + xfB.p.y;
var d = (clipPointx - planePointx) * this.normal.x + (clipPointy - planePointy) * this.normal.y;
var cAx = clipPointx + ((radiusA - d) * this.normal.x);
var cAy = clipPointy + ((radiusA - d) * this.normal.y);
var cBx = (clipPointx - (radiusB * this.normal.x));
var cBy = (clipPointy - (radiusB * this.normal.y));
this.points[i] = new b2Vec2(0.5 * (cAx + cBx), 0.5 * (cAy + cBy));
this.separations[i] = (cBx - cAx) * this.normal.x + (cBy - cAy) * this.normal.y
}
break;
case b2Manifold.e_faceB:
this.normal.x = xfB.q.c * manifold.localNormal.x - xfB.q.s * manifold.localNormal.y;
this.normal.y = xfB.q.s * manifold.localNormal.x + xfB.q.c * manifold.localNormal.y;
var planePointx = (xfB.q.c * manifold.localPoint.x - xfB.q.s * manifold.localPoint.y) + xfB.p.x;
var planePointy = (xfB.q.s * manifold.localPoint.x + xfB.q.c * manifold.localPoint.y) + xfB.p.y;
for (var i = 0; i < manifold.pointCount; ++i) {
var clipPointx = (xfA.q.c * manifold.points[i].localPoint.x - xfA.q.s * manifold.points[i].localPoint.y) + xfA.p.x;
var clipPointy = (xfA.q.s * manifold.points[i].localPoint.x + xfA.q.c * manifold.points[i].localPoint.y) + xfA.p.y;
var d = (clipPointx - planePointx) * this.normal.x + (clipPointy - planePointy) * this.normal.y;
var cBx = clipPointx + ((radiusB - d) * this.normal.x);
var cBy = clipPointy + ((radiusB - d) * this.normal.y);
var cAx = (clipPointx - (radiusA * this.normal.x));
var cAy = (clipPointy - (radiusA * this.normal.y));
this.points[i] = new b2Vec2(0.5 * (cAx + cBx), 0.5 * (cAy + cBy));
this.separations[i] = (cAx - cBx) * this.normal.x + (cAy - cBy) * this.normal.y
}
this.normal.x = -this.normal.x;
this.normal.y = -this.normal.y;
break
}
}
};
function b2GetPointStates(state1, state2, manifold1, manifold2) {
for (var i = 0; i < b2_maxManifoldPoints; ++i) {
state1[i] = b2Manifold.b2_nullState;
state2[i] = b2Manifold.b2_nullState
}
for (var i = 0; i < manifold1.pointCount; ++i) {
var id = manifold1.points[i].id;
state1[i] = b2Manifold.b2_removeState;
for (var j = 0; j < manifold2.pointCount; ++j) {
if (manifold2.points[j].id.Get() == id.Get()) {
state1[i] = b2Manifold.b2_persistState;
break
}
}
}
for (var i = 0; i < manifold2.pointCount; ++i) {
var id = manifold2.points[i].id;
state2[i] = b2Manifold.b2_addState;
for (var j = 0; j < manifold1.pointCount; ++j) {
if (manifold1.points[j].id.Get() == id.Get()) {
state2[i] = b2Manifold.b2_persistState;
break
}
}
}
}
function b2ClipVertex() {
this.v = new b2Vec2();
this.id = new b2ContactID()
}
function b2RayCastInput() {
this.p1 = new b2Vec2(), this.p2 = new b2Vec2();
this.maxFraction = 0
}
function b2RayCastOutput() {
this.normal = new b2Vec2();
this.fraction = 0
}
function b2AABB() {
this.lowerBound = new b2Vec2();
this.upperBound = new b2Vec2()
}
b2AABB.prototype = {
Assign: function (other) {
this.lowerBound.x = other.lowerBound.x;
this.lowerBound.y = other.lowerBound.y;
this.upperBound.x = other.upperBound.x;
this.upperBound.y = other.upperBound.y
},
Clone: function () {
var clone = new b2AABB();
clone.lowerBound.x = this.lowerBound.x;
clone.lowerBound.y = this.lowerBound.y;
clone.lowerBound.x = this.lowerBound.x;
clone.lowerBound.y = this.lowerBound.y;
return clone
},
IsValid: function () {
return (this.upperBound.x - this.lowerBound.x) >= 0 && (this.upperBound.y - this.lowerBound.y) >= 0 && this.lowerBound.IsValid() && this.upperBound.IsValid()
},
GetCenter: function () {
return new b2Vec2(0.5 * (this.lowerBound.x + this.upperBound.x), 0.5 * (this.lowerBound.y + this.upperBound.y))
},
GetExtents: function () {
return new b2Vec2(0.5 * (this.upperBound.x - this.lowerBound.x), 0.5 * (this.upperBound.y - this.lowerBound.y))
},
GetPerimeter: function () {
return 2 * ((this.upperBound.x - this.lowerBound.x) + (this.upperBound.y - this.lowerBound.y))
},
Combine: function (aabb1, aabb2) {
if (aabb2) {
this.lowerBound.x = b2Min(aabb1.lowerBound.x, aabb2.lowerBound.x);
this.lowerBound.y = b2Min(aabb1.lowerBound.y, aabb2.lowerBound.y);
this.upperBound.x = b2Max(aabb1.upperBound.x, aabb2.upperBound.x);
this.upperBound.y = b2Max(aabb1.upperBound.y, aabb2.upperBound.y)
} else {
this.lowerBound.x = b2Min(this.lowerBound.x, aabb1.lowerBound.x);
this.lowerBound.y = b2Min(this.lowerBound.y, aabb1.lowerBound.y);
this.upperBound.x = b2Max(this.upperBound.x, aabb1.upperBound.x);
this.upperBound.y = b2Max(this.upperBound.y, aabb1.upperBound.y)
}
},
Contains: function (aabb) {
return this.lowerBound.x <= aabb.lowerBound.x && this.lowerBound.y <= aabb.lowerBound.y && aabb.upperBound.x <= this.upperBound.x && aabb.upperBound.y <= this.upperBound.y
},
RayCast: function (output, input) {
var tmin = -b2_maxFloat;
var tmax = b2_maxFloat;
var p = input.p1;
var d = b2Vec2.Subtract(input.p2, input.p1);
var absD = b2Abs_v2(d);
var normal = new b2Vec2();
for (var i = 0; i < 2; ++i) {
if (absD.get_i(i) < b2_epsilon) {
if (p.get_i(i) < this.lowerBound.get_i(i) || this.upperBound.get_i(i) < p.get_i(i)) {
return false
}
} else {
var inv_d = 1 / d.get_i(i);
var t1 = (this.lowerBound.get_i(i) - p.get_i(i)) * inv_d;
var t2 = (this.upperBound.get_i(i) - p.get_i(i)) * inv_d;
var s = -1;
if (t1 > t2) {
var temp = t2;
t2 = t1;
t1 = temp;
s = 1
}
if (t1 > tmin) {
normal.x = normal.y = 0;
normal.set_i(i, s);
tmin = t1
}
tmax = b2Min(tmax, t2);
if (tmin > tmax) {
return false
}
}
}
if (tmin < 0 || input.maxFraction < tmin) {
return false
}
output.fraction = tmin;
output.normal.x = normal.x;
output.normal.y = normal.y;
return true
}
};
function b2CollideCircles(manifold, circleA, xfA, circleB, xfB) {
manifold.pointCount = 0;
var pA = b2Mul_t_v2(xfA, circleA.m_p);
var pB = b2Mul_t_v2(xfB, circleB.m_p);
var dx = pB.x - pA.x;
var dy = pB.y - pA.y;
var distSqr = dx * dx + dy * dy;
var rA = circleA.m_radius,
rB = circleB.m_radius;
var radius = rA + rB;
if (distSqr > radius * radius) {
return
}
manifold.type = b2Manifold.e_circles;
manifold.localPoint.x = circleA.m_p.x;
manifold.localPoint.y = circleA.m_p.y;
manifold.localNormal.x = manifold.localNormal.y = 0;
manifold.pointCount = 1;
manifold.points[0] = new b2ManifoldPoint();
manifold.points[0].localPoint.x = circleB.m_p.x;
manifold.points[0].localPoint.y = circleB.m_p.y;
manifold.points[0].id.Reset()
}
function b2CollidePolygonAndCircle(manifold, polygonA, xfA, circleB, xfB) {
manifold.pointCount = 0;
var c = b2Mul_t_v2(xfB, circleB.m_p);
var cLocal = b2MulT_t_v2(xfA, c);
var normalIndex = 0;
var separation = -b2_maxFloat;
var radius = polygonA.m_radius + circleB.m_radius;
var vertexCount = polygonA.m_count;
var vertices = polygonA.m_vertices;
var normals = polygonA.m_normals;
for (var i = 0; i < vertexCount; ++i) {
var s = normals[i].x * (cLocal.x - vertices[i].x) + normals[i].y * (cLocal.y - vertices[i].y);
if (s > radius) {
return
}
if (s > separation) {
separation = s;
normalIndex = i
}
}
var vertIndex1 = normalIndex;
var vertIndex2 = vertIndex1 + 1 < vertexCount ? vertIndex1 + 1 : 0;
var v1 = vertices[vertIndex1];
var v2 = vertices[vertIndex2];
if (separation < b2_epsilon) {
manifold.pointCount = 1;
manifold.type = b2Manifold.e_faceA;
manifold.localNormal.x = normals[normalIndex].x;
manifold.localNormal.y = normals[normalIndex].y;
manifold.localPoint.x = 0.5 * (v1.x + v2.x);
manifold.localPoint.y = 0.5 * (v1.y + v2.y);
manifold.points[0] = new b2ManifoldPoint();
manifold.points[0].localPoint.x = circleB.m_p.x;
manifold.points[0].localPoint.y = circleB.m_p.y;
manifold.points[0].id.Reset();
return
}
var u1 = (cLocal.x - v1.x) * (v2.x - v1.x) + (cLocal.y - v1.y) * (v2.y - v1.y);
var u2 = (cLocal.x - v2.x) * (v1.x - v2.x) + (cLocal.y - v2.y) * (v1.y - v2.y);
if (u1 <= 0) {
if (b2DistanceSquared(cLocal, v1) > radius * radius) {
return
}
manifold.pointCount = 1;
manifold.type = b2Manifold.e_faceA;
manifold.localNormal.x = cLocal.x - v1.x;
manifold.localNormal.y = cLocal.y - v1.y;
manifold.localNormal.Normalize();
manifold.localPoint.x = v1.x;
manifold.localPoint.y = v1.y;
manifold.points[0] = new b2ManifoldPoint();
manifold.points[0].localPoint.x = circleB.m_p.x;
manifold.points[0].localPoint.y = circleB.m_p.y;
manifold.points[0].id.Reset()
} else {
if (u2 <= 0) {
if (b2DistanceSquared(cLocal, v2) > radius * radius) {
return
}
manifold.pointCount = 1;
manifold.type = b2Manifold.e_faceA;
manifold.localNormal.x = cLocal.x - v2.x;
manifold.localNormal.y = cLocal.y - v2.y;
manifold.localNormal.Normalize();
manifold.localPoint.x = v2.x;
manifold.localPoint.y = v2.y;
manifold.points[0] = new b2ManifoldPoint();
manifold.points[0].localPoint.x = circleB.m_p.x;
manifold.points[0].localPoint.y = circleB.m_p.y;
manifold.points[0].id.Reset()
} else {
var faceCenterx = 0.5 * (v1.x + v2.x);
var faceCentery = 0.5 * (v1.y + v2.y);
var separation = (cLocal.x - faceCenterx) * normals[vertIndex1].x + (cLocal.y - faceCentery) * normals[vertIndex1].y;
if (separation > radius) {
return
}
manifold.pointCount = 1;
manifold.type = b2Manifold.e_faceA;
manifold.localNormal.x = normals[vertIndex1].x;
manifold.localNormal.y = normals[vertIndex1].y;
manifold.localPoint.x = faceCenterx;
manifold.localPoint.y = faceCentery;
manifold.points[0] = new b2ManifoldPoint();
manifold.points[0].localPoint.x = circleB.m_p.x;
manifold.points[0].localPoint.y = circleB.m_p.y;
manifold.points[0].id.Reset()
}
}
}
function b2FindMaxSeparation(edgeIndex, poly1, xf1, poly2, xf2) {
var count1 = poly1.m_count;
var count2 = poly2.m_count;
var n1s = poly1.m_normals;
var v1s = poly1.m_vertices;
var v2s = poly2.m_vertices;
var xf = b2MulT_t_t(xf2, xf1);
var bestIndex = 0;
var maxSeparation = -b2_maxFloat;
for (var i = 0; i < count1; ++i) {
var nx = xf.q.c * n1s[i].x - xf.q.s * n1s[i].y;
var ny = xf.q.s * n1s[i].x + xf.q.c * n1s[i].y;
var v1x = (xf.q.c * v1s[i].x - xf.q.s * v1s[i].y) + xf.p.x;
var v1y = (xf.q.s * v1s[i].x + xf.q.c * v1s[i].y) + xf.p.y;
var si = b2_maxFloat;
for (var j = 0; j < count2; ++j) {
var sij = nx * (v2s[j].x - v1x) + ny * (v2s[j].y - v1y);
if (sij < si) {
si = sij
}
}
if (si > maxSeparation) {
maxSeparation = si;
bestIndex = i
}
}
edgeIndex[0] = bestIndex;
return maxSeparation
}
function b2FindIncidentEdge(c, poly1, xf1, edge1, poly2, xf2) {
var normals1 = poly1.m_normals;
var count2 = poly2.m_count;
var vertices2 = poly2.m_vertices;
var normals2 = poly2.m_normals;
var t1x = xf1.q.c * normals1[edge1].x - xf1.q.s * normals1[edge1].y;
var t1y = xf1.q.s * normals1[edge1].x + xf1.q.c * normals1[edge1].y;
var normal1x = xf2.q.c * t1x + xf2.q.s * t1y;
var normal1y = -xf2.q.s * t1x + xf2.q.c * t1y;
var index = 0;
var minDot = b2_maxFloat;
for (var i = 0; i < count2; ++i) {
var dot = normal1x * normals2[i].x + normal1y * normals2[i].y;
if (dot < minDot) {
minDot = dot;
index = i
}
}
var i1 = index;
var i2 = i1 + 1 < count2 ? i1 + 1 : 0;
c[0].v.x = (xf2.q.c * vertices2[i1].x - xf2.q.s * vertices2[i1].y) + xf2.p.x;
c[0].v.y = (xf2.q.s * vertices2[i1].x + xf2.q.c * vertices2[i1].y) + xf2.p.y;
c[0].id.indexA = edge1;
c[0].id.indexB = i1;
c[0].id.typeA = b2ContactID.e_face;
c[0].id.typeB = b2ContactID.e_vertex;
c[1].v.x = (xf2.q.c * vertices2[i2].x - xf2.q.s * vertices2[i2].y) + xf2.p.x;
c[1].v.y = (xf2.q.s * vertices2[i2].x + xf2.q.c * vertices2[i2].y) + xf2.p.y;
c[1].id.indexA = edge1;
c[1].id.indexB = i2;
c[1].id.typeA = b2ContactID.e_face;
c[1].id.typeB = b2ContactID.e_vertex
}
function b2CollidePolygons(manifold, polyA, xfA, polyB, xfB) {
manifold.pointCount = 0;
var totalRadius = polyA.m_radius + polyB.m_radius;
var edgeA = [0];
var separationA = b2FindMaxSeparation(edgeA, polyA, xfA, polyB, xfB);
if (separationA > totalRadius) {
return
}
var edgeB = [0];
var separationB = b2FindMaxSeparation(edgeB, polyB, xfB, polyA, xfA);
if (separationB > totalRadius) {
return
}
var poly1;
var poly2;
var xf1, xf2;
var edge1 = 0;
var flip = 0;
var k_tol = 0.1 * b2_linearSlop;
if (separationB > separationA + k_tol) {
poly1 = polyB;
poly2 = polyA;
xf1 = xfB;
xf2 = xfA;
edge1 = edgeB[0];
manifold.type = b2Manifold.e_faceB;
flip = 1
} else {
poly1 = polyA;
poly2 = polyB;
xf1 = xfA;
xf2 = xfB;
edge1 = edgeA[0];
manifold.type = b2Manifold.e_faceA;
flip = 0
}
b2FindIncidentEdge(b2CollidePolygons._local_incidentEdges, poly1, xf1, edge1, poly2, xf2);
var count1 = poly1.m_count;
var vertices1 = poly1.m_vertices;
var iv1 = edge1;
var iv2 = edge1 + 1 < count1 ? edge1 + 1 : 0;
var v11 = vertices1[iv1];
var v12 = vertices1[iv2];
b2CollidePolygons._localTangent.x = v12.x - v11.x;
b2CollidePolygons._localTangent.y = v12.y - v11.y;
b2CollidePolygons._localTangent.Normalize();
var localNormalx = 1 * b2CollidePolygons._localTangent.y;
var localNormaly = -1 * b2CollidePolygons._localTangent.x;
var planePointx = 0.5 * (v11.x + v12.x);
var planePointy = 0.5 * (v11.y + v12.y);
var tangentx = xf1.q.c * b2CollidePolygons._localTangent.x - xf1.q.s * b2CollidePolygons._localTangent.y;
var tangenty = xf1.q.s * b2CollidePolygons._localTangent.x + xf1.q.c * b2CollidePolygons._localTangent.y;
var normalx = 1 * tangenty;
var normaly = -1 * tangentx;
v11 = b2Mul_t_v2(xf1, v11);
v12 = b2Mul_t_v2(xf1, v12);
var frontOffset = normalx * v11.x + normaly * v11.y;
var sideOffset1 = -(tangentx * v11.x + tangenty * v11.y) + totalRadius;
var sideOffset2 = (tangentx * v12.x + tangenty * v12.y) + totalRadius;
var clipPoints1 = new Array(2);
var clipPoints2 = new Array(2);
var np;
np = b2ClipSegmentToLine(clipPoints1, b2CollidePolygons._local_incidentEdges, -tangentx, -tangenty, sideOffset1, iv1);
if (np < 2) {
return
}
np = b2ClipSegmentToLine(clipPoints2, clipPoints1, tangentx, tangenty, sideOffset2, iv2);
if (np < 2) {
return
}
manifold.localNormal.x = localNormalx;
manifold.localNormal.y = localNormaly;
manifold.localPoint.x = planePointx;
manifold.localPoint.y = planePointy;
var pointCount = 0;
for (var i = 0; i < b2_maxManifoldPoints; ++i) {
var separation = (normalx * clipPoints2[i].v.x + normaly * clipPoints2[i].v.y) - frontOffset;
if (separation <= totalRadius) {
var cp = manifold.points[pointCount] = new b2ManifoldPoint();
cp.localPoint.Assign(b2MulT_t_v2(xf2, clipPoints2[i].v));
cp.id.Assign(clipPoints2[i].id);
if (flip) {
var cf = new b2ContactID();
cf.Assign(cp.id);
cp.id.indexA = cf.indexB;
cp.id.indexB = cf.indexA;
cp.id.typeA = cf.typeB;
cp.id.typeB = cf.typeA
}++pointCount
}
}
manifold.pointCount = pointCount
}
b2CollidePolygons._localTangent = new b2Vec2();
b2CollidePolygons._local_incidentEdges = [new b2ClipVertex(), new b2ClipVertex()];
function b2CollideEdgeAndCircle(manifold, edgeA, xfA, circleB, xfB) {
manifold.pointCount = 0;
var Q = b2MulT_t_v2(xfA, b2Mul_t_v2(xfB, circleB.m_p));
var A = edgeA.m_vertex1,
B = edgeA.m_vertex2;
var ex = B.x - A.x;
var ey = B.y - A.y;
var u = ex * (B.x - Q.x) + ey * (B.y - Q.y);
var v = ex * (Q.x - A.x) + ey * (Q.y - A.y);
var radius = edgeA.m_radius + circleB.m_radius;
var cf = new b2ContactID();
cf.indexB = 0;
cf.typeB = b2ContactID.e_vertex;
if (v <= 0) {
var P = A;
var dx = Q.x - P.x;
var dy = Q.y - P.y;
var dd = dx * dx + dy * dy;
if (dd > radius * radius) {
return
}
if (edgeA.m_hasVertex0) {
var A1 = edgeA.m_vertex0;
var B1 = A;
var e1x = B1.x - A1.x;
var e1y = B1.y - A1.y;
var u1 = e1x * (B1.x - Q.x) + e1y * (B1.y - Q.y);
if (u1 > 0) {
return
}
}
cf.indexA = 0;
cf.typeA = b2ContactID.e_vertex;
manifold.pointCount = 1;
manifold.type = b2Manifold.e_circles;
manifold.localNormal.x = manifold.localNormal.y = 0;
manifold.localPoint.x = P.x;
manifold.localPoint.y = P.y;
manifold.points[0] = new b2ManifoldPoint();
manifold.points[0].id.Assign(cf);
manifold.points[0].localPoint.x = circleB.m_p.x;
manifold.points[0].localPoint.y = circleB.m_p.y;
return
}
if (u <= 0) {
var P = B;
var dx = Q.x - P.x;
var dy = Q.y - P.y;
var dd = dx * dx + dy * dy;
if (dd > radius * radius) {
return
}
if (edgeA.m_hasVertex3) {
var B2 = edgeA.m_vertex3;
var A2 = B;
var e2x = B2.x - A2.x;
var e2y = B2.y - A2.y;
var v2 = e2x * (Q.x - A2.x) + e2y * (Q.y - A2.y);
if (v2 > 0) {
return
}
}
cf.indexA = 1;
cf.typeA = b2ContactID.e_vertex;
manifold.pointCount = 1;
manifold.type = b2Manifold.e_circles;
manifold.localNormal.x = manifold.localNormal.y = 0;
manifold.localPoint.x = P.x;
manifold.localPoint.y = P.y;
manifold.points[0] = new b2ManifoldPoint();
manifold.points[0].id.Assign(cf);
manifold.points[0].localPoint.x = circleB.m_p.x;
manifold.points[0].localPoint.y = circleB.m_p.y;
return
}
var den = ex * ex + ey * ey;
var Px = (1 / den) * ((u * A.x) + (v * B.x));
var Py = (1 / den) * ((u * A.y) + (v * B.y));
var dx = Q.x - Px;
var dy = Q.y - Py;
var dd = dx * dx + dy * dy;
if (dd > radius * radius) {
return
}
var nx = -ey;
var ny = ex;
if (nx * (Q.x - A.x) + ny * (Q.y - A.y) < 0) {
nx = -nx;
ny = -ny
}
cf.indexA = 0;
cf.typeA = b2ContactID.e_face;
manifold.pointCount = 1;
manifold.type = b2Manifold.e_faceA;
manifold.localNormal.x = nx;
manifold.localNormal.y = ny;
manifold.localNormal.Normalize();
manifold.localPoint.x = A.x;
manifold.localPoint.y = A.y;
manifold.points[0] = new b2ManifoldPoint();
manifold.points[0].id.Assign(cf);
manifold.points[0].localPoint.x = circleB.m_p.x;
manifold.points[0].localPoint.y = circleB.m_p.y
}
function b2EPAxis() {
this.type = 0;
this.index = 0;
this.separation = 0
}
b2EPAxis.e_unknown = 0;
b2EPAxis.e_edgeA = 1;
b2EPAxis.e_edgeB = 2;
function b2TempPolygon() {
this.vertices = new Array(b2_maxPolygonVertices);
this.normals = new Array(b2_maxPolygonVertices);
this.count = 0
}
function b2ReferenceFace() {
this.i1 = 0, this.i2 = 0;
this.v1 = new b2Vec2(), this.v2 = new b2Vec2();
this.normal = new b2Vec2();
this.sideNormal1 = new b2Vec2();
this.sideOffset1 = 0;
this.sideNormal2 = new b2Vec2();
this.sideOffset2 = 0
}
function b2EPCollider() {
this.m_polygonB = new b2TempPolygon();
this.m_xf = new b2Transform();
this.m_centroidB = new b2Vec2();
this.m_v0 = new b2Vec2(), this.m_v1 = new b2Vec2(), this.m_v2 = new b2Vec2(), this.m_v3 = new b2Vec2();
this.m_normal0 = new b2Vec2(), this.m_normal1 = new b2Vec2(), this.m_normal2 = new b2Vec2();
this.m_normal = new b2Vec2();
this.m_type1 = 0, this.m_type2 = 0;
this.m_lowerLimit = new b2Vec2(), this.m_upperLimit = new b2Vec2();
this.m_radius = 0;
this.m_front = false
}
b2EPCollider._temp_edge = new b2Vec2();
b2EPCollider._temp_edge0 = new b2Vec2();
b2EPCollider._temp_edge2 = new b2Vec2();
b2EPCollider.prototype = {
Collide: function (manifold, edgeA, xfA, polygonB, xfB) {
this.m_xf.Assign(b2MulT_t_t(xfA, xfB));
this.m_centroidB.x = (this.m_xf.q.c * polygonB.m_centroid.x - this.m_xf.q.s * polygonB.m_centroid.y) + this.m_xf.p.x;
this.m_centroidB.y = (this.m_xf.q.s * polygonB.m_centroid.x + this.m_xf.q.c * polygonB.m_centroid.y) + this.m_xf.p.y;
this.m_v0.x = edgeA.m_vertex0.x;
this.m_v0.y = edgeA.m_vertex0.y;
this.m_v1.x = edgeA.m_vertex1.x;
this.m_v1.y = edgeA.m_vertex1.y;
this.m_v2.x = edgeA.m_vertex2.x;
this.m_v2.y = edgeA.m_vertex2.y;
this.m_v3.x = edgeA.m_vertex3.x;
this.m_v3.y = edgeA.m_vertex3.y;
var hasVertex0 = edgeA.m_hasVertex0;
var hasVertex3 = edgeA.m_hasVertex3;
b2EPCollider._temp_edge.x = this.m_v2.x - this.m_v1.x;
b2EPCollider._temp_edge.y = this.m_v2.y - this.m_v1.y;
b2EPCollider._temp_edge.Normalize();
this.m_normal1.x = b2EPCollider._temp_edge.y;
this.m_normal1.y = -b2EPCollider._temp_edge.x;
var offset1 = this.m_normal1.x * (this.m_centroidB.x - this.m_v1.x) + this.m_normal1.y * (this.m_centroidB.y - this.m_v1.y);
var offset0 = 0,
offset2 = 0;
var convex1 = false,
convex2 = false;
if (hasVertex0) {
b2EPCollider._temp_edge0.x = this.m_v1.x - this.m_v0.x;
b2EPCollider._temp_edge0.y = this.m_v1.y - this.m_v0.y;
b2EPCollider._temp_edge0.Normalize();
this.m_normal0.x = b2EPCollider._temp_edge0.y;
this.m_normal0.y = -b2EPCollider._temp_edge0.x;
convex1 = (b2EPCollider._temp_edge0.x * b2EPCollider._temp_edge.y - b2EPCollider._temp_edge0.y * b2EPCollider._temp_edge.x) >= 0;
offset0 = this.m_normal0.x * (this.m_centroidB.x - this.m_v0.x) + this.m_normal0.y * (this.m_centroidB.y - this.m_v0.y)
}
if (hasVertex3) {
b2EPCollider._temp_edge2.x = this.m_v3.x - this.m_v2.x;
b2EPCollider._temp_edge2.y = this.m_v3.y - this.m_v2.y;
b2EPCollider._temp_edge2.Normalize();
this.m_normal2.x = b2EPCollider._temp_edge2.y;
this.m_normal2.y = -b2EPCollider._temp_edge2.x;
convex2 = (b2EPCollider._temp_edge.x * b2EPCollider._temp_edge2.y - b2EPCollider._temp_edge.y * b2EPCollider._temp_edge2.x) > 0;
offset2 = this.m_normal2.x * (this.m_centroidB.x - this.m_v2.x) + this.m_normal2.y * (this.m_centroidB.y - this.m_v2.y)
}
if (hasVertex0 && hasVertex3) {
if (convex1 && convex2) {
this.m_front = offset0 >= 0 || offset1 >= 0 || offset2 >= 0;
if (this.m_front) {
this.m_normal.x = this.m_normal1.x;
this.m_normal.y = this.m_normal1.y;
this.m_lowerLimit.x = this.m_normal0.x;
this.m_lowerLimit.y = this.m_normal0.y;
this.m_upperLimit.x = this.m_normal2.x;
this.m_upperLimit.y = this.m_normal2.y
} else {
this.m_normal.x = -this.m_normal1.x;
this.m_normal.y = -this.m_normal1.y;
this.m_lowerLimit.x = -this.m_normal1.x;
this.m_lowerLimit.y = -this.m_normal1.y;
this.m_upperLimit.x = -this.m_normal1.x;
this.m_upperLimit.y = -this.m_normal1.y
}
} else {
if (convex1) {
this.m_front = offset0 >= 0 || (offset1 >= 0 && offset2 >= 0);
if (this.m_front) {
this.m_normal.x = this.m_normal1.x;
this.m_normal.y = this.m_normal1.y;
this.m_lowerLimit.x = this.m_normal0.x;
this.m_lowerLimit.y = this.m_normal0.y;
this.m_upperLimit.x = this.m_normal1.x;
this.m_upperLimit.y = this.m_normal1.y
} else {
this.m_normal.x = -this.m_normal1.x;
this.m_normal.y = -this.m_normal1.y;
this.m_lowerLimit.x = -this.m_normal2.x;
this.m_lowerLimit.y = -this.m_normal2.y;
this.m_upperLimit.x = -this.m_normal1.x;
this.m_upperLimit.y = -this.m_normal1.y
}
} else {
if (convex2) {
this.m_front = offset2 >= 0 || (offset0 >= 0 && offset1 >= 0);
if (this.m_front) {
this.m_normal.x = this.m_normal1.x;
this.m_normal.y = this.m_normal1.y;
this.m_lowerLimit.x = this.m_normal1.x;
this.m_lowerLimit.y = this.m_normal1.y;
this.m_upperLimit.x = this.m_normal2.x;
this.m_upperLimit.y = this.m_normal2.y
} else {
this.m_normal.x = -this.m_normal1.x;
this.m_normal.y = -this.m_normal1.y;
this.m_lowerLimit.x = -this.m_normal1.x;
this.m_lowerLimit.y = -this.m_normal1.y;
this.m_upperLimit.x = -this.m_normal0.x;
this.m_upperLimit.y = -this.m_normal0.y
}
} else {
this.m_front = offset0 >= 0 && offset1 >= 0 && offset2 >= 0;
if (this.m_front) {
this.m_normal.x = this.m_normal1.x;
this.m_normal.y = this.m_normal1.y;
this.m_lowerLimit.x = this.m_normal1.x;
this.m_lowerLimit.y = this.m_normal1.y;
this.m_upperLimit.x = this.m_normal1.x;
this.m_upperLimit.y = this.m_normal1.y
} else {
this.m_normal.x = -this.m_normal1.x;
this.m_normal.y = -this.m_normal1.y;
this.m_lowerLimit.x = -this.m_normal2.x;
this.m_lowerLimit.y = -this.m_normal2.y;
this.m_upperLimit.x = -this.m_normal0.x;
this.m_upperLimit.y = -this.m_normal0.y
}
}
}
}
} else {
if (hasVertex0) {
if (convex1) {
this.m_front = offset0 >= 0 || offset1 >= 0;
if (this.m_front) {
this.m_normal.x = this.m_normal1.x;
this.m_normal.y = this.m_normal1.y;
this.m_lowerLimit.x = this.m_normal0.x;
this.m_lowerLimit.y = this.m_normal0.y;
this.m_upperLimit.x = -this.m_normal1.x;
this.m_upperLimit.y = -this.m_normal1.y
} else {
this.m_normal.x = -this.m_normal1.x;
this.m_normal.y = -this.m_normal1.y;
this.m_lowerLimit.x = this.m_normal1.x;
this.m_lowerLimit.y = this.m_normal1.y;
this.m_upperLimit.x = -this.m_normal1.x;
this.m_upperLimit.y = -this.m_normal1.y
}
} else {
this.m_front = offset0 >= 0 && offset1 >= 0;
if (this.m_front) {
this.m_normal.x = this.m_normal1.x;
this.m_normal.y = this.m_normal1.y;
this.m_lowerLimit.x = this.m_normal1.x;
this.m_lowerLimit.y = this.m_normal1.y;
this.m_upperLimit.x = -this.m_normal1.x;
this.m_upperLimit.y = -this.m_normal1.y
} else {
this.m_normal.x = -this.m_normal1.x;
this.m_normal.y = -this.m_normal1.y;
this.m_lowerLimit.x = this.m_normal1.x;
this.m_lowerLimit.y = this.m_normal1.y;
this.m_upperLimit.x = -this.m_normal0.x;
this.m_upperLimit.y = -this.m_normal0.y
}
}
} else {
if (hasVertex3) {
if (convex2) {
this.m_front = offset1 >= 0 || offset2 >= 0;
if (this.m_front) {
this.m_normal.x = this.m_normal1.x;
this.m_normal.y = this.m_normal1.y;
this.m_lowerLimit.x = -this.m_normal1.x;
this.m_lowerLimit.y = -this.m_normal1.y;
this.m_upperLimit.x = this.m_normal2.x;
this.m_upperLimit.y = this.m_normal2.y
} else {
this.m_normal.x = -this.m_normal1.x;
this.m_normal.y = -this.m_normal1.y;
this.m_lowerLimit.x = -this.m_normal1.x;
this.m_lowerLimit.y = -this.m_normal1.y;
this.m_upperLimit.x = this.m_normal1.x;
this.m_upperLimit.y = this.m_normal1.y
}
} else {
this.m_front = offset1 >= 0 && offset2 >= 0;
if (this.m_front) {
this.m_normal.x = this.m_normal1.x;
this.m_normal.y = this.m_normal1.y;
this.m_lowerLimit.x = -this.m_normal1.x;
this.m_lowerLimit.y = -this.m_normal1.y;
this.m_upperLimit.x = this.m_normal1.x;
this.m_upperLimit.y = this.m_normal1.y
} else {
this.m_normal.x = -this.m_normal1.x;
this.m_normal.y = -this.m_normal1.y;
this.m_lowerLimit.x = -this.m_normal2.x;
this.m_lowerLimit.y = -this.m_normal2.y;
this.m_upperLimit.x = this.m_normal1.x;
this.m_upperLimit.y = this.m_normal1.y
}
}
} else {
this.m_front = offset1 >= 0;
if (this.m_front) {
this.m_normal.x = this.m_normal1.x;
this.m_normal.y = this.m_normal1.y;
this.m_lowerLimit.x = -this.m_normal1.x;
this.m_lowerLimit.y = -this.m_normal1.y;
this.m_upperLimit.x = -this.m_normal1.x;
this.m_upperLimit.y = -this.m_normal1.y
} else {
this.m_normal.x = -this.m_normal1.x;
this.m_normal.y = -this.m_normal1.y;
this.m_lowerLimit.x = this.m_normal1.x;
this.m_lowerLimit.y = this.m_normal1.y;
this.m_upperLimit.x = this.m_normal1.x;
this.m_upperLimit.y = this.m_normal1.y
}
}
}
}
this.m_polygonB.count = polygonB.m_count;
for (var i = 0; i < polygonB.m_count; ++i) {
this.m_polygonB.vertices[i] = b2Mul_t_v2(this.m_xf, polygonB.m_vertices[i]);
this.m_polygonB.normals[i] = b2Mul_r_v2(this.m_xf.q, polygonB.m_normals[i])
}
this.m_radius = 2 * b2_polygonRadius;
manifold.pointCount = 0;
var edgeAxis = this.ComputeEdgeSeparation();
if (edgeAxis.type == b2EPAxis.e_unknown) {
return
}
if (edgeAxis.separation > this.m_radius) {
return
}
var polygonAxis = this.ComputePolygonSeparation();
if (polygonAxis.type != b2EPAxis.e_unknown && polygonAxis.separation > this.m_radius) {
return
}
var k_relativeTol = 0.98;
var k_absoluteTol = 0.001;
var primaryAxis = new b2EPAxis();
if (polygonAxis.type == b2EPAxis.e_unknown) {
primaryAxis = edgeAxis
} else {
if (polygonAxis.separation > k_relativeTol * edgeAxis.separation + k_absoluteTol) {
primaryAxis = polygonAxis
} else {
primaryAxis = edgeAxis
}
}
var ie = new Array(2);
var rf = new b2ReferenceFace();
if (primaryAxis.type == b2EPAxis.e_edgeA) {
manifold.type = b2Manifold.e_faceA;
var bestIndex = 0;
var bestValue = this.m_normal.x * this.m_polygonB.normals[0].x + this.m_normal.y * this.m_polygonB.normals[0].y;
for (var i = 1; i < this.m_polygonB.count; ++i) {
var value = this.m_normal.x * this.m_polygonB.normals[i].x + this.m_normal.y * this.m_polygonB.normals[i].y;
if (value < bestValue) {
bestValue = value;
bestIndex = i
}
}
var i1 = bestIndex;
var i2 = i1 + 1 < this.m_polygonB.count ? i1 + 1 : 0;
ie[0] = new b2ClipVertex();
ie[0].v.x = this.m_polygonB.vertices[i1].x;
ie[0].v.y = this.m_polygonB.vertices[i1].y;
ie[0].id.indexA = 0;
ie[0].id.indexB = i1;
ie[0].id.typeA = b2ContactID.e_face;
ie[0].id.typeB = b2ContactID.e_vertex;
ie[1] = new b2ClipVertex();
ie[1].v.x = this.m_polygonB.vertices[i2].x;
ie[1].v.y = this.m_polygonB.vertices[i2].y;
ie[1].id.indexA = 0;
ie[1].id.indexB = i2;
ie[1].id.typeA = b2ContactID.e_face;
ie[1].id.typeB = b2ContactID.e_vertex;
if (this.m_front) {
rf.i1 = 0;
rf.i2 = 1;
rf.v1.x = this.m_v1.x;
rf.v1.y = this.m_v1.y;
rf.v2.x = this.m_v2.x;
rf.v2.y = this.m_v2.y;
rf.normal.x = this.m_normal1.x;
rf.normal.y = this.m_normal1.y
} else {
rf.i1 = 1;
rf.i2 = 0;
rf.v1.x = this.m_v2.x;
rf.v1.y = this.m_v2.y;
rf.v2.x = this.m_v1.x;
rf.v2.y = this.m_v1.y;
rf.normal.x = -this.m_normal1.x;
rf.normal.y = -this.m_normal1.y
}
} else {
manifold.type = b2Manifold.e_faceB;
ie[0] = new b2ClipVertex();
ie[0].v = this.m_v1;
ie[0].id.indexA = 0;
ie[0].id.indexB = primaryAxis.index;
ie[0].id.typeA = b2ContactID.e_vertex;
ie[0].id.typeB = b2ContactID.e_face;
ie[1] = new b2ClipVertex();
ie[1].v = this.m_v2;
ie[1].id.indexA = 0;
ie[1].id.indexB = primaryAxis.index;
ie[1].id.typeA = b2ContactID.e_vertex;
ie[1].id.typeB = b2ContactID.e_face;
rf.i1 = primaryAxis.index;
rf.i2 = rf.i1 + 1 < this.m_polygonB.count ? rf.i1 + 1 : 0;
rf.v1.x = this.m_polygonB.vertices[rf.i1].x;
rf.v1.y = this.m_polygonB.vertices[rf.i1].y;
rf.v2.x = this.m_polygonB.vertices[rf.i2].x;
rf.v2.y = this.m_polygonB.vertices[rf.i2].y;
rf.normal.x = this.m_polygonB.normals[rf.i1].x;
rf.normal.y = this.m_polygonB.normals[rf.i1].y
}
rf.sideNormal1.x = rf.normal.y;
rf.sideNormal1.y = -rf.normal.x;
rf.sideNormal2.x = -rf.sideNormal1.x;
rf.sideNormal2.y = -rf.sideNormal1.y;
rf.sideOffset1 = rf.sideNormal1.x * rf.v1.x + rf.sideNormal1.y * rf.v1.y;
rf.sideOffset2 = rf.sideNormal2.x * rf.v2.x + rf.sideNormal2.y * rf.v2.y;
var clipPoints1 = new Array(2);
var clipPoints2 = new Array(2);
var np;
np = b2ClipSegmentToLine(clipPoints1, ie, rf.sideNormal1.x, rf.sideNormal1.y, rf.sideOffset1, rf.i1);
if (np < b2_maxManifoldPoints) {
return
}
np = b2ClipSegmentToLine(clipPoints2, clipPoints1, rf.sideNormal2.x, rf.sideNormal2.y, rf.sideOffset2, rf.i2);
if (np < b2_maxManifoldPoints) {
return
}
if (primaryAxis.type == b2EPAxis.e_edgeA) {
manifold.localNormal.x = rf.normal.x;
manifold.localNormal.y = rf.normal.y;
manifold.localPoint.x = rf.v1.x;
manifold.localPoint.y = rf.v1.y
} else {
manifold.localNormal.x = polygonB.m_normals[rf.i1].x;
manifold.localNormal.y = polygonB.m_normals[rf.i1].y;
manifold.localPoint.x = polygonB.m_vertices[rf.i1].x;
manifold.localPoint.y = polygonB.m_vertices[rf.i1].y
}
var pointCount = 0;
for (var i = 0; i < b2_maxManifoldPoints; ++i) {
var separation = rf.normal.x * (clipPoints2[i].v.x - rf.v1.x) + rf.normal.y * (clipPoints2[i].v.y - rf.v1.y);
if (separation <= this.m_radius) {
var cp = manifold.points[pointCount] = new b2ManifoldPoint();
if (primaryAxis.type == b2EPAxis.e_edgeA) {
cp.localPoint.Assign(b2MulT_t_v2(this.m_xf, clipPoints2[i].v));
cp.id.Assign(clipPoints2[i].id)
} else {
cp.localPoint.x = clipPoints2[i].v.x;
cp.localPoint.y = clipPoints2[i].v.y;
cp.id.typeA = clipPoints2[i].id.typeB;
cp.id.typeB = clipPoints2[i].id.typeA;
cp.id.indexA = clipPoints2[i].id.indexB;
cp.id.indexB = clipPoints2[i].id.indexA
}++pointCount
}
}
manifold.pointCount = pointCount
},
ComputeEdgeSeparation: function () {
var axis = new b2EPAxis();
axis.type = b2EPAxis.e_edgeA;
axis.index = this.m_front ? 0 : 1;
axis.separation = Number.MAX_VALUE;
for (var i = 0; i < this.m_polygonB.count; ++i) {
var s = this.m_normal.x * (this.m_polygonB.vertices[i].x - this.m_v1.x) + this.m_normal.y * (this.m_polygonB.vertices[i].y - this.m_v1.y);
if (s < axis.separation) {
axis.separation = s
}
}
return axis
},
ComputePolygonSeparation: function () {
var axis = new b2EPAxis();
axis.type = b2EPAxis.e_unknown;
axis.index = -1;
axis.separation = -Number.MAX_VALUE;
var perpx = -this.m_normal.y;
var perpy = this.m_normal.x;
for (var i = 0; i < this.m_polygonB.count; ++i) {
var nx = -this.m_polygonB.normals[i].x;
var ny = -this.m_polygonB.normals[i].y;
var s1 = nx * (this.m_polygonB.vertices[i].x - this.m_v1.x) + ny * (this.m_polygonB.vertices[i].y - this.m_v1.y);
var s2 = nx * (this.m_polygonB.vertices[i].x - this.m_v2.x) + ny * (this.m_polygonB.vertices[i].y - this.m_v2.y);
var s = b2Min(s1, s2);
if (s > this.m_radius) {
axis.type = b2EPAxis.e_edgeB;
axis.index = i;
axis.separation = s;
return axis
}
if (nx * perpx + ny * perpy >= 0) {
if ((nx - this.m_upperLimit.x) * this.m_normal.x + (ny - this.m_upperLimit.y) * this.m_normal.y < -b2_angularSlop) {
continue
}
} else {
if ((nx - this.m_lowerLimit.x) * this.m_normal.x + (ny - this.m_lowerLimit.y) * this.m_normal.y < -b2_angularSlop) {
continue
}
}
if (s > axis.separation) {
axis.type = b2EPAxis.e_edgeB;
axis.index = i;
axis.separation = s
}
}
return axis
}
};
b2EPCollider.e_isolated = 0;
b2EPCollider.e_concave = 1;
b2EPCollider.e_convex = 2;
function b2CollideEdgeAndPolygon(manifold, edgeA, xfA, polygonB, xfB) {
b2CollideEdgeAndPolygon.collider.Collide(manifold, edgeA, xfA, polygonB, xfB)
}
b2CollideEdgeAndPolygon.collider = new b2EPCollider();
function b2ClipSegmentToLine(vOut, vIn, normalx, normaly, offset, vertexIndexA) {
var numOut = 0;
var distance0 = (normalx * vIn[0].v.x + normaly * vIn[0].v.y) - offset;
var distance1 = (normalx * vIn[1].v.x + normaly * vIn[1].v.y) - offset;
if (distance0 <= 0) {
vOut[numOut++] = vIn[0]
}
if (distance1 <= 0) {
vOut[numOut++] = vIn[1]
}
if (distance0 * distance1 < 0) {
var interp = distance0 / (distance0 - distance1);
vOut[numOut] = new b2ClipVertex();
vOut[numOut].v.x = vIn[0].v.x + (interp * (vIn[1].v.x - vIn[0].v.x));
vOut[numOut].v.y = vIn[0].v.y + (interp * (vIn[1].v.y - vIn[0].v.y));
vOut[numOut].id.indexA = vertexIndexA;
vOut[numOut].id.indexB = vIn[0].id.indexB;
vOut[numOut].id.typeA = b2ContactID.e_vertex;
vOut[numOut].id.typeB = b2ContactID.e_face;
++numOut
}
return numOut
}
function b2TestShapeOverlap(shapeA, indexA, shapeB, indexB, xfA, xfB) {
b2TestShapeOverlap.input.proxyA.Set(shapeA, indexA);
b2TestShapeOverlap.input.proxyB.Set(shapeB, indexB);
b2TestShapeOverlap.input.transformA = xfA;
b2TestShapeOverlap.input.transformB = xfB;
b2TestShapeOverlap.input.useRadii = true;
b2TestShapeOverlap.cache.count = 0;
b2DistanceFunc(b2TestShapeOverlap.output, b2TestShapeOverlap.cache, b2TestShapeOverlap.input);
return b2TestShapeOverlap.output.distance < 10 * b2_epsilon
}
b2TestShapeOverlap.input = new b2DistanceInput();
b2TestShapeOverlap.cache = new b2SimplexCache();
b2TestShapeOverlap.output = new b2DistanceOutput();
function b2TestOverlap(a, b) {
return !((b.lowerBound.x - a.upperBound.x) > 0 || (b.lowerBound.y - a.upperBound.y) > 0 || (a.lowerBound.x - b.upperBound.x) > 0 || (a.lowerBound.y - b.upperBound.y) > 0)
}
"use strict";
var b2_nullNode = -1;
function b2TreeNode() {
this.aabb = new b2AABB();
this.userData = null;
this.parent = 0;
this.child1 = this.child2 = this.height = 0
}
b2TreeNode.prototype = {
IsLeaf: function () {
return this.child1 == b2_nullNode
}
};
function b2DynamicTree() {
this.m_root = b2_nullNode;
this.m_nodeCapacity = 16;
this.m_nodeCount = 0;
this.m_nodes = new Array(this.m_nodeCapacity);
for (var i = 0; i < this.m_nodeCapacity - 1; ++i) {
this.m_nodes[i] = new b2TreeNode();
this.m_nodes[i].parent = i + 1;
this.m_nodes[i].height = -1
}
this.m_nodes[this.m_nodeCapacity - 1] = new b2TreeNode();
this.m_nodes[this.m_nodeCapacity - 1].parent = b2_nullNode;
this.m_nodes[this.m_nodeCapacity - 1].height = -1;
this.m_freeList = 0;
this.m_path = 0;
this.m_insertionCount = 0
}
b2DynamicTree.aabbExtensionFattener = new b2Vec2(b2_aabbExtension, b2_aabbExtension);
b2DynamicTree.prototype = {
CreateProxy: function (aabb, userData) {
var proxyId = this.AllocateNode();
this.m_nodes[proxyId].aabb.lowerBound.Assign(b2Vec2.Subtract(aabb.lowerBound, b2DynamicTree.aabbExtensionFattener));
this.m_nodes[proxyId].aabb.upperBound.Assign(b2Vec2.Add(aabb.upperBound, b2DynamicTree.aabbExtensionFattener));
this.m_nodes[proxyId].userData = userData;
this.m_nodes[proxyId].height = 0;
this.InsertLeaf(proxyId);
return proxyId
},
DestroyProxy: function (proxyId) {
this.RemoveLeaf(proxyId);
this.FreeNode(proxyId)
},
MoveProxy: function (proxyId, aabb, displacement) {
if (this.m_nodes[proxyId].aabb.Contains(aabb)) {
return false
}
this.RemoveLeaf(proxyId);
this.m_nodes[proxyId].aabb.Assign(aabb);
this.m_nodes[proxyId].aabb.lowerBound.Subtract(b2DynamicTree.aabbExtensionFattener);
this.m_nodes[proxyId].aabb.upperBound.Add(b2DynamicTree.aabbExtensionFattener);
var d = b2Vec2.Multiply(b2_aabbMultiplier, displacement);
if (d.x < 0) {
this.m_nodes[proxyId].aabb.lowerBound.x += d.x
} else {
this.m_nodes[proxyId].aabb.upperBound.x += d.x
}
if (d.y < 0) {
this.m_nodes[proxyId].aabb.lowerBound.y += d.y
} else {
this.m_nodes[proxyId].aabb.upperBound.y += d.y
}
this.InsertLeaf(proxyId);
return true
},
GetUserData: function (proxyId) {
return this.m_nodes[proxyId].userData
},
GetFatAABB: function (proxyId) {
return this.m_nodes[proxyId].aabb
},
Query: function (callback, aabb) {
var stack = [];
stack.push(this.m_root);
while (stack.length > 0) {
var nodeId = stack.pop();
if (nodeId == b2_nullNode) {
continue
}
var node = this.m_nodes[nodeId];
if (b2TestOverlap(node.aabb, aabb)) {
if (node.IsLeaf()) {
var proceed = callback.QueryCallback(nodeId);
if (proceed == false) {
return
}
} else {
stack.push(node.child1);
stack.push(node.child2)
}
}
}
},
RayCast: function (callback, input) {
var p1 = input.p1;
var p2 = input.p2;
var r = b2Vec2.Subtract(p2, p1);
r.Normalize();
var v = b2Cross_f_v2(1, r);
var abs_v = b2Abs_v2(v);
var maxFraction = input.maxFraction;
var segmentAABB = new b2AABB();
var t = b2Vec2.Add(p1, b2Vec2.Multiply(maxFraction, b2Vec2.Subtract(p2, p1)));
segmentAABB.lowerBound.Assign(b2Min_v2(p1, t));
segmentAABB.upperBound.Assign(b2Max_v2(p1, t));
var stack = [];
stack.push(this.m_root);
while (stack.length > 0) {
var nodeId = stack.pop();
if (nodeId == b2_nullNode) {
continue
}
var node = this.m_nodes[nodeId];
if (b2TestOverlap(node.aabb, segmentAABB) == false) {
continue
}
var c = node.aabb.GetCenter();
var h = node.aabb.GetExtents();
var separation = b2Abs(b2Dot_v2_v2(v, b2Vec2.Subtract(p1, c))) - b2Dot_v2_v2(abs_v, h);
if (separation > 0) {
continue
}
if (node.IsLeaf()) {
var subInput = new b2RayCastInput();
subInput.p1.Assign(input.p1);
subInput.p2.Assign(input.p2);
subInput.maxFraction = maxFraction;
var value = callback.RayCastCallback(subInput, nodeId);
if (value == 0) {
return
}
if (value > 0) {
maxFraction = value;
var t = b2Vec2.Add(p1, b2Vec2.Multiply(maxFraction, b2Vec2.Subtract(p2, p1)));
segmentAABB.lowerBound.Assign(b2Min_v2(p1, t));
segmentAABB.upperBound.Assign(b2Max_v2(p1, t))
}
} else {
stack.push(node.child1);
stack.push(node.child2)
}
}
},
Validate: function () {
this.ValidateStructure(this.m_root);
this.ValidateMetrics(this.m_root);
var freeCount = 0;
var freeIndex = this.m_freeList;
while (freeIndex != b2_nullNode) {
freeIndex = this.m_nodes[freeIndex].parent;
++freeCount
}
},
GetHeight: function () {
if (this.m_root == b2_nullNode) {
return 0
}
return this.m_nodes[this.m_root].height
},
GetMaxBalance: function () {
var maxBalance = 0;
for (var i = 0; i < this.m_nodeCapacity; ++i) {
var node = this.m_nodes[i];
if (node.height <= 1) {
continue
}
var child1 = node.child1;
var child2 = node.child2;
var balance = b2Abs(this.m_nodes[child2].height - this.m_nodes[child1].height);
maxBalance = b2Max(maxBalance, balance)
}
return maxBalance
},
GetAreaRatio: function () {
if (this.m_root == b2_nullNode) {
return 0
}
var root = this.m_nodes[this.m_root];
var rootArea = root.aabb.GetPerimeter();
var totalArea = 0;
for (var i = 0; i < this.m_nodeCapacity; ++i) {
var node = this.m_nodes[i];
if (node.height < 0) {
continue
}
totalArea += node.aabb.GetPerimeter()
}
return totalArea / rootArea
},
RebuildBottomUp: function () {
var nodes = new Array(this.m_nodeCount);
var count = 0;
for (var i = 0; i < this.m_nodeCapacity; ++i) {
if (this.m_nodes[i].height < 0) {
continue
}
if (this.m_nodes[i].IsLeaf()) {
this.m_nodes[i].parent = b2_nullNode;
nodes[count] = i;
++count
} else {
this.FreeNode(i)
}
}
while (count > 1) {
var minCost = b2_maxFloat;
var iMin = -1,
jMin = -1;
for (i = 0; i < count; ++i) {
var aabbi = this.m_nodes[nodes[i]].aabb;
for (var j = i + 1; j < count; ++j) {
var aabbj = this.m_nodes[nodes[j]].aabb;
var b = new b2AABB();
b.Combine(aabbi, aabbj);
var cost = b.GetPerimeter();
if (cost < minCost) {
iMin = i;
jMin = j;
minCost = cost
}
}
}
var index1 = nodes[iMin];
var index2 = nodes[jMin];
var child1 = this.m_nodes[index1];
var child2 = this.m_nodes[index2];
var parentIndex = this.AllocateNode();
var parent = this.m_nodes[parentIndex];
parent.child1 = index1;
parent.child2 = index2;
parent.height = 1 + b2Max(child1.height, child2.height);
parent.aabb.Combine(child1.aabb, child2.aabb);
parent.parent = b2_nullNode;
child1.parent = parentIndex;
child2.parent = parentIndex;
nodes[jMin] = nodes[count - 1];
nodes[iMin] = parentIndex;
--count
}
this.m_root = nodes[0];
this.Validate()
},
ShiftOrigin: function (newOrigin) {
for (var i = 0; i < this.m_nodeCapacity; ++i) {
this.m_nodes[i].aabb.lowerBound.Subtract(newOrigin);
this.m_nodes[i].aabb.upperBound.Subtract(newOrigin)
}
},
AllocateNode: function () {
if (this.m_freeList == b2_nullNode) {
var oldNodes = this.m_nodes;
this.m_nodeCapacity *= 2;
this.m_nodes = oldNodes.concat(new Array(this.m_nodeCapacity - this.m_nodeCount));
for (var i = this.m_nodeCount; i < this.m_nodeCapacity - 1; ++i) {
this.m_nodes[i] = new b2TreeNode();
this.m_nodes[i].parent = i + 1;
this.m_nodes[i].height = -1
}
this.m_nodes[this.m_nodeCapacity - 1] = new b2TreeNode();
this.m_nodes[this.m_nodeCapacity - 1].parent = b2_nullNode;
this.m_nodes[this.m_nodeCapacity - 1].height = -1;
this.m_freeList = this.m_nodeCount
}
var nodeId = this.m_freeList;
this.m_freeList = this.m_nodes[nodeId].parent;
this.m_nodes[nodeId].parent = b2_nullNode;
this.m_nodes[nodeId].child1 = b2_nullNode;
this.m_nodes[nodeId].child2 = b2_nullNode;
this.m_nodes[nodeId].height = 0;
this.m_nodes[nodeId].userData = null;
++this.m_nodeCount;
return nodeId
},
FreeNode: function (nodeId) {
this.m_nodes[nodeId].parent = this.m_freeList;
this.m_nodes[nodeId].height = -1;
this.m_freeList = nodeId;
--this.m_nodeCount
},
InsertLeaf: function (leaf) {
++this.m_insertionCount;
if (this.m_root == b2_nullNode) {
this.m_root = leaf;
this.m_nodes[this.m_root].parent = b2_nullNode;
return
}
var leafAABB = this.m_nodes[leaf].aabb;
var index = this.m_root;
while (this.m_nodes[index].IsLeaf() == false) {
var child1 = this.m_nodes[index].child1;
var child2 = this.m_nodes[index].child2;
var area = this.m_nodes[index].aabb.GetPerimeter();
var combinedAABB = new b2AABB();
combinedAABB.Combine(this.m_nodes[index].aabb, leafAABB);
var combinedArea = combinedAABB.GetPerimeter();
var cost = 2 * combinedArea;
var inheritanceCost = 2 * (combinedArea - area);
var cost1;
var aabb;
if (this.m_nodes[child1].IsLeaf()) {
aabb = new b2AABB();
aabb.Combine(leafAABB, this.m_nodes[child1].aabb);
cost1 = aabb.GetPerimeter() + inheritanceCost
} else {
aabb = new b2AABB();
aabb.Combine(leafAABB, this.m_nodes[child1].aabb);
var oldArea = this.m_nodes[child1].aabb.GetPerimeter();
var newArea = aabb.GetPerimeter();
cost1 = (newArea - oldArea) + inheritanceCost
}
var cost2;
if (this.m_nodes[child2].IsLeaf()) {
aabb = new b2AABB();
aabb.Combine(leafAABB, this.m_nodes[child2].aabb);
cost2 = aabb.GetPerimeter() + inheritanceCost
} else {
aabb = new b2AABB();
aabb.Combine(leafAABB, this.m_nodes[child2].aabb);
var oldArea = this.m_nodes[child2].aabb.GetPerimeter();
var newArea = aabb.GetPerimeter();
cost2 = newArea - oldArea + inheritanceCost
}
if (cost < cost1 && cost < cost2) {
break
}
if (cost1 < cost2) {
index = child1
} else {
index = child2
}
}
var sibling = index;
var oldParent = this.m_nodes[sibling].parent;
var newParent = this.AllocateNode();
this.m_nodes[newParent].parent = oldParent;
this.m_nodes[newParent].userData = null;
this.m_nodes[newParent].aabb.Combine(leafAABB, this.m_nodes[sibling].aabb);
this.m_nodes[newParent].height = this.m_nodes[sibling].height + 1;
if (oldParent != b2_nullNode) {
if (this.m_nodes[oldParent].child1 == sibling) {
this.m_nodes[oldParent].child1 = newParent
} else {
this.m_nodes[oldParent].child2 = newParent
}
this.m_nodes[newParent].child1 = sibling;
this.m_nodes[newParent].child2 = leaf;
this.m_nodes[sibling].parent = newParent;
this.m_nodes[leaf].parent = newParent
} else {
this.m_nodes[newParent].child1 = sibling;
this.m_nodes[newParent].child2 = leaf;
this.m_nodes[sibling].parent = newParent;
this.m_nodes[leaf].parent = newParent;
this.m_root = newParent
}
index = this.m_nodes[leaf].parent;
while (index != b2_nullNode) {
index = this.Balance(index);
var child1 = this.m_nodes[index].child1;
var child2 = this.m_nodes[index].child2;
this.m_nodes[index].height = 1 + b2Max(this.m_nodes[child1].height, this.m_nodes[child2].height);
this.m_nodes[index].aabb.Combine(this.m_nodes[child1].aabb, this.m_nodes[child2].aabb);
index = this.m_nodes[index].parent
}
},
RemoveLeaf: function (leaf) {
if (leaf == this.m_root) {
this.m_root = b2_nullNode;
return
}
var parent = this.m_nodes[leaf].parent;
var grandParent = this.m_nodes[parent].parent;
var sibling;
if (this.m_nodes[parent].child1 == leaf) {
sibling = this.m_nodes[parent].child2
} else {
sibling = this.m_nodes[parent].child1
}
if (grandParent != b2_nullNode) {
if (this.m_nodes[grandParent].child1 == parent) {
this.m_nodes[grandParent].child1 = sibling
} else {
this.m_nodes[grandParent].child2 = sibling
}
this.m_nodes[sibling].parent = grandParent;
this.FreeNode(parent);
var index = grandParent;
while (index != b2_nullNode) {
index = this.Balance(index);
var child1 = this.m_nodes[index].child1;
var child2 = this.m_nodes[index].child2;
this.m_nodes[index].aabb.Combine(this.m_nodes[child1].aabb, this.m_nodes[child2].aabb);
this.m_nodes[index].height = 1 + b2Max(this.m_nodes[child1].height, this.m_nodes[child2].height);
index = this.m_nodes[index].parent
}
} else {
this.m_root = sibling;
this.m_nodes[sibling].parent = b2_nullNode;
this.FreeNode(parent)
}
},
Balance: function (iA) {
var A = this.m_nodes[iA];
if (A.IsLeaf() || A.height < 2) {
return iA
}
var iB = A.child1;
var iC = A.child2;
var B = this.m_nodes[iB];
var C = this.m_nodes[iC];
var balance = C.height - B.height;
if (balance > 1) {
var iF = C.child1;
var iG = C.child2;
var F = this.m_nodes[iF];
var G = this.m_nodes[iG];
C.child1 = iA;
C.parent = A.parent;
A.parent = iC;
if (C.parent != b2_nullNode) {
if (this.m_nodes[C.parent].child1 == iA) {
this.m_nodes[C.parent].child1 = iC
} else {
this.m_nodes[C.parent].child2 = iC
}
} else {
this.m_root = iC
}
if (F.height > G.height) {
C.child2 = iF;
A.child2 = iG;
G.parent = iA;
A.aabb.Combine(B.aabb, G.aabb);
C.aabb.Combine(A.aabb, F.aabb);
A.height = 1 + b2Max(B.height, G.height);
C.height = 1 + b2Max(A.height, F.height)
} else {
C.child2 = iG;
A.child2 = iF;
F.parent = iA;
A.aabb.Combine(B.aabb, F.aabb);
C.aabb.Combine(A.aabb, G.aabb);
A.height = 1 + b2Max(B.height, F.height);
C.height = 1 + b2Max(A.height, G.height)
}
return iC
}
if (balance < -1) {
var iD = B.child1;
var iE = B.child2;
var D = this.m_nodes[iD];
var E = this.m_nodes[iE];
B.child1 = iA;
B.parent = A.parent;
A.parent = iB;
if (B.parent != b2_nullNode) {
if (this.m_nodes[B.parent].child1 == iA) {
this.m_nodes[B.parent].child1 = iB
} else {
this.m_nodes[B.parent].child2 = iB
}
} else {
this.m_root = iB
}
if (D.height > E.height) {
B.child2 = iD;
A.child1 = iE;
E.parent = iA;
A.aabb.Combine(C.aabb, E.aabb);
B.aabb.Combine(A.aabb, D.aabb);
A.height = 1 + b2Max(C.height, E.height);
B.height = 1 + b2Max(A.height, D.height)
} else {
B.child2 = iE;
A.child1 = iD;
D.parent = iA;
A.aabb.Combine(C.aabb, D.aabb);
B.aabb.Combine(A.aabb, E.aabb);
A.height = 1 + b2Max(C.height, D.height);
B.height = 1 + b2Max(A.height, E.height)
}
return iB
}
return iA
},
ComputeHeight: function (nodeId) {
if (typeof (nodeId) === "undefined") {
nodeId = this.m_root
}
var node = this.m_nodes[nodeId];
if (node.IsLeaf()) {
return 0
}
var height1 = this.ComputeHeight(node.child1);
var height2 = this.ComputeHeight(node.child2);
return 1 + b2Max(height1, height2)
},
ValidateStructure: function (index) {
if (index == b2_nullNode) {
return
}
var node = this.m_nodes[index];
var child1 = node.child1;
var child2 = node.child2;
if (node.IsLeaf()) {
return
}
this.ValidateStructure(child1);
this.ValidateStructure(child2)
},
ValidateMetrics: function (index) {
if (index == b2_nullNode) {
return
}
var node = this.m_nodes[index];
var child1 = node.child1;
var child2 = node.child2;
if (node.IsLeaf()) {
return
}
var height1 = this.m_nodes[child1].height;
var height2 = this.m_nodes[child2].height;
var height;
height = 1 + b2Max(height1, height2);
var aabb = new b2AABB();
aabb.Combine(this.m_nodes[child1].aabb, this.m_nodes[child2].aabb);
this.ValidateMetrics(child1);
this.ValidateMetrics(child2)
}
};
"use strict";
function b2TOIInput() {
this.proxyA = new b2DistanceProxy();
this.proxyB = new b2DistanceProxy();
this.sweepA = new b2Sweep();
this.sweepB = new b2Sweep();
this.tMax = 0
}
function b2TOIOutput() {
this.state = 0;
this.t = 0
}
b2TOIOutput.e_unknown = 0;
b2TOIOutput.e_failed = 1;
b2TOIOutput.e_overlapped = 2;
b2TOIOutput.e_touching = 3;
b2TOIOutput.e_separated = 4;
function b2SeparationFunction() {
this.m_proxyA = null;
this.m_proxyB = null;
this.m_sweepA = null;
this.m_sweepB = null;
this.m_type = 0;
this.m_localPoint = new b2Vec2();
this.m_axis = new b2Vec2()
}
var _local_xfA = new b2Transform();
var _local_xfB = new b2Transform();
b2SeparationFunction.prototype = {
Initialize: function (cache, proxyA, sweepA, proxyB, sweepB, t1) {
this.m_proxyA = proxyA;
this.m_proxyB = proxyB;
var count = cache.count;
this.m_sweepA = sweepA;
this.m_sweepB = sweepB;
this.m_sweepA.GetTransform(_local_xfA, t1);
this.m_sweepB.GetTransform(_local_xfB, t1);
if (count == 1) {
this.m_type = b2SeparationFunction.e_points;
var localPointA = this.m_proxyA.GetVertex(cache.indexA[0]);
var localPointB = this.m_proxyB.GetVertex(cache.indexB[0]);
var pointAx = (_local_xfA.q.c * localPointA.x - _local_xfA.q.s * localPointA.y) + _local_xfA.p.x;
var pointAy = (_local_xfA.q.s * localPointA.x + _local_xfA.q.c * localPointA.y) + _local_xfA.p.y;
var pointBx = (_local_xfB.q.c * localPointB.x - _local_xfB.q.s * localPointB.y) + _local_xfB.p.x;
var pointBy = (_local_xfB.q.s * localPointB.x + _local_xfB.q.c * localPointB.y) + _local_xfB.p.y;
this.m_axis.x = pointBx - pointAx;
this.m_axis.y = pointBy - pointAy;
var s = this.m_axis.Normalize();
return s
} else {
if (cache.indexA[0] == cache.indexA[1]) {
this.m_type = b2SeparationFunction.e_faceB;
var localPointB1 = proxyB.GetVertex(cache.indexB[0]);
var localPointB2 = proxyB.GetVertex(cache.indexB[1]);
this.m_axis.x = 1 * (localPointB2.y - localPointB1.y);
this.m_axis.y = -1 * (localPointB2.x - localPointB1.x);
this.m_axis.Normalize();
var normalx = _local_xfB.q.c * this.m_axis.x - _local_xfB.q.s * this.m_axis.y;
var normaly = _local_xfB.q.s * this.m_axis.x + _local_xfB.q.c * this.m_axis.y;
this.m_localPoint.x = 0.5 * (localPointB1.x + localPointB2.x);
this.m_localPoint.y = 0.5 * (localPointB1.y + localPointB2.y);
var pointBx = (_local_xfB.q.c * this.m_localPoint.x - _local_xfB.q.s * this.m_localPoint.y) + _local_xfB.p.x;
var pointBy = (_local_xfB.q.s * this.m_localPoint.x + _local_xfB.q.c * this.m_localPoint.y) + _local_xfB.p.y;
var localPointA = proxyA.GetVertex(cache.indexA[0]);
var pointAx = (_local_xfA.q.c * localPointA.x - _local_xfA.q.s * localPointA.y) + _local_xfA.p.x;
var pointAy = (_local_xfA.q.s * localPointA.x + _local_xfA.q.c * localPointA.y) + _local_xfA.p.y;
var s = (pointAx - pointBx) * normalx + (pointAy - pointBy) * normaly;
if (s < 0) {
this.m_axis.x = -this.m_axis.x;
this.m_axis.y = -this.m_axis.y;
s = -s
}
return s
} else {
this.m_type = b2SeparationFunction.e_faceA;
var localPointA1 = this.m_proxyA.GetVertex(cache.indexA[0]);
var localPointA2 = this.m_proxyA.GetVertex(cache.indexA[1]);
this.m_axis.x = 1 * (localPointA2.y - localPointA1.y);
this.m_axis.y = -1 * (localPointA2.x - localPointA1.x);
this.m_axis.Normalize();
var normalx = _local_xfA.q.c * this.m_axis.x - _local_xfA.q.s * this.m_axis.y;
var normaly = _local_xfA.q.s * this.m_axis.x + _local_xfA.q.c * this.m_axis.y;
this.m_localPoint.x = 0.5 * (localPointA1.x + localPointA2.x);
this.m_localPoint.y = 0.5 * (localPointA1.y + localPointA2.y);
var pointAx = (_local_xfA.q.c * this.m_localPoint.x - _local_xfA.q.s * this.m_localPoint.y) + _local_xfA.p.x;
var pointAy = (_local_xfA.q.s * this.m_localPoint.x + _local_xfA.q.c * this.m_localPoint.y) + _local_xfA.p.y;
var localPointB = this.m_proxyB.GetVertex(cache.indexB[0]);
var pointBx = (_local_xfB.q.c * localPointB.x - _local_xfB.q.s * localPointB.y) + _local_xfB.p.x;
var pointBy = (_local_xfB.q.s * localPointB.x + _local_xfB.q.c * localPointB.y) + _local_xfB.p.y;
var s = (pointBx - pointAx) * normalx + (pointBy - pointAy) * normaly;
if (s < 0) {
this.m_axis.x = -this.m_axis.x;
this.m_axis.y = -this.m_axis.y;
s = -s
}
return s
}
}
},
FindMinSeparation: function (indices, t) {
this.m_sweepA.GetTransform(_local_xfA, t);
this.m_sweepB.GetTransform(_local_xfB, t);
switch (this.m_type) {
case b2SeparationFunction.e_points:
var axisAx = _local_xfA.q.c * this.m_axis.x + _local_xfA.q.s * this.m_axis.y;
var axisAy = -_local_xfA.q.s * this.m_axis.x + _local_xfA.q.c * this.m_axis.y;
var axisBx = _local_xfB.q.c * -this.m_axis.x + _local_xfB.q.s * -this.m_axis.y;
var axisBy = -_local_xfB.q.s * -this.m_axis.x + _local_xfB.q.c * -this.m_axis.y;
indices[0] = this.m_proxyA.GetSupport(axisAx, axisAy);
indices[1] = this.m_proxyB.GetSupport(axisBx, axisBy);
var localPointA = this.m_proxyA.GetVertex(indices[0]);
var localPointB = this.m_proxyB.GetVertex(indices[1]);
var pointAx = (_local_xfA.q.c * localPointA.x - _local_xfA.q.s * localPointA.y) + _local_xfA.p.x;
var pointAy = (_local_xfA.q.s * localPointA.x + _local_xfA.q.c * localPointA.y) + _local_xfA.p.y;
var pointBx = (_local_xfB.q.c * localPointB.x - _local_xfB.q.s * localPointB.y) + _local_xfB.p.x;
var pointBy = (_local_xfB.q.s * localPointB.x + _local_xfB.q.c * localPointB.y) + _local_xfB.p.y;
return (pointBx - pointAx) * this.m_axis.x + (pointBy - pointAy) * this.m_axis.y;
case b2SeparationFunction.e_faceA:
var normalx = _local_xfA.q.c * this.m_axis.x - _local_xfA.q.s * this.m_axis.y;
var normaly = _local_xfA.q.s * this.m_axis.x + _local_xfA.q.c * this.m_axis.y;
var pointAx = (_local_xfA.q.c * this.m_localPoint.x - _local_xfA.q.s * this.m_localPoint.y) + _local_xfA.p.x;
var pointAy = (_local_xfA.q.s * this.m_localPoint.x + _local_xfA.q.c * this.m_localPoint.y) + _local_xfA.p.y;
var axisBx = _local_xfB.q.c * -normalx + _local_xfB.q.s * -normaly;
var axisBy = -_local_xfB.q.s * -normalx + _local_xfB.q.c * -normaly;
indices[0] = -1;
indices[1] = this.m_proxyB.GetSupport(axisBx, axisBy);
var localPointB = this.m_proxyB.GetVertex(indices[1]);
var pointBx = (_local_xfB.q.c * localPointB.x - _local_xfB.q.s * localPointB.y) + _local_xfB.p.x;
var pointBy = (_local_xfB.q.s * localPointB.x + _local_xfB.q.c * localPointB.y) + _local_xfB.p.y;
return (pointBx - pointAx) * normalx + (pointBy - pointAy) * normaly;
case b2SeparationFunction.e_faceB:
var normalx = _local_xfB.q.c * this.m_axis.x - _local_xfB.q.s * this.m_axis.y;
var normaly = _local_xfB.q.s * this.m_axis.x + _local_xfB.q.c * this.m_axis.y;
var pointBx = (_local_xfB.q.c * this.m_localPoint.x - _local_xfB.q.s * this.m_localPoint.y) + _local_xfB.p.x;
var pointBy = (_local_xfB.q.s * this.m_localPoint.x + _local_xfB.q.c * this.m_localPoint.y) + _local_xfB.p.y;
var axisAx = _local_xfA.q.c * -normalx + _local_xfA.q.s * -normaly;
var axisBy = -_local_xfA.q.s * -normalx + _local_xfA.q.c * -normaly;
indices[1] = -1;
indices[0] = this.m_proxyA.GetSupport(axisAx, axisBy);
var localPointA = this.m_proxyA.GetVertex(indices[0]);
var pointAx = (_local_xfA.q.c * localPointA.x - _local_xfA.q.s * localPointA.y) + _local_xfA.p.x;
var pointAy = (_local_xfA.q.s * localPointA.x + _local_xfA.q.c * localPointA.y) + _local_xfA.p.y;
return (pointAx - pointBx) * normalx + (pointAy - pointBy) * normaly
}
},
Evaluate: function (indexA, indexB, t) {
this.m_sweepA.GetTransform(_local_xfA, t);
this.m_sweepB.GetTransform(_local_xfB, t);
switch (this.m_type) {
case b2SeparationFunction.e_points:
var localPointA = this.m_proxyA.GetVertex(indexA);
var localPointB = this.m_proxyB.GetVertex(indexB);
var pointAx = (_local_xfA.q.c * localPointA.x - _local_xfA.q.s * localPointA.y) + _local_xfA.p.x;
var pointAy = (_local_xfA.q.s * localPointA.x + _local_xfA.q.c * localPointA.y) + _local_xfA.p.y;
var pointBx = (_local_xfB.q.c * localPointB.x - _local_xfB.q.s * localPointB.y) + _local_xfB.p.x;
var pointBy = (_local_xfB.q.s * localPointB.x + _local_xfB.q.c * localPointB.y) + _local_xfB.p.y;
var separation = (pointBx - pointAx) * this.m_axis.x + (pointBy - pointAy) * this.m_axis.y;
return separation;
case b2SeparationFunction.e_faceA:
var normalx = _local_xfA.q.c * this.m_axis.x - _local_xfA.q.s * this.m_axis.y;
var normaly = _local_xfA.q.s * this.m_axis.x + _local_xfA.q.c * this.m_axis.y;
var pointAx = (_local_xfA.q.c * this.m_localPoint.x - _local_xfA.q.s * this.m_localPoint.y) + _local_xfA.p.x;
var pointAy = (_local_xfA.q.s * this.m_localPoint.x + _local_xfA.q.c * this.m_localPoint.y) + _local_xfA.p.y;
var localPointB = this.m_proxyB.GetVertex(indexB);
var pointBx = (_local_xfB.q.c * localPointB.x - _local_xfB.q.s * localPointB.y) + _local_xfB.p.x;
var pointBy = (_local_xfB.q.s * localPointB.x + _local_xfB.q.c * localPointB.y) + _local_xfB.p.y;
var separation = (pointBx - pointAx) * normalx + (pointBy - pointAy) * normaly;
return separation;
case b2SeparationFunction.e_faceB:
var normalx = _local_xfB.q.c * this.m_axis.x - _local_xfB.q.s * this.m_axis.y;
var normaly = _local_xfB.q.s * this.m_axis.x + _local_xfB.q.c * this.m_axis.y;
var pointBx = (_local_xfB.q.c * this.m_localPoint.x - _local_xfB.q.s * this.m_localPoint.y) + _local_xfB.p.x;
var pointBy = (_local_xfB.q.s * this.m_localPoint.x + _local_xfB.q.c * this.m_localPoint.y) + _local_xfB.p.y;
var localPointA = this.m_proxyA.GetVertex(indexA);
var pointAx = (_local_xfA.q.c * localPointA.x - _local_xfA.q.s * localPointA.y) + _local_xfA.p.x;
var pointAy = (_local_xfA.q.s * localPointA.x + _local_xfA.q.c * localPointA.y) + _local_xfA.p.y;
var separation = (pointAx - pointBx) * normalx + (pointAy - pointBy) * normaly;
return separation
}
}
};
b2SeparationFunction.e_points = 0;
b2SeparationFunction.e_faceA = 1;
b2SeparationFunction.e_faceB = 2;
var profile_toi = b2Profiler.create("toi", "solveTOI");
function b2TimeOfImpact(output, input) {
profile_toi.start();
++b2TimeOfImpact.b2_toiCalls;
output.state = b2TOIOutput.e_unknown;
output.t = input.tMax;
var proxyA = input.proxyA;
var proxyB = input.proxyB;
b2TimeOfImpact._temp_sweepA.Assign(input.sweepA);
b2TimeOfImpact._temp_sweepB.Assign(input.sweepB);
b2TimeOfImpact._temp_sweepA.Normalize();
b2TimeOfImpact._temp_sweepB.Normalize();
var tMax = input.tMax;
var totalRadius = proxyA.m_radius + proxyB.m_radius;
var target = b2Max(b2_linearSlop, totalRadius - 3 * b2_linearSlop);
var tolerance = 0.25 * b2_linearSlop;
var t1 = 0;
var k_maxIterations = 20;
var iter = 0;
var cache = new b2SimplexCache();
cache.count = 0;
var distanceInput = new b2DistanceInput();
distanceInput.proxyA.Assign(input.proxyA);
distanceInput.proxyB.Assign(input.proxyB);
distanceInput.useRadii = false;
for (;;) {
b2TimeOfImpact._temp_sweepA.GetTransform(distanceInput.transformA, t1);
b2TimeOfImpact._temp_sweepB.GetTransform(distanceInput.transformB, t1);
var distanceOutput = new b2DistanceOutput();
b2DistanceFunc(distanceOutput, cache, distanceInput);
if (distanceOutput.distance <= 0) {
output.state = b2TOIOutput.e_overlapped;
output.t = 0;
break
}
if (distanceOutput.distance < target + tolerance) {
output.state = b2TOIOutput.e_touching;
output.t = t1;
break
}
var fcn = new b2SeparationFunction();
fcn.Initialize(cache, proxyA, b2TimeOfImpact._temp_sweepA, proxyB, b2TimeOfImpact._temp_sweepB, t1);
var done = false;
var t2 = tMax;
var pushBackIter = 0;
for (;;) {
var indices = [];
var s2 = fcn.FindMinSeparation(indices, t2);
if (s2 > target + tolerance) {
output.state = b2TOIOutput.e_separated;
output.t = tMax;
done = true;
break
}
if (s2 > target - tolerance) {
t1 = t2;
break
}
var s1 = fcn.Evaluate(indices[0], indices[1], t1);
if (s1 < target - tolerance) {
output.state = b2TOIOutput.e_failed;
output.t = t1;
done = true;
break
}
if (s1 <= target + tolerance) {
output.state = b2TOIOutput.e_touching;
output.t = t1;
done = true;
break
}
var rootIterCount = 0;
var a1 = t1,
a2 = t2;
for (;;) {
var t;
if (rootIterCount & 1) {
t = a1 + (target - s1) * (a2 - a1) / (s2 - s1)
} else {
t = 0.5 * (a1 + a2)
}++rootIterCount;
++b2TimeOfImpact.b2_toiRootIters;
var s = fcn.Evaluate(indices[0], indices[1], t);
if (b2Abs(s - target) < tolerance) {
t2 = t;
break
}
if (s > target) {
a1 = t;
s1 = s
} else {
a2 = t;
s2 = s
}
if (rootIterCount == 50) {
break
}
}
b2TimeOfImpact.b2_toiMaxRootIters = b2Max(b2TimeOfImpact.b2_toiMaxRootIters, rootIterCount);
++pushBackIter;
if (pushBackIter == b2_maxPolygonVertices) {
break
}
}++iter;
++b2TimeOfImpact.b2_toiIters;
if (done) {
break
}
if (iter == k_maxIterations) {
output.state = b2TOIOutput.e_failed;
output.t = t1;
break
}
}
b2TimeOfImpact.b2_toiMaxIters = b2Max(b2TimeOfImpact.b2_toiMaxIters, iter);
profile_toi.stop();
b2TimeOfImpact.b2_toiMaxTime = b2Max(b2TimeOfImpact.b2_toiMaxTime, profile_toi.elapsedTime);
b2TimeOfImpact.b2_toiTime += profile_toi.elapsedTime
}
b2TimeOfImpact._temp_sweepA = new b2Sweep();
b2TimeOfImpact._temp_sweepB = new b2Sweep();
b2TimeOfImpact.b2_toiTime = 0;
b2TimeOfImpact.b2_toiMaxTime = 0;
b2TimeOfImpact.b2_toiCalls = 0;
b2TimeOfImpact.b2_toiIters = 0;
b2TimeOfImpact.b2_toiMaxIters = 0;
b2TimeOfImpact.b2_toiRootIters = 0;
b2TimeOfImpact.b2_toiMaxRootIters = 0;
"use strict";
function b2BodyDef() {
this.type = b2Body.b2_staticBody;
this.position = new b2Vec2(0, 0);
this.angle = 0;
this.linearVelocity = new b2Vec2(0, 0);
this.angularVelocity = 0;
this.linearDamping = 0;
this.angularDamping = 0;
this.allowSleep = true;
this.awake = true;
this.fixedRotation = false;
this.bullet = false;
this.active = true;
this.userData = null;
this.gravityScale = 1;
Object.seal(this)
}
b2BodyDef.prototype = {
_deserialize: function (data) {
this.type = data.type;
this.position._deserialize(data.position);
this.angle = data.angle;
this.linearVelocity._deserialize(data.linearVelocity);
this.angularVelocity = data.angularVelocity;
this.linearDamping = data.linearDamping;
this.angularDamping = data.angularDamping;
this.allowSleep = data.allowSleep;
this.awake = data.awake;
this.fixedRotation = data.fixedRotation;
this.bullet = data.bullet;
this.active = data.active;
this.gravityScale = data.gravityScale
}
};
function b2Body(bd, world) {
this.m_islandIndex = 0;
this.m_flags = 0;
if (bd.bullet) {
this.m_flags |= b2Body.e_bulletFlag
}
if (bd.fixedRotation) {
this.m_flags |= b2Body.e_fixedRotationFlag
}
if (bd.allowSleep) {
this.m_flags |= b2Body.e_autoSleepFlag
}
if (bd.awake) {
this.m_flags |= b2Body.e_awakeFlag
}
if (bd.active) {
this.m_flags |= b2Body.e_activeFlag
}
this.m_world = world;
this.m_xf = new b2Transform();
this.m_xf.p.Assign(bd.position);
this.m_xf.q.Set(bd.angle);
this.m_sweep = new b2Sweep();
this.m_sweep.localCenter.SetZero();
this.m_sweep.c0.Assign(this.m_xf.p);
this.m_sweep.c.Assign(this.m_xf.p);
this.m_sweep.a0 = bd.angle;
this.m_sweep.a = bd.angle;
this.m_sweep.alpha0 = 0;
this.m_jointList = null;
this.m_contactList = null;
this.m_prev = null;
this.m_next = null;
this.m_linearVelocity = bd.linearVelocity.Clone();
this.m_angularVelocity = bd.angularVelocity;
this.m_linearDamping = bd.linearDamping;
this.m_angularDamping = bd.angularDamping;
this.m_gravityScale = bd.gravityScale;
this.m_force = new b2Vec2();
this.m_torque = 0;
this.m_sleepTime = 0;
this.m_type = bd.type;
if (this.m_type == b2Body.b2_dynamicBody) {
this.m_mass = 1;
this.m_invMass = 1
} else {
this.m_mass = 0;
this.m_invMass = 0
}
this.m_I = 0;
this.m_invI = 0;
this.m_userData = bd.userData;
this.m_fixtureList = null;
this.m_fixtureCount = 0
}
b2Body.b2_staticBody = 0;
b2Body.b2_kinematicBody = 1;
b2Body.b2_dynamicBody = 2;
b2Body.e_islandFlag = 1;
b2Body.e_awakeFlag = 2;
b2Body.e_autoSleepFlag = 4;
b2Body.e_bulletFlag = 8;
b2Body.e_fixedRotationFlag = 16;
b2Body.e_activeFlag = 32;
b2Body.e_toiFlag = 64;
b2Body.m_local_oldCenter = new b2Vec2();
b2Body.m_local_xf1 = new b2Transform();
b2Body.prototype = {
CreateFixture: function (def, density) {
if (typeof (density) !== "undefined") {
var ndef = new b2FixtureDef();
ndef.shape = def;
ndef.density = density;
return this.CreateFixture(ndef)
}
if (this.m_world.IsLocked() == true) {
return null
}
var fixture = new b2Fixture();
fixture.Create(this, def);
if (this.m_flags & b2Body.e_activeFlag) {
var broadPhase = this.m_world.m_contactManager.m_broadPhase;
fixture.CreateProxies(broadPhase, this.m_xf)
}
fixture.m_next = this.m_fixtureList;
this.m_fixtureList = fixture;
++this.m_fixtureCount;
fixture.m_body = this;
if (fixture.m_density > 0) {
this.ResetMassData()
}
this.m_world.m_flags |= b2World.e_newFixture;
return fixture
},
DestroyFixture: function (fixture) {
if (this.m_world.IsLocked() == true) {
return
}
var node = this.m_fixtureList;
var found = false;
while (node != null) {
if (node == fixture) {
this.m_fixtureList = node = fixture.m_next;
found = true;
break
}
node = node.m_next
}
var edge = this.m_contactList;
while (edge) {
var c = edge.contact;
edge = edge.next;
var fixtureA = c.GetFixtureA();
var fixtureB = c.GetFixtureB();
if (fixture == fixtureA || fixture == fixtureB) {
this.m_world.m_contactManager.Destroy(c)
}
}
if (this.m_flags & b2Body.e_activeFlag) {
var broadPhase = this.m_world.m_contactManager.m_broadPhase;
fixture.DestroyProxies(broadPhase)
}
fixture.Destroy();
fixture.m_body = null;
fixture.m_next = null;
--this.m_fixtureCount;
this.ResetMassData()
},
SetTransform: function (position, angle) {
if (this.m_world.IsLocked() == true) {
return
}
this.m_xf.q.Set(angle);
this.m_xf.p.Assign(position);
this.m_sweep.c.Assign(b2Mul_t_v2(this.m_xf, this.m_sweep.localCenter));
this.m_sweep.a = angle;
this.m_sweep.c0.Assign(this.m_sweep.c);
this.m_sweep.a0 = angle;
var broadPhase = this.m_world.m_contactManager.m_broadPhase;
for (var f = this.m_fixtureList; f; f = f.m_next) {
f.Synchronize(broadPhase, this.m_xf, this.m_xf)
}
},
GetTransform: function () {
return this.m_xf
},
GetPosition: function () {
return this.m_xf.p
},
GetAngle: function () {
return this.m_sweep.a
},
GetWorldCenter: function () {
return this.m_sweep.c
},
GetLocalCenter: function () {
return this.m_sweep.localCenter
},
SetLinearVelocity: function (v) {
if (this.m_type == b2Body.b2_staticBody) {
return
}
if (b2Dot_v2_v2(v, v) > 0) {
this.SetAwake(true)
}
this.m_linearVelocity = v
},
GetLinearVelocity: function () {
return this.m_linearVelocity
},
SetAngularVelocity: function (w) {
if (this.m_type == b2Body.b2_staticBody) {
return
}
if (w * w > 0) {
this.SetAwake(true)
}
this.m_angularVelocity = w
},
GetAngularVelocity: function () {
return this.m_angularVelocity
},
ApplyForce: function (force, point, wake) {
if (this.m_type != b2Body.b2_dynamicBody) {
return
}
if (wake && (this.m_flags & b2Body.e_awakeFlag) == 0) {
this.SetAwake(true)
}
if (this.m_flags & b2Body.e_awakeFlag) {
this.m_force.Add(force);
this.m_torque += b2Cross_v2_v2(b2Vec2.Subtract(point, this.m_sweep.c), force)
}
},
ApplyForceToCenter: function (force, wake) {
if (this.m_type != b2Body.b2_dynamicBody) {
return
}
if (wake && (this.m_flags & b2Body.e_awakeFlag) == 0) {
this.SetAwake(true)
}
if (this.m_flags & b2Body.e_awakeFlag) {
this.m_force.Add(force)
}
},
ApplyTorque: function (torque, wake) {
if (this.m_type != b2Body.b2_dynamicBody) {
return
}
if (wake && (this.m_flags & b2Body.e_awakeFlag) == 0) {
this.SetAwake(true)
}
if (this.m_flags & b2Body.e_awakeFlag) {
this.m_torque += torque
}
},
ApplyLinearImpulse: function (impulse, point, wake) {
if (this.m_type != b2Body.b2_dynamicBody) {
return
}
if (wake && (this.m_flags & b2Body.e_awakeFlag) == 0) {
this.SetAwake(true)
}
if (this.m_flags & b2Body.e_awakeFlag) {
this.m_linearVelocity.Add(b2Vec2.Multiply(this.m_invMass, impulse));
this.m_angularVelocity += this.m_invI * b2Cross_v2_v2(b2Vec2.Subtract(point, this.m_sweep.c), impulse)
}
},
ApplyAngularImpulse: function (impulse, wake) {
if (this.m_type != b2Body.b2_dynamicBody) {
return
}
if (wake && (this.m_flags & b2Body.e_awakeFlag) == 0) {
this.SetAwake(true)
}
if (this.m_flags & b2Body.e_awakeFlag) {
this.m_angularVelocity += this.m_invI * impulse
}
},
GetMass: function () {
return this.m_mass
},
GetInertia: function () {
return this.m_I + this.m_mass * b2Dot_v2_v2(this.m_sweep.localCenter, this.m_sweep.localCenter)
},
GetMassData: function (data) {
data.mass = this.m_mass;
data.I = this.m_I + this.m_mass * b2Dot_v2_v2(this.m_sweep.localCenter, this.m_sweep.localCenter);
data.center = this.m_sweep.localCenter
},
SetMassData: function (massData) {
if (this.m_world.IsLocked() == true) {
return
}
if (this.m_type != b2Body.b2_dynamicBody) {
return
}
this.m_invMass = 0;
this.m_I = 0;
this.m_invI = 0;
this.m_mass = massData.mass;
if (this.m_mass <= 0) {
this.m_mass = 1
}
this.m_invMass = 1 / this.m_mass;
if (massData.I > 0 && (this.m_flags & b2Body.e_fixedRotationFlag) == 0) {
this.m_I = massData.I - this.m_mass * b2Dot_v2_v2(massData.center, massData.center);
this.m_invI = 1 / this.m_I
}
b2Body.m_local_oldCenter.Assign(this.m_sweep.c);
this.m_sweep.localCenter.Assign(massData.center);
this.m_sweep.c0.Assign(b2Mul_t_v2(this.m_xf, this.m_sweep.localCenter));
this.m_sweep.c.Assign(this.m_sweep.c0);
this.m_linearVelocity.Add(b2Cross_f_v2(this.m_angularVelocity, b2Vec2.Subtract(this.m_sweep.c, b2Body.m_local_oldCenter)))
},
ResetMassData: function () {
this.m_mass = 0;
this.m_invMass = 0;
this.m_I = 0;
this.m_invI = 0;
this.m_sweep.localCenter.SetZero();
if (this.m_type == b2Body.b2_staticBody || this.m_type == b2Body.b2_kinematicBody) {
this.m_sweep.c0.Assign(this.m_xf.p);
this.m_sweep.c.Assign(this.m_xf.p);
this.m_sweep.a0 = this.m_sweep.a;
return
}
var localCenter = new b2Vec2(0, 0);
for (var f = this.m_fixtureList; f; f = f.m_next) {
if (f.m_density == 0) {
continue
}
var massData = new b2MassData();
f.GetMassData(massData);
this.m_mass += massData.mass;
localCenter.Add(b2Vec2.Multiply(massData.mass, massData.center));
this.m_I += massData.I
}
if (this.m_mass > 0) {
this.m_invMass = 1 / this.m_mass;
localCenter.Multiply(this.m_invMass)
} else {
this.m_mass = 1;
this.m_invMass = 1
}
if (this.m_I > 0 && (this.m_flags & b2Body.e_fixedRotationFlag) == 0) {
this.m_I -= this.m_mass * b2Dot_v2_v2(localCenter, localCenter);
this.m_invI = 1 / this.m_I
} else {
this.m_I = 0;
this.m_invI = 0
}
b2Body.m_local_oldCenter.Assign(this.m_sweep.c);
this.m_sweep.localCenter.Assign(localCenter);
this.m_sweep.c0.Assign(b2Mul_t_v2(this.m_xf, this.m_sweep.localCenter));
this.m_sweep.c.Assign(this.m_sweep.c0);
this.m_linearVelocity.Add(b2Cross_f_v2(this.m_angularVelocity, b2Vec2.Subtract(this.m_sweep.c, b2Body.m_local_oldCenter)))
},
GetWorldPoint: function (localPoint) {
return b2Mul_t_v2(this.m_xf, localPoint)
},
GetWorldVector: function (localVector) {
return b2Mul_r_v2(this.m_xf.q, localVector)
},
GetLocalPoint: function (worldPoint) {
return b2MulT_t_v2(this.m_xf, worldPoint)
},
GetLocalVector: function (worldVector) {
return b2MulT_r_v2(this.m_xf.q, worldVector)
},
GetLinearVelocityFromWorldPoint: function (worldPoint) {
return b2Vec2.Add(this.m_linearVelocity, b2Cross_f_v2(this.m_angularVelocity, b2Vec2.Subtract(worldPoint, this.m_sweep.c)))
},
GetLinearVelocityFromLocalPoint: function (localPoint) {
return this.GetLinearVelocityFromWorldPoint(this.GetWorldPoint(localPoint))
},
GetLinearDamping: function () {
return this.m_linearDamping
},
SetLinearDamping: function (linearDamping) {
this.m_linearDamping = linearDamping
},
GetAngularDamping: function () {
return this.m_angularDamping
},
SetAngularDamping: function (angularDamping) {
this.m_angularDamping = angularDamping
},
GetGravityScale: function () {
return this.m_gravityScale
},
SetGravityScale: function (scale) {
this.m_gravityScale = scale
},
SetType: function (type) {
if (this.m_world.IsLocked() == true) {
return
}
if (this.m_type == type) {
return
}
this.m_type = type;
this.ResetMassData();
if (this.m_type == b2Body.b2_staticBody) {
this.m_linearVelocity.SetZero();
this.m_angularVelocity = 0;
this.m_sweep.a0 = this.m_sweep.a;
this.m_sweep.c0.Assign(this.m_sweep.c);
this.SynchronizeFixtures()
}
this.SetAwake(true);
this.m_force.SetZero();
this.m_torque = 0;
var ce = this.m_contactList;
while (ce) {
var ce0 = ce;
ce = ce.next;
this.m_world.m_contactManager.Destroy(ce0.contact)
}
this.m_contactList = null;
var broadPhase = this.m_world.m_contactManager.m_broadPhase;
for (var f = this.m_fixtureList; f; f = f.m_next) {
var proxyCount = f.m_proxyCount;
for (var i = 0; i < proxyCount; ++i) {
broadPhase.TouchProxy(f.m_proxies[i].proxyId)
}
}
},
GetType: function () {
return this.m_type
},
SetBullet: function (flag) {
if (flag) {
this.m_flags |= b2Body.e_bulletFlag
} else {
this.m_flags &= ~b2Body.e_bulletFlag
}
},
IsBullet: function () {
return (this.m_flags & b2Body.e_bulletFlag) == b2Body.e_bulletFlag
},
SetSleepingAllowed: function (flag) {
if (flag) {
this.m_flags |= b2Body.e_autoSleepFlag
} else {
this.m_flags &= ~b2Body.e_autoSleepFlag;
this.SetAwake(true)
}
},
IsSleepingAllowed: function () {
return (this.m_flags & b2Body.e_autoSleepFlag) == b2Body.e_autoSleepFlag
},
SetAwake: function (flag) {
if (flag) {
if ((this.m_flags & b2Body.e_awakeFlag) == 0) {
this.m_flags |= b2Body.e_awakeFlag;
this.m_sleepTime = 0
}
} else {
this.m_flags &= ~b2Body.e_awakeFlag;
this.m_sleepTime = 0;
this.m_linearVelocity.SetZero();
this.m_angularVelocity = 0;
this.m_force.SetZero();
this.m_torque = 0
}
},
IsAwake: function () {
return (this.m_flags & b2Body.e_awakeFlag) == b2Body.e_awakeFlag
},
SetActive: function (flag) {
if (flag == this.IsActive()) {
return
}
if (flag) {
this.m_flags |= b2Body.e_activeFlag;
var broadPhase = this.m_world.m_contactManager.m_broadPhase;
for (var f = this.m_fixtureList; f; f = f.m_next) {
f.CreateProxies(broadPhase, this.m_xf)
}
} else {
this.m_flags &= ~b2Body.e_activeFlag;
var broadPhase = this.m_world.m_contactManager.m_broadPhase;
for (var f = this.m_fixtureList; f; f = f.m_next) {
f.DestroyProxies(broadPhase)
}
var ce = this.m_contactList;
while (ce) {
var ce0 = ce;
ce = ce.next;
this.m_world.m_contactManager.Destroy(ce0.contact)
}
this.m_contactList = null
}
},
IsActive: function () {
return (this.m_flags & b2Body.e_activeFlag) == b2Body.e_activeFlag
},
SetFixedRotation: function (flag) {
var status = (this.m_flags & b2Body.e_fixedRotationFlag) == b2Body.e_fixedRotationFlag;
if (status == flag) {
return
}
if (flag) {
this.m_flags |= b2Body.e_fixedRotationFlag
} else {
this.m_flags &= ~b2Body.e_fixedRotationFlag
}
this.m_angularVelocity = 0;
this.ResetMassData()
},
IsFixedRotation: function () {
return (this.m_flags & b2Body.e_fixedRotationFlag) == b2Body.e_fixedRotationFlag
},
GetFixtureList: function () {
return this.m_fixtureList
},
GetJointList: function () {
return this.m_jointList
},
GetContactList: function () {
return this.m_contactList
},
GetNext: function () {
return this.m_next
},
GetUserData: function () {
return this.m_userData
},
SetUserData: function (data) {
this.m_userData = data
},
GetWorld: function () {
return this.m_world
},
SynchronizeFixtures: function () {
b2Body.m_local_xf1.q.Set(this.m_sweep.a0);
b2Body.m_local_xf1.p.Assign(b2Vec2.Subtract(this.m_sweep.c0, b2Mul_r_v2(b2Body.m_local_xf1.q, this.m_sweep.localCenter)));
var broadPhase = this.m_world.m_contactManager.m_broadPhase;
for (var f = this.m_fixtureList; f; f = f.m_next) {
f.Synchronize(broadPhase, b2Body.m_local_xf1, this.m_xf)
}
},
SynchronizeTransform: function () {
this.m_xf.q.Set(this.m_sweep.a);
this.m_xf.p.Assign(b2Vec2.Subtract(this.m_sweep.c, b2Mul_r_v2(this.m_xf.q, this.m_sweep.localCenter)))
},
ShouldCollide: function (other) {
if (this.m_type != b2Body.b2_dynamicBody && other.m_type != b2Body.b2_dynamicBody) {
return false
}
for (var jn = this.m_jointList; jn; jn = jn.next) {
if (jn.other == other) {
if (jn.joint.m_collideConnected == false) {
return false
}
}
}
return true
},
Advance: function (alpha) {
this.m_sweep.Advance(alpha);
this.m_sweep.c.Assign(this.m_sweep.c0);
this.m_sweep.a = this.m_sweep.a0;
this.m_xf.q.Set(this.m_sweep.a);
this.m_xf.p.Assign(b2Vec2.Subtract(this.m_sweep.c, b2Mul_r_v2(this.m_xf.q, this.m_sweep.localCenter)))
},
_serialize: function (out) {
var obj = out || {};
obj.fixtures = null;
obj.type = this.m_type;
obj.position = this.GetPosition()._serialize();
obj.angle = this.GetAngle();
obj.linearVelocity = this.GetLinearVelocity()._serialize();
obj.angularVelocity = this.GetAngularVelocity();
obj.linearDamping = this.GetLinearDamping();
obj.angularDamping = this.GetAngularDamping();
obj.allowSleep = this.IsSleepingAllowed();
obj.awake = this.IsAwake();
obj.fixedRotation = this.IsFixedRotation();
obj.bullet = this.IsBullet();
obj.active = this.IsActive();
obj.gravityScale = this.GetGravityScale();
return obj
}
};
"use strict";
function b2Filter() {
this.categoryBits = 1;
this.maskBits = 65535;
this.groupIndex = 0
}
b2Filter.prototype = {
Clone: function () {
var filter = new b2Filter();
filter.categoryBits = this.categoryBits;
filter.maskBits = this.maskBits;
filter.groupIndex = this.groupIndex;
return filter
},
Assign: function (filter) {
this.categoryBits = filter.categoryBits;
this.maskBits = filter.maskBits;
this.groupIndex = filter.groupIndex
},
_serialize: function (out) {
var obj = out || {};
obj.categoryBits = this.categoryBits;
obj.maskBits = this.maskBits;
obj.groupIndex = this.groupIndex;
return obj
},
_deserialize: function (data) {
this.categoryBits = data.categoryBits;
this.maskBits = data.maskBits;
this.groupIndex = data.groupIndex
}
};
function b2FixtureDef() {
this.shape = null;
this.userData = null;
this.friction = 0.2;
this.restitution = 0;
this.density = 0;
this.isSensor = false;
this.filter = new b2Filter();
Object.seal(this)
}
b2FixtureDef.prototype = {
_deserialize: function (data) {
this.friction = data.friction;
this.restitution = data.restitution;
this.density = data.density;
this.isSensor = data.isSensor;
this.filter._deserialize(data.filter)
}
};
function b2FixtureProxy() {
this.aabb = new b2AABB();
this.fixture = null;
this.childIndex = 0;
this.proxyId = 0
}
function b2Fixture() {
this.m_userData = null;
this.m_body = null;
this.m_next = null;
this.m_proxies = null;
this.m_proxyCount = 0;
this.m_shape = null;
this.m_density = 0;
this.m_filter = new b2Filter();
this.m_isSensor = false;
this.m_friction = 0;
this.m_restitution = 0
}
b2Fixture.prototype = {
GetType: function () {
return this.m_shape.GetType()
},
GetShape: function () {
return this.m_shape
},
SetSensor: function (sensor) {
if (sensor != this.m_isSensor) {
this.m_body.SetAwake(true);
this.m_isSensor = sensor
}
},
IsSensor: function () {
return this.m_isSensor
},
SetFilterData: function (filter) {
this.m_filter = filter;
this.Refilter()
},
GetFilterData: function () {
return this.m_filter
},
Refilter: function () {
if (this.m_body == null) {
return
}
var edge = this.m_body.GetContactList();
while (edge) {
var contact = edge.contact;
var fixtureA = contact.GetFixtureA();
var fixtureB = contact.GetFixtureB();
if (fixtureA == this || fixtureB == this) {
contact.FlagForFiltering()
}
edge = edge.next
}
var world = this.m_body.GetWorld();
if (world == null) {
return
}
var broadPhase = world.m_contactManager.m_broadPhase;
for (var i = 0; i < this.m_proxyCount; ++i) {
broadPhase.TouchProxy(this.m_proxies[i].proxyId)
}
},
GetBody: function () {
return this.m_body
},
GetNext: function () {
return this.m_next
},
GetUserData: function () {
return this.m_userData
},
SetUserData: function (data) {
this.m_userData = data
},
TestPoint: function (p) {
return this.m_shape.TestPoint(this.m_body.GetTransform(), p)
},
RayCast: function (output, input, childIndex) {
return this.m_shape.RayCast(output, input, this.m_body.GetTransform(), childIndex)
},
GetMassData: function (massData) {
this.m_shape.ComputeMass(massData, this.m_density)
},
SetDensity: function (density) {
this.m_density = density
},
GetDensity: function () {
return this.m_density
},
GetFriction: function () {
return this.m_friction
},
SetFriction: function (friction) {
this.m_friction = friction
},
GetRestitution: function () {
return this.m_restitution
},
SetRestitution: function (restitution) {
this.m_restitution = restitution
},
GetAABB: function (childIndex) {
return this.m_proxies[childIndex].aabb
},
Create: function (body, def) {
this.m_userData = def.userData;
this.m_friction = def.friction;
this.m_restitution = def.restitution;
this.m_body = body;
this.m_next = null;
this.m_filter.Assign(def.filter);
this.m_isSensor = def.isSensor;
this.m_shape = def.shape.Clone();
var childCount = this.m_shape.GetChildCount();
this.m_proxies = new Array(childCount);
for (var i = 0; i < childCount; ++i) {
this.m_proxies[i] = new b2FixtureProxy();
this.m_proxies[i].fixture = null;
this.m_proxies[i].proxyId = b2BroadPhase.e_nullProxy
}
this.m_proxyCount = 0;
this.m_density = def.density
},
Destroy: function () {
this.m_proxies = null;
this.m_shape = null
},
CreateProxies: function (broadPhase, xf) {
this.m_proxyCount = this.m_shape.GetChildCount();
for (var i = 0; i < this.m_proxyCount; ++i) {
var proxy = this.m_proxies[i];
this.m_shape.ComputeAABB(proxy.aabb, xf, i);
proxy.proxyId = broadPhase.CreateProxy(proxy.aabb, proxy);
proxy.fixture = this;
proxy.childIndex = i
}
},
DestroyProxies: function (broadPhase) {
for (var i = 0; i < this.m_proxyCount; ++i) {
var proxy = this.m_proxies[i];
broadPhase.DestroyProxy(proxy.proxyId);
proxy.proxyId = b2BroadPhase.e_nullProxy
}
this.m_proxyCount = 0
},
Synchronize: function (broadPhase, transform1, transform2) {
if (this.m_proxyCount == 0) {
return
}
for (var i = 0; i < this.m_proxyCount; ++i) {
var proxy = this.m_proxies[i];
var aabb1 = new b2AABB(),
aabb2 = new b2AABB();
this.m_shape.ComputeAABB(aabb1, transform1, proxy.childIndex);
this.m_shape.ComputeAABB(aabb2, transform2, proxy.childIndex);
proxy.aabb.Combine(aabb1, aabb2);
var displacement = b2Vec2.Subtract(transform2.p, transform1.p);
broadPhase.MoveProxy(proxy.proxyId, proxy.aabb, displacement)
}
},
_serialize: function (out) {
var obj = out || {};
obj.shape = null;
obj.friction = this.m_friction;
obj.restitution = this.m_restitution;
obj.density = this.m_density;
obj.isSensor = this.m_isSensor;
obj.filter = this.m_filter._serialize();
return obj
}
};
"use strict";
function b2DestructionListener() {}
b2DestructionListener.prototype = {
SayGoodbyeJoint: function (joint) {},
SayGoodbyeFixture: function (fixture) {}
};
function b2ContactFilter() {}
b2ContactFilter.prototype = {
ShouldCollide: function (fixtureA, fixtureB) {
var filterA = fixtureA.GetFilterData();
var filterB = fixtureB.GetFilterData();
if (filterA.groupIndex == filterB.groupIndex && filterA.groupIndex != 0) {
return filterA.groupIndex > 0
}
var collide = (filterA.maskBits & filterB.categoryBits) != 0 && (filterA.categoryBits & filterB.maskBits) != 0;
return collide
}
};
function b2ContactImpulse() {
this.normalImpulses = new Array(b2_maxManifoldPoints);
this.tangentImpulses = new Array(b2_maxManifoldPoints);
this.count = 0
}
function b2ContactListener() {}
b2ContactListener.prototype = {
BeginContact: function (contact) {},
EndContact: function (contact) {},
PreSolve: function (contact, oldManifold) {},
PostSolve: function (contact, impulse) {}
};
function b2QueryCallback() {}
b2QueryCallback.prototype = {
ReportFixture: function (fixture) {}
};
function b2RayCastCallback() {}
b2RayCastCallback.prototype = {
ReportFixture: function (fixture, point, normal, fraction) {}
};
"use strict";
function b2TimeStep() {
this.dt = 0;
this.inv_dt = 0;
this.dtRatio = 0;
this.velocityIterations = 0;
this.positionIterations = 0;
this.warmStarting = false
}
function b2Position() {
this.c = new b2Vec2();
this.a = 0
}
function b2Velocity() {
this.v = new b2Vec2();
this.w = 0
}
function b2SolverData() {
this.step = new b2TimeStep();
this.positions = null;
this.velocities = null
}
"use strict";
var profile_world_step = b2Profiler.create("step");
var profile_world_collide = b2Profiler.create("collide", "step");
var profile_world_solve = b2Profiler.create("solve", "step");
var profile_world_solveTOI = b2Profiler.create("solveTOI", "step");
var profile_world_broadphase = b2Profiler.create("broadphase", "step");
function b2World(gravity) {
this.m_contactManager = new b2ContactManager();
this.m_destructionListener = null;
this.g_debugDraw = null;
this.m_bodyList = null;
this.m_jointList = null;
this.m_bodyCount = 0;
this.m_jointCount = 0;
this.m_warmStarting = true;
this.m_continuousPhysics = true;
this.m_subStepping = false;
this.m_stepComplete = true;
this.m_allowSleep = true;
this.m_gravity = gravity;
this.m_flags = b2World.e_clearForces;
this.m_inv_dt0 = 0;
this.p_step = new b2TimeStep();
this.p_island = new b2Island()
}
function b2WorldQueryWrapper() {
this.broadPhase = null;
this.callback = null
}
b2WorldQueryWrapper.prototype = {
QueryCallback: function (proxyId) {
var proxy = this.broadPhase.GetUserData(proxyId);
return this.callback.ReportFixture(proxy.fixture)
}
};
function b2WorldRayCastWrapper() {
this.broadPhase = null;
this.callback = null
}
b2WorldRayCastWrapper.prototype = {
RayCastCallback: function (input, proxyId) {
var userData = this.broadPhase.GetUserData(proxyId);
var proxy = userData;
var fixture = proxy.fixture;
var index = proxy.childIndex;
var output = new b2RayCastOutput();
var hit = fixture.RayCast(output, input, index);
if (hit) {
var fraction = output.fraction;
var point = b2Vec2.Add(b2Vec2.Multiply((1 - fraction), input.p1), b2Vec2.Multiply(fraction, input.p2));
return this.callback.ReportFixture(fixture, point, output.normal, fraction)
}
return input.maxFraction
}
};
b2World.m_local_sweep_backupA = new b2Sweep();
b2World.m_local_sweep_backupB = new b2Sweep();
b2World.m_local_sweep_backupC = new b2Sweep();
b2World.prototype = {
Destroy: function () {
var b = this.m_bodyList;
while (b) {
var bNext = b.m_next;
var f = b.m_fixtureList;
while (f) {
var fNext = f.m_next;
f.m_proxyCount = 0;
f.Destroy();
f = fNext
}
b = bNext
}
},
SetDestructionListener: function (listener) {
this.m_destructionListener = listener
},
SetContactFilter: function (filter) {
this.m_contactManager.m_contactFilter = filter
},
SetContactListener: function (listener) {
this.m_contactManager.m_contactListener = listener
},
SetDebugDraw: function (debugDraw) {
this.g_debugDraw = debugDraw
},
CreateBody: function (def) {
if (this.IsLocked()) {
return null
}
var b = new b2Body(def, this);
b.m_prev = null;
b.m_next = this.m_bodyList;
if (this.m_bodyList) {
this.m_bodyList.m_prev = b
}
this.m_bodyList = b;
++this.m_bodyCount;
return b
},
DestroyBody: function (b) {
if (this.IsLocked()) {
return
}
var je = b.m_jointList;
while (je) {
var je0 = je;
je = je.next;
if (this.m_destructionListener) {
this.m_destructionListener.SayGoodbyeJoint(je0.joint)
}
this.DestroyJoint(je0.joint);
b.m_jointList = je
}
b.m_jointList = null;
var ce = b.m_contactList;
while (ce) {
var ce0 = ce;
ce = ce.next;
this.m_contactManager.Destroy(ce0.contact)
}
b.m_contactList = null;
var f = b.m_fixtureList;
while (f) {
var f0 = f;
f = f.m_next;
if (this.m_destructionListener) {
this.m_destructionListener.SayGoodbyeFixture(f0)
}
f0.DestroyProxies(this.m_contactManager.m_broadPhase);
f0.Destroy();
b.m_fixtureList = f;
b.m_fixtureCount -= 1
}
b.m_fixtureList = null;
b.m_fixtureCount = 0;
if (b.m_prev) {
b.m_prev.m_next = b.m_next
}
if (b.m_next) {
b.m_next.m_prev = b.m_prev
}
if (b == this.m_bodyList) {
this.m_bodyList = b.m_next
}
b.m_destroyed = true;
--this.m_bodyCount
},
CreateJoint: function (def) {
if (this.IsLocked()) {
return null
}
var j = b2Joint.Create(def);
j.m_prev = null;
j.m_next = this.m_jointList;
if (this.m_jointList) {
this.m_jointList.m_prev = j
}
this.m_jointList = j;
++this.m_jointCount;
j.m_edgeA.joint = j;
j.m_edgeA.other = j.m_bodyB;
j.m_edgeA.prev = null;
j.m_edgeA.next = j.m_bodyA.m_jointList;
if (j.m_bodyA.m_jointList) {
j.m_bodyA.m_jointList.prev = j.m_edgeA
}
j.m_bodyA.m_jointList = j.m_edgeA;
j.m_edgeB.joint = j;
j.m_edgeB.other = j.m_bodyA;
j.m_edgeB.prev = null;
j.m_edgeB.next = j.m_bodyB.m_jointList;
if (j.m_bodyB.m_jointList) {
j.m_bodyB.m_jointList.prev = j.m_edgeB
}
j.m_bodyB.m_jointList = j.m_edgeB;
var bodyA = def.bodyA;
var bodyB = def.bodyB;
if (def.collideConnected == false) {
var edge = bodyB.GetContactList();
while (edge) {
if (edge.other == bodyA) {
edge.contact.FlagForFiltering()
}
edge = edge.next
}
}
return j
},
DestroyJoint: function (j) {
if (this.IsLocked()) {
return
}
var collideConnected = j.m_collideConnected;
if (j.m_prev) {
j.m_prev.m_next = j.m_next
}
if (j.m_next) {
j.m_next.m_prev = j.m_prev
}
if (j == this.m_jointList) {
this.m_jointList = j.m_next
}
var bodyA = j.m_bodyA;
var bodyB = j.m_bodyB;
bodyA.SetAwake(true);
bodyB.SetAwake(true);
if (j.m_edgeA.prev) {
j.m_edgeA.prev.next = j.m_edgeA.next
}
if (j.m_edgeA.next) {
j.m_edgeA.next.prev = j.m_edgeA.prev
}
if (j.m_edgeA == bodyA.m_jointList) {
bodyA.m_jointList = j.m_edgeA.next
}
j.m_edgeA.prev = null;
j.m_edgeA.next = null;
if (j.m_edgeB.prev) {
j.m_edgeB.prev.next = j.m_edgeB.next
}
if (j.m_edgeB.next) {
j.m_edgeB.next.prev = j.m_edgeB.prev
}
if (j.m_edgeB == bodyB.m_jointList) {
bodyB.m_jointList = j.m_edgeB.next
}
j.m_edgeB.prev = null;
j.m_edgeB.next = null;
b2Joint.Destroy(j);
--this.m_jointCount;
if (collideConnected == false) {
var edge = bodyB.GetContactList();
while (edge) {
if (edge.other == bodyA) {
edge.contact.FlagForFiltering()
}
edge = edge.next
}
}
},
Step: function (dt, velocityIterations, positionIterations) {
profile_world_step.start();
if (this.m_flags & b2World.e_newFixture) {
this.m_contactManager.FindNewContacts();
this.m_flags &= ~b2World.e_newFixture
}
this.m_flags |= b2World.e_locked;
this.p_step.dt = dt;
this.p_step.velocityIterations = velocityIterations;
this.p_step.positionIterations = positionIterations;
if (dt > 0) {
this.p_step.inv_dt = 1 / dt
} else {
this.p_step.inv_dt = 0
}
this.p_step.dtRatio = this.m_inv_dt0 * dt;
this.p_step.warmStarting = this.m_warmStarting;
profile_world_collide.start();
this.m_contactManager.Collide();
profile_world_collide.stop();
if (this.m_stepComplete && this.p_step.dt > 0) {
profile_world_solve.start();
this.Solve(this.p_step);
profile_world_solve.stop()
}
if (this.m_continuousPhysics && this.p_step.dt > 0) {
profile_world_solveTOI.start();
this.SolveTOI(this.p_step);
profile_world_solveTOI.stop()
}
if (this.p_step.dt > 0) {
this.m_inv_dt0 = this.p_step.inv_dt
}
if (this.m_flags & b2World.e_clearForces) {
this.ClearForces()
}
this.m_flags &= ~b2World.e_locked;
profile_world_step.stop()
},
ClearForces: function () {
for (var body = this.m_bodyList; body; body = body.GetNext()) {
body.m_force.x = body.m_force.y = 0;
body.m_torque = 0
}
},
DrawDebugData: function () {
if (this.g_debugDraw == null) {
return
}
var flags = this.g_debugDraw.GetFlags();
if (flags & b2Draw.e_shapeBit) {
for (var b = this.m_bodyList; b; b = b.GetNext()) {
var xf = b.GetTransform();
for (var f = b.GetFixtureList(); f; f = f.GetNext()) {
if (b.IsActive() == false) {
this.DrawShape(f, xf, new b2Color(0.5, 0.5, 0.3))
} else {
if (b.GetType() == b2Body.b2_staticBody) {
this.DrawShape(f, xf, new b2Color(0.5, 0.9, 0.5))
} else {
if (b.GetType() == b2Body.b2_kinematicBody) {
this.DrawShape(f, xf, new b2Color(0.5, 0.5, 0.9))
} else {
if (b.IsAwake() == false) {
this.DrawShape(f, xf, new b2Color(0.6, 0.6, 0.6))
} else {
this.DrawShape(f, xf, new b2Color(0.9, 0.7, 0.7))
}
}
}
}
}
}
}
if (flags & b2Draw.e_jointBit) {
for (var j = this.m_jointList; j; j = j.GetNext()) {
this.DrawJoint(j)
}
}
if (flags & b2Draw.e_pairBit) {
var color = new b2Color(0.3, 0.9, 0.9);
for (var c = this.m_contactManager.m_contactList; c; c = c.GetNext()) {
var fixtureA = c.GetFixtureA();
var fixtureB = c.GetFixtureB();
var cA = fixtureA.GetAABB(c.GetChildIndexA()).GetCenter();
var cB = fixtureB.GetAABB(c.GetChildIndexB()).GetCenter();
this.g_debugDraw.DrawSegment(cA, cB, color)
}
}
if (flags & b2Draw.e_aabbBit) {
var color = new b2Color(0.9, 0.3, 0.9);
var bp = this.m_contactManager.m_broadPhase;
for (var b = this.m_bodyList; b; b = b.GetNext()) {
if (b.IsActive() == false) {
continue
}
for (var f = b.GetFixtureList(); f; f = f.GetNext()) {
for (var i = 0; i < f.m_proxyCount; ++i) {
var proxy = f.m_proxies[i];
var aabb = bp.GetFatAABB(proxy.proxyId);
var vs = [];
vs[0] = new b2Vec2(aabb.lowerBound.x, aabb.lowerBound.y);
vs[1] = new b2Vec2(aabb.upperBound.x, aabb.lowerBound.y);
vs[2] = new b2Vec2(aabb.upperBound.x, aabb.upperBound.y);
vs[3] = new b2Vec2(aabb.lowerBound.x, aabb.upperBound.y);
this.g_debugDraw.DrawPolygon(vs, 4, color)
}
}
}
}
if (flags & b2Draw.e_centerOfMassBit) {
for (var b = this.m_bodyList; b; b = b.GetNext()) {
var xf = b.GetTransform().Clone();
xf.p = b.GetWorldCenter();
this.g_debugDraw.DrawTransform(xf)
}
}
},
QueryAABB: function (callback, aabb) {
var wrapper = new b2WorldQueryWrapper();
wrapper.broadPhase = this.m_contactManager.m_broadPhase;
wrapper.callback = callback;
this.m_contactManager.m_broadPhase.Query(wrapper, aabb)
},
RayCast: function (callback, point1, point2) {
var wrapper = new b2WorldRayCastWrapper();
wrapper.broadPhase = this.m_contactManager.m_broadPhase;
wrapper.callback = callback;
var input = new b2RayCastInput();
input.maxFraction = 1;
input.p1 = point1;
input.p2 = point2;
this.m_contactManager.m_broadPhase.RayCast(wrapper, input)
},
GetBodyList: function () {
return this.m_bodyList
},
GetJointList: function () {
return this.m_jointList
},
GetContactList: function () {
return this.m_contactManager.m_contactList
},
SetAllowSleeping: function (flag) {
if (flag == this.m_allowSleep) {
return
}
this.m_allowSleep = flag;
if (this.m_allowSleep == false) {
for (var b = this.m_bodyList; b; b = b.m_next) {
b.SetAwake(true)
}
}
},
GetAllowSleeping: function () {
return this.m_allowSleep
},
SetWarmStarting: function (flag) {
this.m_warmStarting = flag
},
GetWarmStarting: function () {
return this.m_warmStarting
},
SetContinuousPhysics: function (flag) {
this.m_continuousPhysics = flag
},
GetContinuousPhysics: function () {
return this.m_continuousPhysics
},
SetSubStepping: function (flag) {
this.m_subStepping = flag
},
GetSubStepping: function () {
return this.m_subStepping
},
GetProxyCount: function () {
return this.m_contactManager.m_broadPhase.GetProxyCount()
},
GetBodyCount: function () {
return this.m_bodyCount
},
GetJointCount: function () {
return this.m_jointCount
},
GetContactCount: function () {
return this.m_contactManager.m_contactCount
},
GetTreeHeight: function () {
return this.m_contactManager.m_broadPhase.GetTreeHeight()
},
GetTreeBalance: function () {
return this.m_contactManager.m_broadPhase.GetTreeBalance()
},
GetTreeQuality: function () {
return this.m_contactManager.m_broadPhase.GetTreeQuality()
},
SetGravity: function (gravity) {
this.m_gravity = gravity
},
GetGravity: function () {
return this.m_gravity
},
IsLocked: function () {
return (this.m_flags & b2World.e_locked) == b2World.e_locked
},
SetAutoClearForces: function (flag) {
if (flag) {
this.m_flags |= b2World.e_clearForces
} else {
this.m_flags &= ~b2World.e_clearForces
}
},
GetAutoClearForces: function () {
return (this.m_flags & b2World.e_clearForces) == b2World.e_clearForces
},
ShiftOrigin: function (newOrigin) {
if ((this.m_flags & b2World.e_locked) == b2World.e_locked) {
return
}
for (var b = this.m_bodyList; b; b = b.m_next) {
b.m_xf.p.Subtract(newOrigin);
b.m_sweep.c0.Subtract(newOrigin);
b.m_sweep.c.Subtract(newOrigin)
}
for (var j = this.m_jointList; j; j = j.m_next) {
j.ShiftOrigin(newOrigin)
}
this.m_contactManager.m_broadPhase.ShiftOrigin(newOrigin)
},
GetContactManager: function () {
return this.m_contactManager
},
Solve: function (step) {
this.p_island.Initialize(this.m_bodyCount, this.m_contactManager.m_contactCount, this.m_jointCount, this.m_contactManager.m_contactListener);
for (var b = this.m_bodyList; b; b = b.m_next) {
b.m_flags &= ~b2Body.e_islandFlag
}
for (var c = this.m_contactManager.m_contactList; c; c = c.m_next) {
c.m_flags &= ~b2Contact.e_islandFlag
}
for (var j = this.m_jointList; j; j = j.m_next) {
j.m_islandFlag = false
}
var stackSize = this.m_bodyCount;
var stack = new Array(stackSize);
for (var seed = this.m_bodyList; seed; seed = seed.m_next) {
if (seed.m_flags & b2Body.e_islandFlag) {
continue
}
if (seed.IsAwake() == false || seed.IsActive() == false) {
continue
}
if (seed.GetType() == b2Body.b2_staticBody) {
continue
}
this.p_island.Clear();
var stackCount = 0;
stack[stackCount++] = seed;
seed.m_flags |= b2Body.e_islandFlag;
while (stackCount > 0) {
var b = stack[--stackCount];
this.p_island.AddBody(b);
b.SetAwake(true);
if (b.GetType() == b2Body.b2_staticBody) {
continue
}
for (var ce = b.m_contactList; ce; ce = ce.next) {
var contact = ce.contact;
if (contact.m_flags & b2Contact.e_islandFlag) {
continue
}
if (contact.IsEnabled() == false || contact.IsTouching() == false) {
continue
}
var sensorA = contact.m_fixtureA.m_isSensor;
var sensorB = contact.m_fixtureB.m_isSensor;
if (sensorA || sensorB) {
continue
}
this.p_island.AddContact(contact);
contact.m_flags |= b2Contact.e_islandFlag;
var other = ce.other;
if (other.m_flags & b2Body.e_islandFlag) {
continue
}
stack[stackCount++] = other;
other.m_flags |= b2Body.e_islandFlag
}
for (var je = b.m_jointList; je; je = je.next) {
if (je.joint.m_islandFlag == true) {
continue
}
var other = je.other;
if (other.IsActive() == false) {
continue
}
this.p_island.AddJoint(je.joint);
je.joint.m_islandFlag = true;
if (other.m_flags & b2Body.e_islandFlag) {
continue
}
stack[stackCount++] = other;
other.m_flags |= b2Body.e_islandFlag
}
}
this.p_island.Solve(step, this.m_gravity, this.m_allowSleep);
for (var i = 0; i < this.p_island.m_bodyCount; ++i) {
var b = this.p_island.m_bodies[i];
if (b.GetType() == b2Body.b2_staticBody) {
b.m_flags &= ~b2Body.e_islandFlag
}
}
}
profile_world_broadphase.start();
for (var b = this.m_bodyList; b; b = b.GetNext()) {
if ((b.m_flags & b2Body.e_islandFlag) == 0) {
continue
}
if (b.GetType() == b2Body.b2_staticBody) {
continue
}
b.SynchronizeFixtures()
}
this.m_contactManager.FindNewContacts();
profile_world_broadphase.stop()
},
SolveTOI: function (step) {
this.p_island.Initialize(2 * b2_maxTOIContacts, b2_maxTOIContacts, 0, this.m_contactManager.m_contactListener);
if (this.m_stepComplete) {
for (var b = this.m_bodyList; b; b = b.m_next) {
b.m_flags &= ~b2Body.e_islandFlag;
b.m_sweep.alpha0 = 0
}
for (var c = this.m_contactManager.m_contactList; c; c = c.m_next) {
c.m_flags &= ~(b2Contact.e_toiFlag | b2Contact.e_islandFlag);
c.m_toiCount = 0;
c.m_toi = 1
}
}
for (;;) {
var minContact = null;
var minAlpha = 1;
for (var c = this.m_contactManager.m_contactList; c; c = c.m_next) {
if (c.IsEnabled() == false) {
continue
}
if (c.m_toiCount > b2_maxSubSteps) {
continue
}
var alpha = 1;
if (c.m_flags & b2Contact.e_toiFlag) {
alpha = c.m_toi
} else {
var fA = c.GetFixtureA();
var fB = c.GetFixtureB();
if (fA.IsSensor() || fB.IsSensor()) {
continue
}
var bA = fA.GetBody();
var bB = fB.GetBody();
var typeA = bA.m_type;
var typeB = bB.m_type;
var activeA = bA.IsAwake() && typeA != b2Body.b2_staticBody;
var activeB = bB.IsAwake() && typeB != b2Body.b2_staticBody;
if (activeA == false && activeB == false) {
continue
}
var collideA = bA.IsBullet() || typeA != b2Body.b2_dynamicBody;
var collideB = bB.IsBullet() || typeB != b2Body.b2_dynamicBody;
if (collideA == false && collideB == false) {
continue
}
var alpha0 = bA.m_sweep.alpha0;
if (bA.m_sweep.alpha0 < bB.m_sweep.alpha0) {
alpha0 = bB.m_sweep.alpha0;
bA.m_sweep.Advance(alpha0)
} else {
if (bB.m_sweep.alpha0 < bA.m_sweep.alpha0) {
alpha0 = bA.m_sweep.alpha0;
bB.m_sweep.Advance(alpha0)
}
}
var indexA = c.GetChildIndexA();
var indexB = c.GetChildIndexB();
var input = new b2TOIInput();
input.proxyA.Set(fA.GetShape(), indexA);
input.proxyB.Set(fB.GetShape(), indexB);
input.sweepA.Assign(bA.m_sweep);
input.sweepB.Assign(bB.m_sweep);
input.tMax = 1;
var output = new b2TOIOutput();
b2TimeOfImpact(output, input);
var beta = output.t;
if (output.state == b2TOIOutput.e_touching) {
alpha = b2Min(alpha0 + (1 - alpha0) * beta, 1)
} else {
alpha = 1
}
c.m_toi = alpha;
c.m_flags |= b2Contact.e_toiFlag
}
if (alpha < minAlpha) {
minContact = c;
minAlpha = alpha
}
}
if (minContact == null || 1 - 10 * b2_epsilon < minAlpha) {
this.m_stepComplete = true;
break
}
var fA = minContact.GetFixtureA();
var fB = minContact.GetFixtureB();
var bA = fA.GetBody();
var bB = fB.GetBody();
b2World.m_local_sweep_backupA.Assign(bA.m_sweep);
b2World.m_local_sweep_backupB.Assign(bB.m_sweep);
bA.Advance(minAlpha);
bB.Advance(minAlpha);
minContact.Update(this.m_contactManager.m_contactListener);
minContact.m_flags &= ~b2Contact.e_toiFlag;
++minContact.m_toiCount;
if (minContact.IsEnabled() == false || minContact.IsTouching() == false) {
minContact.SetEnabled(false);
bA.m_sweep.Assign(b2World.m_local_sweep_backupA);
bB.m_sweep.Assign(b2World.m_local_sweep_backupB);
bA.SynchronizeTransform();
bB.SynchronizeTransform();
continue
}
bA.SetAwake(true);
bB.SetAwake(true);
this.p_island.Clear();
this.p_island.AddBody(bA);
this.p_island.AddBody(bB);
this.p_island.AddContact(minContact);
bA.m_flags |= b2Body.e_islandFlag;
bB.m_flags |= b2Body.e_islandFlag;
minContact.m_flags |= b2Contact.e_islandFlag;
var bodies = [bA, bB];
for (var i = 0; i < 2; ++i) {
var body = bodies[i];
if (body.m_type == b2Body.b2_dynamicBody) {
for (var ce = body.m_contactList; ce; ce = ce.next) {
if (this.p_island.m_bodyCount == this.p_island.m_bodyCapacity) {
break
}
if (this.p_island.m_contactCount == this.p_island.m_contactCapacity) {
break
}
var contact = ce.contact;
if (contact.m_flags & b2Contact.e_islandFlag) {
continue
}
var other = ce.other;
if (other.m_type == b2Body.b2_dynamicBody && body.IsBullet() == false && other.IsBullet() == false) {
continue
}
var sensorA = contact.m_fixtureA.m_isSensor;
var sensorB = contact.m_fixtureB.m_isSensor;
if (sensorA || sensorB) {
continue
}
b2World.m_local_sweep_backupC.Assign(other.m_sweep);
if ((other.m_flags & b2Body.e_islandFlag) == 0) {
other.Advance(minAlpha)
}
contact.Update(this.m_contactManager.m_contactListener);
if (contact.IsEnabled() == false) {
other.m_sweep.Assign(b2World.m_local_sweep_backupC);
other.SynchronizeTransform();
continue
}
if (contact.IsTouching() == false) {
other.m_sweep.Assign(b2World.m_local_sweep_backupC);
other.SynchronizeTransform();
continue
}
contact.m_flags |= b2Contact.e_islandFlag;
this.p_island.AddContact(contact);
if (other.m_flags & b2Body.e_islandFlag) {
continue
}
other.m_flags |= b2Body.e_islandFlag;
if (other.m_type != b2Body.b2_staticBody) {
other.SetAwake(true)
}
this.p_island.AddBody(other)
}
}
}
var subStep = new b2TimeStep();
subStep.dt = (1 - minAlpha) * step.dt;
subStep.inv_dt = 1 / subStep.dt;
subStep.dtRatio = 1;
subStep.positionIterations = 20;
subStep.velocityIterations = step.velocityIterations;
subStep.warmStarting = false;
this.p_island.SolveTOI(subStep, bA.m_islandIndex, bB.m_islandIndex);
for (var i = 0; i < this.p_island.m_bodyCount; ++i) {
var body = this.p_island.m_bodies[i];
body.m_flags &= ~b2Body.e_islandFlag;
if (body.m_type != b2Body.b2_dynamicBody) {
continue
}
body.SynchronizeFixtures();
for (var ce = body.m_contactList; ce; ce = ce.next) {
ce.contact.m_flags &= ~(b2Contact.e_toiFlag | b2Contact.e_islandFlag)
}
}
this.m_contactManager.FindNewContacts();
if (this.m_subStepping) {
this.m_stepComplete = false;
break
}
}
},
DrawJoint: function (joint) {
var bodyA = joint.GetBodyA();
var bodyB = joint.GetBodyB();
var xf1 = bodyA.GetTransform();
var xf2 = bodyB.GetTransform();
var x1 = xf1.p;
var x2 = xf2.p;
var p1 = joint.GetAnchorA();
var p2 = joint.GetAnchorB();
var color = new b2Color(0.5, 0.8, 0.8);
switch (joint.GetType()) {
case b2Joint.e_distanceJoint:
this.g_debugDraw.DrawSegment(p1, p2, color);
break;
case b2Joint.e_pulleyJoint:
var pulley = joint;
var s1 = pulley.GetGroundAnchorA();
var s2 = pulley.GetGroundAnchorB();
this.g_debugDraw.DrawSegment(s1, p1, color);
this.g_debugDraw.DrawSegment(s2, p2, color);
this.g_debugDraw.DrawSegment(s1, s2, color);
break;
case b2Joint.e_mouseJoint:
break;
case b2Joint.e_motorJoint:
this.g_debugDraw.DrawPoint(joint.GetLinearOffset(), 5, color);
default:
this.g_debugDraw.DrawSegment(x1, p1, color);
this.g_debugDraw.DrawSegment(p1, p2, color);
this.g_debugDraw.DrawSegment(x2, p2, color)
}
},
DrawShape: function (fixture, xf, color) {
switch (fixture.GetType()) {
case b2Shape.e_circle:
var circle = fixture.GetShape();
var center = b2Mul_t_v2(xf, circle.m_p);
var radius = circle.m_radius;
var axis = b2Mul_r_v2(xf.q, new b2Vec2(1, 0));
this.g_debugDraw.DrawSolidCircle(center, radius, axis, color);
break;
case b2Shape.e_edge:
var edge = fixture.GetShape();
var v1 = b2Mul_t_v2(xf, edge.m_vertex1);
var v2 = b2Mul_t_v2(xf, edge.m_vertex2);
this.g_debugDraw.DrawSegment(v1, v2, color);
break;
case b2Shape.e_chain:
var chain = fixture.GetShape();
var count = chain.m_count;
var vertices = chain.m_vertices;
var v1 = b2Mul_t_v2(xf, vertices[0]);
for (var i = 1; i < count; ++i) {
var v2 = b2Mul_t_v2(xf, vertices[i]);
this.g_debugDraw.DrawSegment(v1, v2, color);
v1 = v2
}
break;
case b2Shape.e_polygon:
var poly = fixture.GetShape();
var vertexCount = poly.m_count;
var vertices = new Array(b2_maxPolygonVertices);
for (var i = 0; i < vertexCount; ++i) {
vertices[i] = b2Mul_t_v2(xf, poly.m_vertices[i])
}
this.g_debugDraw.DrawSolidPolygon(vertices, vertexCount, color);
break;
default:
break
}
}
};
b2World.e_newFixture = 1;
b2World.e_locked = 2;
b2World.e_clearForces = 4;
"use strict";
function b2MixFriction(friction1, friction2) {
return b2Sqrt(friction1 * friction2)
}
function b2MixRestitution(restitution1, restitution2) {
return restitution1 > restitution2 ? restitution1 : restitution2
}
function b2ContactRegister() {
this.fcn = null;
this.primary = false
}
function b2ContactEdge() {
this.other = null;
this.contact = null;
this.prev = null;
this.next = null
}
function b2Contact() {
this.m_nodeA = new b2ContactEdge();
this.m_nodeB = new b2ContactEdge();
this.m_manifold = new b2Manifold()
}
b2Contact.m_local_tempManifold = new b2Manifold();
b2Contact.prototype = {
Create: function (fA, indexA, fB, indexB) {
this.m_toi = 0;
this.m_flags = b2Contact.e_enabledFlag;
this.m_fixtureA = fA || null;
this.m_fixtureB = fB || null;
this.m_indexA = indexA || 0;
this.m_indexB = indexB || 0;
this.m_manifold.pointCount = 0;
this.m_prev = null;
this.m_next = null;
this.m_nodeA.contact = null;
this.m_nodeA.prev = null;
this.m_nodeA.next = null;
this.m_nodeA.other = null;
this.m_nodeB.contact = null;
this.m_nodeB.prev = null;
this.m_nodeB.next = null;
this.m_nodeB.other = null;
this.m_toiCount = 0;
if (fA) {
this.m_friction = b2MixFriction(this.m_fixtureA.m_friction, this.m_fixtureB.m_friction);
this.m_restitution = b2MixRestitution(this.m_fixtureA.m_restitution, this.m_fixtureB.m_restitution)
} else {
this.m_friction = 0;
this.m_restitution = 0
}
this.m_tangentSpeed = 0
},
GetManifold: function () {
return this.m_manifold
},
GetWorldManifold: function (worldManifold) {
var bodyA = this.m_fixtureA.GetBody();
var bodyB = this.m_fixtureB.GetBody();
var shapeA = this.m_fixtureA.GetShape();
var shapeB = this.m_fixtureB.GetShape();
worldManifold.Initialize(this.m_manifold, bodyA.GetTransform(), shapeA.m_radius, bodyB.GetTransform(), shapeB.m_radius)
},
IsTouching: function () {
return (this.m_flags & b2Contact.e_touchingFlag) == b2Contact.e_touchingFlag
},
SetEnabled: function (flag) {
if (flag) {
this.m_flags |= b2Contact.e_enabledFlag
} else {
this.m_flags &= ~b2Contact.e_enabledFlag
}
},
IsEnabled: function () {
return (this.m_flags & b2Contact.e_enabledFlag) == b2Contact.e_enabledFlag
},
GetNext: function () {
return this.m_next
},
GetFixtureA: function () {
return this.m_fixtureA
},
GetChildIndexA: function () {
return this.m_indexA
},
GetFixtureB: function () {
return this.m_fixtureB
},
GetChildIndexB: function () {
return this.m_indexB
},
SetFriction: function (friction) {
this.m_friction = friction
},
GetFriction: function () {
return this.m_friction
},
ResetFriction: function () {
this.m_friction = b2MixFriction(this.m_fixtureA.m_friction, this.m_fixtureB.m_friction)
},
SetRestitution: function (restitution) {
this.m_restitution = restitution
},
GetRestitution: function () {
return this.m_restitution
},
ResetRestitution: function () {
this.m_restitution = b2MixRestitution(this.m_fixtureA.m_restitution, this.m_fixtureB.m_restitution)
},
SetTangentSpeed: function (speed) {
this.m_tangentSpeed = speed
},
GetTangentSpeed: function () {
return this.m_tangentSpeed
},
Evaluate: function (manifold, xfA, xfB) {},
FlagForFiltering: function () {
this.m_flags |= b2Contact.e_filterFlag
},
m_oldManifold: null,
Update: function (listener) {
b2Contact.m_local_tempManifold.Assign(this.m_manifold);
this.m_flags |= b2Contact.e_enabledFlag;
var touching = false;
var wasTouching = (this.m_flags & b2Contact.e_touchingFlag) == b2Contact.e_touchingFlag;
var sensorA = this.m_fixtureA.IsSensor();
var sensorB = this.m_fixtureB.IsSensor();
var sensor = sensorA || sensorB;
var bodyA = this.m_fixtureA.GetBody();
var bodyB = this.m_fixtureB.GetBody();
var xfA = bodyA.GetTransform();
var xfB = bodyB.GetTransform();
if (sensor) {
var shapeA = this.m_fixtureA.GetShape();
var shapeB = this.m_fixtureB.GetShape();
touching = b2TestShapeOverlap(shapeA, this.m_indexA, shapeB, this.m_indexB, xfA, xfB);
this.m_manifold.pointCount = 0
} else {
this.Evaluate(this.m_manifold, xfA, xfB);
touching = this.m_manifold.pointCount > 0;
for (var i = 0; i < this.m_manifold.pointCount; ++i) {
var mp2 = this.m_manifold.points[i];
mp2.normalImpulse = 0;
mp2.tangentImpulse = 0;
var id2 = mp2.id;
for (var j = 0; j < b2Contact.m_local_tempManifold.pointCount; ++j) {
var mp1 = b2Contact.m_local_tempManifold.points[j];
if (mp1.id.Get() == id2.Get()) {
mp2.normalImpulse = mp1.normalImpulse;
mp2.tangentImpulse = mp1.tangentImpulse;
break
}
}
}
if (touching != wasTouching) {
bodyA.SetAwake(true);
bodyB.SetAwake(true)
}
}
if (touching) {
this.m_flags |= b2Contact.e_touchingFlag
} else {
this.m_flags &= ~b2Contact.e_touchingFlag
}
if (wasTouching == false && touching == true && listener) {
listener.BeginContact(this)
}
if (wasTouching == true && touching == false && listener) {
listener.EndContact(this)
}
if (sensor == false && touching && listener) {
listener.PreSolve(this, b2Contact.m_local_tempManifold)
}
}
};
b2Contact.e_islandFlag = 1;
b2Contact.e_touchingFlag = 2;
b2Contact.e_enabledFlag = 4;
b2Contact.e_filterFlag = 8;
b2Contact.e_bulletHitFlag = 16;
b2Contact.e_toiFlag = 32;
function b2CircleContact() {
this.parent.call(this)
}
b2CircleContact.prototype = {
Evaluate: function (manifold, xfA, xfB) {
b2CollideCircles(manifold, this.m_fixtureA.GetShape(), xfA, this.m_fixtureB.GetShape(), xfB)
},
Create: function (fixtureA, unused1, fixtureB, unused2) {
this.parent.prototype.Create.call(this, fixtureA, 0, fixtureB, 0)
}
};
b2CircleContact._extend(b2Contact);
var _local_temp_edgeShape = new b2EdgeShape();
function b2ChainAndCircleContact() {
this.parent.call(this)
}
b2ChainAndCircleContact.prototype = {
Evaluate: function (manifold, xfA, xfB) {
var chain = this.m_fixtureA.GetShape();
chain.GetChildEdge(_local_temp_edgeShape, this.m_indexA);
b2CollideEdgeAndCircle(manifold, _local_temp_edgeShape, xfA, this.m_fixtureB.GetShape(), xfB)
},
Create: function (fixtureA, indexA, fixtureB, indexB) {
this.parent.prototype.Create.call(this, fixtureA, indexA, fixtureB, indexB)
}
};
b2ChainAndCircleContact._extend(b2Contact);
function b2ChainAndPolygonContact() {
this.parent.call(this)
}
b2ChainAndPolygonContact.prototype = {
Evaluate: function (manifold, xfA, xfB) {
var chain = this.m_fixtureA.GetShape();
chain.GetChildEdge(_local_temp_edgeShape, this.m_indexA);
b2CollideEdgeAndPolygon(manifold, _local_temp_edgeShape, xfA, this.m_fixtureB.GetShape(), xfB)
},
Create: function (fixtureA, indexA, fixtureB, indexB) {
this.parent.prototype.Create.call(this, fixtureA, indexA, fixtureB, indexB)
}
};
b2ChainAndPolygonContact.Create = function (fixtureA, indexA, fixtureB, indexB) {
return new b2ChainAndPolygonContact(fixtureA, indexA, fixtureB, indexB)
};
b2ChainAndPolygonContact._extend(b2Contact);
function b2EdgeAndCircleContact() {
this.parent.call(this)
}
b2EdgeAndCircleContact.prototype = {
Evaluate: function (manifold, xfA, xfB) {
b2CollideEdgeAndCircle(manifold, this.m_fixtureA.GetShape(), xfA, this.m_fixtureB.GetShape(), xfB)
},
Create: function (fixtureA, indexA, fixtureB, indexB) {
this.parent.prototype.Create.call(this, fixtureA, 0, fixtureB, 0)
}
};
b2EdgeAndCircleContact.Create = function (fixtureA, indexA, fixtureB, indexB) {
return new b2EdgeAndCircleContact(fixtureA, fixtureB)
};
b2EdgeAndCircleContact._extend(b2Contact);
function b2EdgeAndPolygonContact() {
this.parent.call(this)
}
b2EdgeAndPolygonContact.prototype = {
Evaluate: function (manifold, xfA, xfB) {
b2CollideEdgeAndPolygon(manifold, this.m_fixtureA.GetShape(), xfA, this.m_fixtureB.GetShape(), xfB)
},
Create: function (fixtureA, indexA, fixtureB, indexB) {
this.parent.prototype.Create.call(this, fixtureA, 0, fixtureB, 0)
}
};
b2EdgeAndPolygonContact.Create = function (fixtureA, indexA, fixtureB, indexB) {
return new b2EdgeAndPolygonContact(fixtureA, fixtureB)
};
b2EdgeAndPolygonContact._extend(b2Contact);
function b2PolygonAndCircleContact() {
this.parent.call(this)
}
b2PolygonAndCircleContact.prototype = {
Evaluate: function (manifold, xfA, xfB) {
b2CollidePolygonAndCircle(manifold, this.m_fixtureA.GetShape(), xfA, this.m_fixtureB.GetShape(), xfB)
},
Create: function (fixtureA, indexA, fixtureB, indexB) {
this.parent.prototype.Create.call(this, fixtureA, 0, fixtureB, 0)
}
};
b2PolygonAndCircleContact.Create = function (fixtureA, indexA, fixtureB, indexB) {
return new b2PolygonAndCircleContact(fixtureA, fixtureB)
};
b2PolygonAndCircleContact._extend(b2Contact);
function b2PolygonContact() {
this.parent.call(this)
}
b2PolygonContact.prototype = {
Evaluate: function (manifold, xfA, xfB) {
b2CollidePolygons(manifold, this.m_fixtureA.GetShape(), xfA, this.m_fixtureB.GetShape(), xfB)
},
Create: function (fixtureA, indexA, fixtureB, indexB) {
this.parent.prototype.Create.call(this, fixtureA, 0, fixtureB, 0)
}
};
b2PolygonContact.Create = function (fixtureA, indexA, fixtureB, indexB) {
return new b2PolygonContact(fixtureA, fixtureB)
};
b2PolygonContact._extend(b2Contact);
b2Contact.AddType = function (fcn, type1, type2) {
if (!b2Contact.s_registers[type1]) {
b2Contact.s_registers[type1] = []
}
b2Contact.s_registers[type1][type2] = new b2ContactRegister();
b2Contact.s_registers[type1][type2].fcn = fcn;
b2Contact.s_registers[type1][type2].primary = true;
if (type1 != type2) {
if (!b2Contact.s_registers[type2]) {
b2Contact.s_registers[type2] = []
}
b2Contact.s_registers[type2][type1] = new b2ContactRegister();
b2Contact.s_registers[type2][type1].fcn = fcn;
b2Contact.s_registers[type2][type1].primary = false
}
fcn.garbage = [];
fcn.alloc = 2
};
b2Contact.InitializeRegisters = function () {
b2Contact.AddType(b2CircleContact, b2Shape.e_circle, b2Shape.e_circle);
b2Contact.AddType(b2PolygonAndCircleContact, b2Shape.e_polygon, b2Shape.e_circle);
b2Contact.AddType(b2PolygonContact, b2Shape.e_polygon, b2Shape.e_polygon);
b2Contact.AddType(b2EdgeAndCircleContact, b2Shape.e_edge, b2Shape.e_circle);
b2Contact.AddType(b2EdgeAndPolygonContact, b2Shape.e_edge, b2Shape.e_polygon);
b2Contact.AddType(b2ChainAndCircleContact, b2Shape.e_chain, b2Shape.e_circle);
b2Contact.AddType(b2ChainAndPolygonContact, b2Shape.e_chain, b2Shape.e_polygon)
};
b2Contact.RetrieveGarbage = function (fcn) {
var contact;
if (contact = fcn.garbage.pop()) {
return contact
}
for (var i = 0; i < fcn.alloc - 1; ++i) {
fcn.garbage.push(new fcn())
}
fcn.alloc += 32;
return new fcn()
};
b2Contact.Create = function (fixtureA, indexA, fixtureB, indexB) {
if (b2Contact.s_initialized == false) {
b2Contact.InitializeRegisters();
b2Contact.s_initialized = true
}
var type1 = fixtureA.GetType();
var type2 = fixtureB.GetType();
var fcn = b2Contact.s_registers[type1][type2].fcn;
if (fcn) {
var contact = b2Contact.RetrieveGarbage(fcn);
if (b2Contact.s_registers[type1][type2].primary) {
contact.Create(fixtureA, indexA, fixtureB, indexB)
} else {
contact.Create(fixtureB, indexB, fixtureA, indexA)
}
return contact
}
return null
};
b2Contact.Destroy = function (contact) {
var fixtureA = contact.m_fixtureA;
var fixtureB = contact.m_fixtureB;
if (contact.m_manifold.pointCount > 0 && fixtureA.IsSensor() == false && fixtureB.IsSensor() == false) {
fixtureA.GetBody().SetAwake(true);
fixtureB.GetBody().SetAwake(true)
}
var typeA = fixtureA.GetType();
var typeB = fixtureB.GetType();
b2Contact.s_registers[typeA][typeB].fcn.garbage.push(contact)
};
b2Contact.s_registers = [];
b2Contact.s_initialized = false;
"use strict";
var b2_defaultFilter = new b2ContactFilter();
var b2_defaultListener = new b2ContactListener();
function b2ContactManager() {
this.m_broadPhase = new b2BroadPhase();
this.m_contactList = null;
this.m_contactCount = 0;
this.m_contactFilter = b2_defaultFilter;
this.m_contactListener = b2_defaultListener
}
b2ContactManager.prototype = {
AddPair: function (proxyUserDataA, proxyUserDataB) {
var proxyA = proxyUserDataA;
var proxyB = proxyUserDataB;
var fixtureA = proxyA.fixture;
var fixtureB = proxyB.fixture;
var indexA = proxyA.childIndex;
var indexB = proxyB.childIndex;
var bodyA = fixtureA.GetBody();
var bodyB = fixtureB.GetBody();
if (bodyA == bodyB) {
return
}
var edge = bodyB.GetContactList();
while (edge) {
if (edge.other == bodyA) {
var fA = edge.contact.GetFixtureA();
var fB = edge.contact.GetFixtureB();
var iA = edge.contact.GetChildIndexA();
var iB = edge.contact.GetChildIndexB();
if (fA == fixtureA && fB == fixtureB && iA == indexA && iB == indexB) {
return
}
if (fA == fixtureB && fB == fixtureA && iA == indexB && iB == indexA) {
return
}
}
edge = edge.next
}
if (bodyB.ShouldCollide(bodyA) == false) {
return
}
if (this.m_contactFilter && this.m_contactFilter.ShouldCollide(fixtureA, fixtureB) == false) {
return
}
var c = b2Contact.Create(fixtureA, indexA, fixtureB, indexB);
if (c == null) {
return
}
fixtureA = c.GetFixtureA();
fixtureB = c.GetFixtureB();
indexA = c.GetChildIndexA();
indexB = c.GetChildIndexB();
bodyA = fixtureA.GetBody();
bodyB = fixtureB.GetBody();
c.m_prev = null;
c.m_next = this.m_contactList;
if (this.m_contactList != null) {
this.m_contactList.m_prev = c
}
this.m_contactList = c;
c.m_nodeA.contact = c;
c.m_nodeA.other = bodyB;
c.m_nodeA.prev = null;
c.m_nodeA.next = bodyA.m_contactList;
if (bodyA.m_contactList != null) {
bodyA.m_contactList.prev = c.m_nodeA
}
bodyA.m_contactList = c.m_nodeA;
c.m_nodeB.contact = c;
c.m_nodeB.other = bodyA;
c.m_nodeB.prev = null;
c.m_nodeB.next = bodyB.m_contactList;
if (bodyB.m_contactList != null) {
bodyB.m_contactList.prev = c.m_nodeB
}
bodyB.m_contactList = c.m_nodeB;
if (fixtureA.IsSensor() == false && fixtureB.IsSensor() == false) {
bodyA.SetAwake(true);
bodyB.SetAwake(true)
}++this.m_contactCount
},
FindNewContacts: function () {
this.m_broadPhase.UpdatePairs(this)
},
Destroy: function (c) {
var fixtureA = c.GetFixtureA();
var fixtureB = c.GetFixtureB();
var bodyA = fixtureA.GetBody();
var bodyB = fixtureB.GetBody();
if (this.m_contactListener && c.IsTouching()) {
this.m_contactListener.EndContact(c)
}
if (c.m_prev) {
c.m_prev.m_next = c.m_next
}
if (c.m_next) {
c.m_next.m_prev = c.m_prev
}
if (c == this.m_contactList) {
this.m_contactList = c.m_next
}
if (c.m_nodeA.prev) {
c.m_nodeA.prev.next = c.m_nodeA.next
}
if (c.m_nodeA.next) {
c.m_nodeA.next.prev = c.m_nodeA.prev
}
if (c.m_nodeA == bodyA.m_contactList) {
bodyA.m_contactList = c.m_nodeA.next
}
if (c.m_nodeB.prev) {
c.m_nodeB.prev.next = c.m_nodeB.next
}
if (c.m_nodeB.next) {
c.m_nodeB.next.prev = c.m_nodeB.prev
}
if (c.m_nodeB == bodyB.m_contactList) {
bodyB.m_contactList = c.m_nodeB.next
}
b2Contact.Destroy(c);
--this.m_contactCount
},
Collide: function () {
var c = this.m_contactList;
while (c) {
var fixtureA = c.GetFixtureA();
var fixtureB = c.GetFixtureB();
var indexA = c.GetChildIndexA();
var indexB = c.GetChildIndexB();
var bodyA = fixtureA.GetBody();
var bodyB = fixtureB.GetBody();
if (c.m_flags & b2Contact.e_filterFlag) {
if (bodyB.ShouldCollide(bodyA) == false) {
var cNuke = c;
c = cNuke.GetNext();
this.Destroy(cNuke);
continue
}
if (this.m_contactFilter && this.m_contactFilter.ShouldCollide(fixtureA, fixtureB) == false) {
var cNuke = c;
c = cNuke.GetNext();
this.Destroy(cNuke);
continue
}
c.m_flags &= ~b2Contact.e_filterFlag
}
var activeA = bodyA.IsAwake() && bodyA.m_type != b2Body.b2_staticBody;
var activeB = bodyB.IsAwake() && bodyB.m_type != b2Body.b2_staticBody;
if (activeA == false && activeB == false) {
c = c.GetNext();
continue
}
var proxyIdA = fixtureA.m_proxies[indexA].proxyId;
var proxyIdB = fixtureB.m_proxies[indexB].proxyId;
var overlap = this.m_broadPhase.TestOverlap(proxyIdA, proxyIdB);
if (overlap == false) {
var cNuke = c;
c = cNuke.GetNext();
this.Destroy(cNuke);
continue
}
c.Update(this.m_contactListener);
c = c.GetNext()
}
}
};
function b2VelocityConstraintPoint() {
this.rA = new b2Vec2();
this.rB = new b2Vec2();
this.normalImpulse = 0;
this.tangentImpulse = 0;
this.normalMass = 0;
this.tangentMass = 0;
this.velocityBias = 0
}
function b2ContactPositionConstraint() {
this.localPoints = new Array(b2_maxManifoldPoints);
this.localNormal = new b2Vec2();
this.localPoint = new b2Vec2();
this.indexA = 0;
this.indexB = 0;
this.invMassA = 0, this.invMassB = 0;
this.localCenterA = new b2Vec2(), this.localCenterB = new b2Vec2();
this.invIA = 0, this.invIB = 0;
this.type = 0;
this.radiusA = 0, this.radiusB = 0;
this.pointCount = 0
}
function b2ContactVelocityConstraint() {
this.points = new Array(b2_maxManifoldPoints);
for (var i = 0; i < this.points.length; ++i) {
this.points[i] = new b2VelocityConstraintPoint()
}
this.normal = new b2Vec2();
this.normalMass = new b2Mat22();
this.K = new b2Mat22();
this.indexA = 0;
this.indexB = 0;
this.invMassA = 0, this.invMassB = 0;
this.invIA = 0, this.invIB = 0;
this.friction = 0;
this.restitution = 0;
this.tangentSpeed = 0;
this.pointCount = 0;
this.contactIndex = 0
}
function b2PositionSolverManifold() {
this.normal = new b2Vec2();
this.point = new b2Vec2();
this.separation = 0
}
b2PositionSolverManifold.prototype = {
Initialize: function (pc, xfA, xfB, index) {
switch (pc.type) {
case b2Manifold.e_circles:
var pointAx = (xfA.q.c * pc.localPoint.x - xfA.q.s * pc.localPoint.y) + xfA.p.x;
var pointAy = (xfA.q.s * pc.localPoint.x + xfA.q.c * pc.localPoint.y) + xfA.p.y;
var pointBx = (xfB.q.c * pc.localPoints[0].x - xfB.q.s * pc.localPoints[0].y) + xfB.p.x;
var pointBy = (xfB.q.s * pc.localPoints[0].x + xfB.q.c * pc.localPoints[0].y) + xfB.p.y;
this.point.x = 0.5 * (pointAx + pointBx);
this.point.y = 0.5 * (pointAy + pointBy);
this.normal.x = pointBx - pointAx;
this.normal.y = pointBy - pointAy;
var tempnx = this.normal.x;
var tempny = this.normal.y;
this.normal.Normalize();
this.separation = (tempnx * this.normal.x + tempny * this.normal.y) - pc.radiusA - pc.radiusB;
break;
case b2Manifold.e_faceA:
this.normal.x = xfA.q.c * pc.localNormal.x - xfA.q.s * pc.localNormal.y;
this.normal.y = xfA.q.s * pc.localNormal.x + xfA.q.c * pc.localNormal.y;
var planePointx = (xfA.q.c * pc.localPoint.x - xfA.q.s * pc.localPoint.y) + xfA.p.x;
var planePointy = (xfA.q.s * pc.localPoint.x + xfA.q.c * pc.localPoint.y) + xfA.p.y;
var clipPointx = (xfB.q.c * pc.localPoints[index].x - xfB.q.s * pc.localPoints[index].y) + xfB.p.x;
var clipPointy = (xfB.q.s * pc.localPoints[index].x + xfB.q.c * pc.localPoints[index].y) + xfB.p.y;
this.separation = ((clipPointx - planePointx) * this.normal.x + (clipPointy - planePointy) * this.normal.y) - pc.radiusA - pc.radiusB;
this.point.x = clipPointx;
this.point.y = clipPointy;
break;
case b2Manifold.e_faceB:
this.normal.x = xfB.q.c * pc.localNormal.x - xfB.q.s * pc.localNormal.y;
this.normal.y = xfB.q.s * pc.localNormal.x + xfB.q.c * pc.localNormal.y;
var planePointx = (xfB.q.c * pc.localPoint.x - xfB.q.s * pc.localPoint.y) + xfB.p.x;
var planePointy = (xfB.q.s * pc.localPoint.x + xfB.q.c * pc.localPoint.y) + xfB.p.y;
var clipPointx = (xfA.q.c * pc.localPoints[index].x - xfA.q.s * pc.localPoints[index].y) + xfA.p.x;
var clipPointy = (xfA.q.s * pc.localPoints[index].x + xfA.q.c * pc.localPoints[index].y) + xfA.p.y;
this.separation = ((clipPointx - planePointx) * this.normal.x + (clipPointy - planePointy) * this.normal.y) - pc.radiusA - pc.radiusB;
this.point.x = clipPointx;
this.point.y = clipPointy;
this.normal.x = -this.normal.x;
this.normal.y = -this.normal.y;
break
}
}
};
function b2ContactSolverDef() {
this.step = new b2TimeStep();
this.contacts = null;
this.count = 0;
this.positions = null;
this.velocities = null
}
function b2ContactSolver() {
this.m_positionConstraints = [];
this.m_velocityConstraints = []
}
b2ContactSolver.cs_xfA = new b2Transform();
b2ContactSolver.cs_xfB = new b2Transform();
b2ContactSolver.temp_solver_manifold = new b2PositionSolverManifold();
b2ContactSolver.prototype = {
Init: function (def) {
this.m_step = def.step;
this.m_count = def.count;
this.m_positionConstraints.length = this.m_count;
this.m_velocityConstraints.length = this.m_count;
this.m_positions = def.positions;
this.m_velocities = def.velocities;
this.m_contacts = def.contacts;
for (var i = 0; i < this.m_count; ++i) {
var contact = this.m_contacts[i];
var fixtureA = contact.m_fixtureA;
var fixtureB = contact.m_fixtureB;
var shapeA = fixtureA.GetShape();
var shapeB = fixtureB.GetShape();
var radiusA = shapeA.m_radius;
var radiusB = shapeB.m_radius;
var bodyA = fixtureA.GetBody();
var bodyB = fixtureB.GetBody();
var manifold = contact.GetManifold();
var pointCount = manifold.pointCount;
var vc = this.m_velocityConstraints[i] || new b2ContactVelocityConstraint();
vc.friction = contact.m_friction;
vc.restitution = contact.m_restitution;
vc.tangentSpeed = contact.m_tangentSpeed;
vc.indexA = bodyA.m_islandIndex;
vc.indexB = bodyB.m_islandIndex;
vc.invMassA = bodyA.m_invMass;
vc.invMassB = bodyB.m_invMass;
vc.invIA = bodyA.m_invI;
vc.invIB = bodyB.m_invI;
vc.contactIndex = i;
vc.pointCount = pointCount;
vc.K.SetZero();
vc.normalMass.SetZero();
this.m_velocityConstraints[i] = vc;
var pc = this.m_positionConstraints[i] || new b2ContactPositionConstraint();
pc.indexA = bodyA.m_islandIndex;
pc.indexB = bodyB.m_islandIndex;
pc.invMassA = bodyA.m_invMass;
pc.invMassB = bodyB.m_invMass;
pc.localCenterA.x = bodyA.m_sweep.localCenter.x;
pc.localCenterA.y = bodyA.m_sweep.localCenter.y;
pc.localCenterB.x = bodyB.m_sweep.localCenter.x;
pc.localCenterB.y = bodyB.m_sweep.localCenter.y;
pc.invIA = bodyA.m_invI;
pc.invIB = bodyB.m_invI;
pc.localNormal.x = manifold.localNormal.x;
pc.localNormal.y = manifold.localNormal.y;
pc.localPoint.x = manifold.localPoint.x;
pc.localPoint.y = manifold.localPoint.y;
pc.pointCount = pointCount;
pc.radiusA = radiusA;
pc.radiusB = radiusB;
pc.type = manifold.type;
this.m_positionConstraints[i] = pc;
for (var j = 0; j < pointCount; ++j) {
var cp = manifold.points[j];
var vcp = vc.points[j];
if (this.m_step.warmStarting) {
vcp.normalImpulse = this.m_step.dtRatio * cp.normalImpulse;
vcp.tangentImpulse = this.m_step.dtRatio * cp.tangentImpulse
} else {
vcp.normalImpulse = 0;
vcp.tangentImpulse = 0
}
vcp.rA.SetZero();
vcp.rB.SetZero();
vcp.normalMass = 0;
vcp.tangentMass = 0;
vcp.velocityBias = 0;
pc.localPoints[j] = cp.localPoint
}
}
},
InitializeVelocityConstraints: function () {
for (var i = 0; i < this.m_count; ++i) {
var vc = this.m_velocityConstraints[i];
var pc = this.m_positionConstraints[i];
var radiusA = pc.radiusA;
var radiusB = pc.radiusB;
var manifold = this.m_contacts[vc.contactIndex].GetManifold();
var indexA = vc.indexA;
var indexB = vc.indexB;
var mA = vc.invMassA;
var mB = vc.invMassB;
var iA = vc.invIA;
var iB = vc.invIB;
var localCenterA = pc.localCenterA;
var localCenterB = pc.localCenterB;
var cA = this.m_positions[indexA].c;
var aA = this.m_positions[indexA].a;
var vA = this.m_velocities[indexA].v;
var wA = this.m_velocities[indexA].w;
var cB = this.m_positions[indexB].c;
var aB = this.m_positions[indexB].a;
var vB = this.m_velocities[indexB].v;
var wB = this.m_velocities[indexB].w;
b2ContactSolver.cs_xfA.q.Set(aA);
b2ContactSolver.cs_xfB.q.Set(aB);
b2ContactSolver.cs_xfA.p.x = cA.x - (b2ContactSolver.cs_xfA.q.c * localCenterA.x - b2ContactSolver.cs_xfA.q.s * localCenterA.y);
b2ContactSolver.cs_xfA.p.y = cA.y - (b2ContactSolver.cs_xfA.q.s * localCenterA.x + b2ContactSolver.cs_xfA.q.c * localCenterA.y);
b2ContactSolver.cs_xfB.p.x = cB.x - (b2ContactSolver.cs_xfB.q.c * localCenterB.x - b2ContactSolver.cs_xfB.q.s * localCenterB.y);
b2ContactSolver.cs_xfB.p.y = cB.y - (b2ContactSolver.cs_xfB.q.s * localCenterB.x + b2ContactSolver.cs_xfB.q.c * localCenterB.y);
var worldManifold = new b2WorldManifold();
worldManifold.Initialize(manifold, b2ContactSolver.cs_xfA, radiusA, b2ContactSolver.cs_xfB, radiusB);
vc.normal.x = worldManifold.normal.x;
vc.normal.y = worldManifold.normal.y;
var pointCount = vc.pointCount;
for (var j = 0; j < pointCount; ++j) {
var vcp = vc.points[j];
vcp.rA.x = worldManifold.points[j].x - cA.x;
vcp.rA.y = worldManifold.points[j].y - cA.y;
vcp.rB.x = worldManifold.points[j].x - cB.x;
vcp.rB.y = worldManifold.points[j].y - cB.y;
var rnA = vcp.rA.x * vc.normal.y - vcp.rA.y * vc.normal.x;
var rnB = vcp.rB.x * vc.normal.y - vcp.rB.y * vc.normal.x;
var kNormal = mA + mB + iA * rnA * rnA + iB * rnB * rnB;
vcp.normalMass = kNormal > 0 ? 1 / kNormal : 0;
var tangentx = 1 * vc.normal.y;
var tangenty = -1 * vc.normal.x;
var rtA = vcp.rA.x * tangenty - vcp.rA.y * tangentx;
var rtB = vcp.rB.x * tangenty - vcp.rB.y * tangentx;
var kTangent = mA + mB + iA * rtA * rtA + iB * rtB * rtB;
vcp.tangentMass = kTangent > 0 ? 1 / kTangent : 0;
vcp.velocityBias = 0;
var vRel = vc.normal.x * (((vB.x + (-wB * vcp.rB.y)) - vA.x) - (-wA * vcp.rA.y)) + vc.normal.y * (((vB.y + (wB * vcp.rB.x)) - vA.y) - (wA * vcp.rA.x));
if (vRel < -b2_velocityThreshold) {
vcp.velocityBias = -vc.restitution * vRel
}
}
if (vc.pointCount == 2) {
var vcp1 = vc.points[0];
var vcp2 = vc.points[1];
var rn1A = vcp1.rA.x * vc.normal.y - vcp1.rA.y * vc.normal.x;
var rn1B = vcp1.rB.x * vc.normal.y - vcp1.rB.y * vc.normal.x;
var rn2A = vcp2.rA.x * vc.normal.y - vcp2.rA.y * vc.normal.x;
var rn2B = vcp2.rB.x * vc.normal.y - vcp2.rB.y * vc.normal.x;
var k11 = mA + mB + iA * rn1A * rn1A + iB * rn1B * rn1B;
var k22 = mA + mB + iA * rn2A * rn2A + iB * rn2B * rn2B;
var k12 = mA + mB + iA * rn1A * rn2A + iB * rn1B * rn2B;
var k_maxConditionNumber = 1000;
if (k11 * k11 < k_maxConditionNumber * (k11 * k22 - k12 * k12)) {
vc.K.ex.x = k11;
vc.K.ex.y = k12;
vc.K.ey.x = k12;
vc.K.ey.y = k22;
vc.normalMass.Assign(vc.K.GetInverse())
} else {
vc.pointCount = 1
}
}
}
},
WarmStart: function () {
for (var i = 0; i < this.m_count; ++i) {
var vc = this.m_velocityConstraints[i];
var indexA = vc.indexA;
var indexB = vc.indexB;
var mA = vc.invMassA;
var iA = vc.invIA;
var mB = vc.invMassB;
var iB = vc.invIB;
var pointCount = vc.pointCount;
var vA = this.m_velocities[indexA].v;
var wA = this.m_velocities[indexA].w;
var vB = this.m_velocities[indexB].v;
var wB = this.m_velocities[indexB].w;
var normal = vc.normal;
var tangentx = 1 * normal.y;
var tangenty = -1 * normal.x;
for (var j = 0; j < pointCount; ++j) {
var vcp = vc.points[j];
var Px = (vcp.normalImpulse * normal.x) + (vcp.tangentImpulse * tangentx);
var Py = (vcp.normalImpulse * normal.y) + (vcp.tangentImpulse * tangenty);
wA -= iA * (vcp.rA.x * Py - vcp.rA.y * Px);
vA.x -= mA * Px;
vA.y -= mA * Py;
wB += iB * (vcp.rB.x * Py - vcp.rB.y * Px);
vB.x += mB * Px;
vB.y += mB * Py
}
this.m_velocities[indexA].w = wA;
this.m_velocities[indexB].w = wB
}
},
SolveVelocityConstraints: function () {
for (var i = 0; i < this.m_count; ++i) {
var vc = this.m_velocityConstraints[i];
var indexA = vc.indexA;
var indexB = vc.indexB;
var mA = vc.invMassA;
var iA = vc.invIA;
var mB = vc.invMassB;
var iB = vc.invIB;
var pointCount = vc.pointCount;
var vA = this.m_velocities[indexA].v;
var wA = this.m_velocities[indexA].w;
var vB = this.m_velocities[indexB].v;
var wB = this.m_velocities[indexB].w;
var normal = vc.normal;
var tangentx = 1 * normal.y;
var tangenty = -1 * normal.x;
var friction = vc.friction;
for (var j = 0; j < pointCount; ++j) {
var vcp = vc.points[j];
var dvx = vB.x + (-wB * vcp.rB.y) - vA.x - (-wA * vcp.rA.y);
var dvy = vB.y + (wB * vcp.rB.x) - vA.y - (wA * vcp.rA.x);
var vt = (dvx * tangentx + dvy * tangenty) - vc.tangentSpeed;
var lambda = vcp.tangentMass * (-vt);
var maxFriction = friction * vcp.normalImpulse;
var newImpulse = b2Clamp(vcp.tangentImpulse + lambda, -maxFriction, maxFriction);
lambda = newImpulse - vcp.tangentImpulse;
vcp.tangentImpulse = newImpulse;
var Px = lambda * tangentx;
var Py = lambda * tangenty;
vA.x -= mA * Px;
vA.y -= mA * Py;
wA -= iA * (vcp.rA.x * Py - vcp.rA.y * Px);
vB.x += mB * Px;
vB.y += mB * Py;
wB += iB * (vcp.rB.x * Py - vcp.rB.y * Px)
}
if (vc.pointCount == 1) {
vcp = vc.points[0];
dvx = vB.x + (-wB * vcp.rB.y) - vA.x - (-wA * vcp.rA.y);
dvy = vB.y + (wB * vcp.rB.x) - vA.y - (wA * vcp.rA.x);
var vn = dvx * normal.x + dvy * normal.y;
var lambda = -vcp.normalMass * (vn - vcp.velocityBias);
var newImpulse = b2Max(vcp.normalImpulse + lambda, 0);
lambda = newImpulse - vcp.normalImpulse;
vcp.normalImpulse = newImpulse;
Px = lambda * normal.x;
Py = lambda * normal.y;
vA.x -= mA * Px;
vA.y -= mA * Py;
wA -= iA * (vcp.rA.x * Py - vcp.rA.y * Px);
vB.x += mB * Px;
vB.y += mB * Py;
wB += iB * (vcp.rB.x * Py - vcp.rB.y * Px)
} else {
var cp1 = vc.points[0];
var cp2 = vc.points[1];
var ax = cp1.normalImpulse;
var ay = cp2.normalImpulse;
var dv1x = vB.x + (-wB * cp1.rB.y) - vA.x - (-wA * cp1.rA.y);
var dv1y = vB.y + (wB * cp1.rB.x) - vA.y - (wA * cp1.rA.x);
var dv2x = vB.x + (-wB * cp2.rB.y) - vA.x - (-wA * cp2.rA.y);
var dv2y = vB.y + (wB * cp2.rB.x) - vA.y - (wA * cp2.rA.x);
var vn1 = dv1x * normal.x + dv1y * normal.y;
var vn2 = dv2x * normal.x + dv2y * normal.y;
var bx = vn1 - cp1.velocityBias;
var by = vn2 - cp2.velocityBias;
bx -= vc.K.ex.x * ax + vc.K.ey.x * ay;
by -= vc.K.ex.y * ax + vc.K.ey.y * ay;
for (;;) {
var xx = -(vc.normalMass.ex.x * bx + vc.normalMass.ey.x * by);
var xy = -(vc.normalMass.ex.y * bx + vc.normalMass.ey.y * by);
if (xx >= 0 && xy >= 0) {
var dx = xx - ax;
var dy = xy - ay;
var P1x = dx * normal.x;
var P1y = dx * normal.y;
var P2x = dy * normal.x;
var P2y = dy * normal.y;
vA.x -= mA * (P1x + P2x);
vA.y -= mA * (P1y + P2y);
wA -= iA * ((cp1.rA.x * P1y - cp1.rA.y * P1x) + (cp2.rA.x * P2y - cp2.rA.y * P2x));
vB.x += mB * (P1x + P2x);
vB.y += mB * (P1y + P2y);
wB += iB * ((cp1.rB.x * P1y - cp1.rB.y * P1x) + (cp2.rB.x * P2y - cp2.rB.y * P2x));
cp1.normalImpulse = xx;
cp2.normalImpulse = xy;
break
}
xx = -cp1.normalMass * bx;
xy = 0;
vn1 = 0;
vn2 = vc.K.ex.y * xx + by;
if (xx >= 0 && vn2 >= 0) {
dx = xx - ax;
dy = xy - ay;
P1x = dx * normal.x;
P1y = dx * normal.y;
P2x = dy * normal.x;
P2y = dy * normal.y;
vA.x -= mA * (P1x + P2x);
vA.y -= mA * (P1y + P2y);
wA -= iA * ((cp1.rA.x * P1y - cp1.rA.y * P1x) + (cp2.rA.x * P2y - cp2.rA.y * P2x));
vB.x += mB * (P1x + P2x);
vB.y += mB * (P1y + P2y);
wB += iB * ((cp1.rB.x * P1y - cp1.rB.y * P1x) + (cp2.rB.x * P2y - cp2.rB.y * P2x));
cp1.normalImpulse = xx;
cp2.normalImpulse = xy;
break
}
xx = 0;
xy = -cp2.normalMass * by;
vn1 = vc.K.ey.x * xy + bx;
vn2 = 0;
if (xy >= 0 && vn1 >= 0) {
dx = xx - ax;
dy = xy - ay;
P1x = dx * normal.x;
P1y = dx * normal.y;
P2x = dy * normal.x;
P2y = dy * normal.y;
vA.x -= mA * (P1x + P2x);
vA.y -= mA * (P1y + P2y);
wA -= iA * ((cp1.rA.x * P1y - cp1.rA.y * P1x) + (cp2.rA.x * P2y - cp2.rA.y * P2x));
vB.x += mB * (P1x + P2x);
vB.y += mB * (P1y + P2y);
wB += iB * ((cp1.rB.x * P1y - cp1.rB.y * P1x) + (cp2.rB.x * P2y - cp2.rB.y * P2x));
cp1.normalImpulse = xx;
cp2.normalImpulse = xy;
break
}
xx = 0;
xy = 0;
vn1 = bx;
vn2 = by;
if (vn1 >= 0 && vn2 >= 0) {
dx = xx - ax;
dy = xy - ay;
P1x = dx * normal.x;
P1y = dx * normal.y;
P2x = dy * normal.x;
P2y = dy * normal.y;
vA.x -= mA * (P1x + P2x);
vA.y -= mA * (P1y + P2y);
wA -= iA * ((cp1.rA.x * P1y - cp1.rA.y * P1x) + (cp2.rA.x * P2y - cp2.rA.y * P2x));
vB.x += mB * (P1x + P2x);
vB.y += mB * (P1y + P2y);
wB += iB * ((cp1.rB.x * P1y - cp1.rB.y * P1x) + (cp2.rB.x * P2y - cp2.rB.y * P2x));
cp1.normalImpulse = xx;
cp2.normalImpulse = xy;
break
}
break
}
}
this.m_velocities[indexA].w = wA;
this.m_velocities[indexB].w = wB
}
},
StoreImpulses: function () {
for (var i = 0; i < this.m_count; ++i) {
var vc = this.m_velocityConstraints[i];
var manifold = this.m_contacts[vc.contactIndex].GetManifold();
for (var j = 0; j < vc.pointCount; ++j) {
manifold.points[j].normalImpulse = vc.points[j].normalImpulse;
manifold.points[j].tangentImpulse = vc.points[j].tangentImpulse
}
}
},
SolvePositionConstraints: function () {
var minSeparation = 0;
for (var i = 0; i < this.m_count; ++i) {
var pc = this.m_positionConstraints[i];
var indexA = pc.indexA;
var indexB = pc.indexB;
var localCenterA = pc.localCenterA;
var mA = pc.invMassA;
var iA = pc.invIA;
var localCenterB = pc.localCenterB;
var mB = pc.invMassB;
var iB = pc.invIB;
var pointCount = pc.pointCount;
var cA = this.m_positions[indexA].c;
var aA = this.m_positions[indexA].a;
var cB = this.m_positions[indexB].c;
var aB = this.m_positions[indexB].a;
for (var j = 0; j < pointCount; ++j) {
b2ContactSolver.cs_xfA.q.Set(aA);
b2ContactSolver.cs_xfB.q.Set(aB);
b2ContactSolver.cs_xfA.p.x = cA.x - (b2ContactSolver.cs_xfA.q.c * localCenterA.x - b2ContactSolver.cs_xfA.q.s * localCenterA.y);
b2ContactSolver.cs_xfA.p.y = cA.y - (b2ContactSolver.cs_xfA.q.s * localCenterA.x + b2ContactSolver.cs_xfA.q.c * localCenterA.y);
b2ContactSolver.cs_xfB.p.x = cB.x - (b2ContactSolver.cs_xfB.q.c * localCenterB.x - b2ContactSolver.cs_xfB.q.s * localCenterB.y);
b2ContactSolver.cs_xfB.p.y = cB.y - (b2ContactSolver.cs_xfB.q.s * localCenterB.x + b2ContactSolver.cs_xfB.q.c * localCenterB.y);
b2ContactSolver.temp_solver_manifold.Initialize(pc, b2ContactSolver.cs_xfA, b2ContactSolver.cs_xfB, j);
var normal = b2ContactSolver.temp_solver_manifold.normal;
var point = b2ContactSolver.temp_solver_manifold.point;
var separation = b2ContactSolver.temp_solver_manifold.separation;
var rAx = point.x - cA.x;
var rAy = point.y - cA.y;
var rBx = point.x - cB.x;
var rBy = point.y - cB.y;
minSeparation = b2Min(minSeparation, separation);
var C = b2Clamp(b2_baumgarte * (separation + b2_linearSlop), -b2_maxLinearCorrection, 0);
var rnA = rAx * normal.y - rAy * normal.x;
var rnB = rBx * normal.y - rBy * normal.x;
var K = mA + mB + iA * rnA * rnA + iB * rnB * rnB;
var impulse = K > 0 ? -C / K : 0;
var Px = impulse * normal.x;
var Py = impulse * normal.y;
cA.x -= mA * Px;
cA.y -= mA * Py;
aA -= iA * (rAx * Py - rAy * Px);
cB.x += mB * Px;
cB.y += mB * Py;
aB += iB * (rBx * Py - rBy * Px)
}
this.m_positions[indexA].a = aA;
this.m_positions[indexB].a = aB
}
return minSeparation >= -3 * b2_linearSlop
},
SolveTOIPositionConstraints: function (toiIndexA, toiIndexB) {
var minSeparation = 0;
for (var i = 0; i < this.m_count; ++i) {
var pc = this.m_positionConstraints[i];
var indexA = pc.indexA;
var indexB = pc.indexB;
var localCenterA = pc.localCenterA;
var localCenterB = pc.localCenterB;
var pointCount = pc.pointCount;
var mA = 0;
var iA = 0;
if (indexA == toiIndexA || indexA == toiIndexB) {
mA = pc.invMassA;
iA = pc.invIA
}
var mB = 0;
var iB = 0;
if (indexB == toiIndexA || indexB == toiIndexB) {
mB = pc.invMassB;
iB = pc.invIB
}
var cA = this.m_positions[indexA].c;
var aA = this.m_positions[indexA].a;
var cB = this.m_positions[indexB].c;
var aB = this.m_positions[indexB].a;
for (var j = 0; j < pointCount; ++j) {
b2ContactSolver.cs_xfA.q.Set(aA);
b2ContactSolver.cs_xfB.q.Set(aB);
b2ContactSolver.cs_xfA.p.Assign(b2Vec2.Subtract(cA, b2Mul_r_v2(b2ContactSolver.cs_xfA.q, localCenterA)));
b2ContactSolver.cs_xfB.p.Assign(b2Vec2.Subtract(cB, b2Mul_r_v2(b2ContactSolver.cs_xfB.q, localCenterB)));
b2ContactSolver.temp_solver_manifold.Initialize(pc, b2ContactSolver.cs_xfA, b2ContactSolver.cs_xfB, j);
var normal = b2ContactSolver.temp_solver_manifold.normal;
var point = b2ContactSolver.temp_solver_manifold.point;
var separation = b2ContactSolver.temp_solver_manifold.separation;
var rA = b2Vec2.Subtract(point, cA);
var rB = b2Vec2.Subtract(point, cB);
minSeparation = b2Min(minSeparation, separation);
var C = b2Clamp(b2_toiBaugarte * (separation + b2_linearSlop), -b2_maxLinearCorrection, 0);
var rnA = b2Cross_v2_v2(rA, normal);
var rnB = b2Cross_v2_v2(rB, normal);
var K = mA + mB + iA * rnA * rnA + iB * rnB * rnB;
var impulse = K > 0 ? -C / K : 0;
var P = b2Vec2.Multiply(impulse, normal);
cA.Subtract(b2Vec2.Multiply(mA, P));
aA -= iA * b2Cross_v2_v2(rA, P);
cB.Add(b2Vec2.Multiply(mB, P));
aB += iB * b2Cross_v2_v2(rB, P)
}
this.m_positions[indexA].a = aA;
this.m_positions[indexB].a = aB
}
return minSeparation >= -1.5 * b2_linearSlop
}
};
"use strict";
function b2Island() {
this.m_bodies = [];
this.m_contacts = [];
this.m_joints = [];
this.m_velocities = [];
this.m_positions = []
}
var profile_solve_init = b2Profiler.create("solve initialization", "solve");
var profile_solve_init_warmStarting = b2Profiler.create("warm starting", "solve initialization");
var profile_solve_velocity = b2Profiler.create("solve velocities", "solve");
var profile_solve_position = b2Profiler.create("solve positions", "solve");
b2Island._solverData = new b2SolverData();
b2Island._solverDef = new b2ContactSolverDef();
b2Island._solver = new b2ContactSolver();
b2Island.prototype = {
Clear: function () {
this.m_bodyCount = 0;
this.m_contactCount = 0;
this.m_jointCount = 0
},
Initialize: function (bodyCapacity, contactCapacity, jointCapacity, listener) {
this.m_listener = listener;
this.m_bodyCapacity = bodyCapacity;
this.m_contactCapacity = contactCapacity;
this.m_jointCapacity = jointCapacity;
this.m_bodyCount = 0;
this.m_contactCount = 0;
this.m_jointCount = 0;
this.m_bodies.length = bodyCapacity;
this.m_contacts.length = contactCapacity;
this.m_joints.length = jointCapacity;
this.m_velocities.length = bodyCapacity;
this.m_positions.length = bodyCapacity
},
Solve: function (step, gravity, allowSleep) {
profile_solve_init.start();
var h = step.dt;
for (var i = 0; i < this.m_bodyCount; ++i) {
var b = this.m_bodies[i];
this.m_positions[i].c.Assign(b.m_sweep.c);
var a = b.m_sweep.a;
this.m_velocities[i].v.Assign(b.m_linearVelocity);
var w = b.m_angularVelocity;
b.m_sweep.c0.Assign(b.m_sweep.c);
b.m_sweep.a0 = b.m_sweep.a;
if (b.m_type == b2Body.b2_dynamicBody) {
this.m_velocities[i].v.x += h * ((b.m_gravityScale * gravity.x) + (b.m_invMass * b.m_force.x));
this.m_velocities[i].v.y += h * ((b.m_gravityScale * gravity.y) + (b.m_invMass * b.m_force.y));
w += h * b.m_invI * b.m_torque;
this.m_velocities[i].v.x *= 1 / (1 + h * b.m_linearDamping);
this.m_velocities[i].v.y *= 1 / (1 + h * b.m_linearDamping);
w *= 1 / (1 + h * b.m_angularDamping)
}
this.m_positions[i].a = a;
this.m_velocities[i].w = w
}
b2Island._solverData.step = step;
b2Island._solverData.positions = this.m_positions;
b2Island._solverData.velocities = this.m_velocities;
b2Island._solverDef.step = step;
b2Island._solverDef.contacts = this.m_contacts;
b2Island._solverDef.count = this.m_contactCount;
b2Island._solverDef.positions = this.m_positions;
b2Island._solverDef.velocities = this.m_velocities;
b2Island._solverDef.allocator = this.m_allocator;
b2Island._solver.Init(b2Island._solverDef);
b2Island._solver.InitializeVelocityConstraints();
if (step.warmStarting) {
profile_solve_init_warmStarting.start();
b2Island._solver.WarmStart();
profile_solve_init_warmStarting.stop()
}
for (var i = 0; i < this.m_jointCount; ++i) {
this.m_joints[i].InitVelocityConstraints(b2Island._solverData)
}
profile_solve_init.stop();
profile_solve_velocity.start();
for (var i = 0; i < step.velocityIterations; ++i) {
for (var j = 0; j < this.m_jointCount; ++j) {
this.m_joints[j].SolveVelocityConstraints(b2Island._solverData)
}
b2Island._solver.SolveVelocityConstraints()
}
b2Island._solver.StoreImpulses();
profile_solve_velocity.stop();
profile_solve_position.start();
for (var i = 0; i < this.m_bodyCount; ++i) {
var c = this.m_positions[i].c;
var a = this.m_positions[i].a;
var v = this.m_velocities[i].v;
var w = this.m_velocities[i].w;
var translationx = h * v.x;
var translationy = h * v.y;
var translationl = translationx * translationx + translationy * translationy;
if (translationl > b2_maxTranslationSquared) {
var ratio = b2_maxTranslation / b2Sqrt(translationl);
v.x *= ratio;
v.y *= ratio
}
var rotation = h * w;
if (rotation * rotation > b2_maxRotationSquared) {
var ratio = b2_maxRotation / b2Abs(rotation);
w *= ratio
}
c.x += h * v.x;
c.y += h * v.y;
a += h * w;
this.m_positions[i].a = a;
this.m_velocities[i].w = w
}
var positionSolved = false;
for (var i = 0; i < step.positionIterations; ++i) {
var contactsOkay = b2Island._solver.SolvePositionConstraints();
var jointsOkay = true;
for (var j = 0; j < this.m_jointCount; ++j) {
var jointOkay = this.m_joints[j].SolvePositionConstraints(b2Island._solverData);
jointsOkay = jointsOkay && jointOkay
}
if (contactsOkay && jointsOkay) {
positionSolved = true;
break
}
}
for (var i = 0; i < this.m_bodyCount; ++i) {
var body = this.m_bodies[i];
body.m_sweep.c.Assign(this.m_positions[i].c);
body.m_sweep.a = this.m_positions[i].a;
body.m_linearVelocity.Assign(this.m_velocities[i].v);
body.m_angularVelocity = this.m_velocities[i].w;
body.SynchronizeTransform()
}
profile_solve_position.stop();
this.Report(b2Island._solver.m_velocityConstraints);
if (allowSleep) {
var minSleepTime = b2_maxFloat;
var linTolSqr = b2_linearSleepTolerance * b2_linearSleepTolerance;
var angTolSqr = b2_angularSleepTolerance * b2_angularSleepTolerance;
for (var i = 0; i < this.m_bodyCount; ++i) {
var b = this.m_bodies[i];
if (b.GetType() == b2Body.b2_staticBody) {
continue
}
if ((b.m_flags & b2Body.e_autoSleepFlag) == 0 || b.m_angularVelocity * b.m_angularVelocity > angTolSqr || b2Dot_v2_v2(b.m_linearVelocity, b.m_linearVelocity) > linTolSqr) {
b.m_sleepTime = 0;
minSleepTime = 0
} else {
b.m_sleepTime += h;
minSleepTime = b2Min(minSleepTime, b.m_sleepTime)
}
}
if (minSleepTime >= b2_timeToSleep && positionSolved) {
for (var i = 0; i < this.m_bodyCount; ++i) {
var b = this.m_bodies[i];
b.SetAwake(false)
}
}
}
},
SolveTOI: function (subStep, toiIndexA, toiIndexB) {
for (var i = 0; i < this.m_bodyCount; ++i) {
var b = this.m_bodies[i];
this.m_positions[i].c.Assign(b.m_sweep.c);
this.m_positions[i].a = b.m_sweep.a;
this.m_velocities[i].v.Assign(b.m_linearVelocity);
this.m_velocities[i].w = b.m_angularVelocity
}
b2Island._solverDef.contacts = this.m_contacts;
b2Island._solverDef.count = this.m_contactCount;
b2Island._solverDef.step = subStep;
b2Island._solverDef.positions = this.m_positions;
b2Island._solverDef.velocities = this.m_velocities;
b2Island._solver.Init(b2Island._solverDef);
for (var i = 0; i < subStep.positionIterations; ++i) {
var contactsOkay = b2Island._solver.SolveTOIPositionConstraints(toiIndexA, toiIndexB);
if (contactsOkay) {
break
}
}
this.m_bodies[toiIndexA].m_sweep.c0.Assign(this.m_positions[toiIndexA].c);
this.m_bodies[toiIndexA].m_sweep.a0 = this.m_positions[toiIndexA].a;
this.m_bodies[toiIndexB].m_sweep.c0.Assign(this.m_positions[toiIndexB].c);
this.m_bodies[toiIndexB].m_sweep.a0 = this.m_positions[toiIndexB].a;
b2Island._solver.InitializeVelocityConstraints();
for (var i = 0; i < subStep.velocityIterations; ++i) {
b2Island._solver.SolveVelocityConstraints()
}
var h = subStep.dt;
for (var i = 0; i < this.m_bodyCount; ++i) {
var c = this.m_positions[i].c;
var a = this.m_positions[i].a;
var v = this.m_velocities[i].v;
var w = this.m_velocities[i].w;
var translation = b2Vec2.Multiply(h, v);
if (b2Dot_v2_v2(translation, translation) > b2_maxTranslationSquared) {
var ratio = b2_maxTranslation / translation.Length();
v.Multiply(ratio)
}
var rotation = h * w;
if (rotation * rotation > b2_maxRotationSquared) {
var ratio = b2_maxRotation / b2Abs(rotation);
w *= ratio
}
c.Add(b2Vec2.Multiply(h, v));
a += h * w;
this.m_positions[i].a = a;
this.m_velocities[i].w = w;
var body = this.m_bodies[i];
body.m_sweep.c.Assign(c);
body.m_sweep.a = a;
body.m_linearVelocity.Assign(v);
body.m_angularVelocity = w;
body.SynchronizeTransform()
}
this.Report(b2Island._solver.m_velocityConstraints)
},
AddBody: function (body) {
body.m_islandIndex = this.m_bodyCount;
this.m_bodies[this.m_bodyCount] = body;
if (!this.m_positions[this.m_bodyCount]) {
this.m_positions[this.m_bodyCount] = new b2Position();
this.m_velocities[this.m_bodyCount] = new b2Velocity()
}++this.m_bodyCount
},
AddContact: function (contact) {
this.m_contacts[this.m_contactCount++] = contact
},
AddJoint: function (joint) {
this.m_joints[this.m_jointCount++] = joint
},
Report: function (constraints) {
if (this.m_listener == null) {
return
}
for (var i = 0; i < this.m_contactCount; ++i) {
var c = this.m_contacts[i];
var vc = constraints[i];
var impulse = new b2ContactImpulse();
impulse.count = vc.pointCount;
for (var j = 0; j < vc.pointCount; ++j) {
impulse.normalImpulses[j] = vc.points[j].normalImpulse;
impulse.tangentImpulses[j] = vc.points[j].tangentImpulse
}
this.m_listener.PostSolve(c, impulse)
}
}
};
function b2Jacobian() {
this.linear = new b2Vec2();
this.angularA = 0;
this.angularB = 0
}
function b2JointEdge() {
this.other = null;
this.joint = null;
this.prev = null;
this.next = null
}
function b2JointDef() {
this.type = b2Joint.e_unknownJoint;
this.userData = null;
this.bodyA = null;
this.bodyB = null;
this.collideConnected = false
}
b2JointDef.prototype = {
_deserialize: function (data, bodies, joints) {
this.bodyA = bodies[data.bodyA];
this.bodyB = bodies[data.bodyB];
this.collideConnected = data.collideConnected
}
};
function b2Joint(def) {
this.m_type = def.type;
this.m_prev = null;
this.m_next = null;
this.m_bodyA = def.bodyA;
this.m_bodyB = def.bodyB;
this.m_index = 0;
this.m_collideConnected = def.collideConnected;
this.m_islandFlag = false;
this.m_userData = def.userData;
this.m_edgeA = new b2JointEdge();
this.m_edgeA.joint = null;
this.m_edgeA.other = null;
this.m_edgeA.prev = null;
this.m_edgeA.next = null;
this.m_edgeB = new b2JointEdge();
this.m_edgeB.joint = null;
this.m_edgeB.other = null;
this.m_edgeB.prev = null;
this.m_edgeB.next = null
}
b2Joint.prototype = {
GetType: function () {
return this.m_type
},
GetBodyA: function () {
return this.m_bodyA
},
GetBodyB: function () {
return this.m_bodyB
},
GetAnchorA: function () {},
GetAnchorB: function () {},
GetReactionForce: function (inv_dt) {},
GetReactionTorque: function (inv_dt) {},
GetNext: function () {
return this.m_next
},
GetUserData: function () {
return this.m_userData
},
SetUserData: function (data) {
this.m_userData = data
},
IsActive: function () {
return this.m_bodyA.IsActive() && this.m_bodyB.IsActive()
},
GetCollideConnected: function () {
return this.m_collideConnected
},
ShiftOrigin: function (newOrigin) {},
InitVelocityConstraints: function (data) {},
SolveVelocityConstraints: function (data) {},
SolvePositionConstraints: function (data) {},
_serialize: function (out) {
var obj = out || {};
obj.bodyA = null;
obj.bodyB = null;
obj.type = this.m_type;
obj.collideConnected = this.m_collideConnected;
return obj
}
};
b2Joint.e_inactiveLimit = 0;
b2Joint.e_atLowerLimit = 1;
b2Joint.e_atUpperLimit = 2;
b2Joint.e_equalLimits = 3;
b2Joint.e_unknownJoint = 0;
b2Joint.e_revoluteJoint = 1;
b2Joint.e_prismaticJoint = 2;
b2Joint.e_distanceJoint = 3;
b2Joint.e_pulleyJoint = 4;
b2Joint.e_mouseJoint = 5;
b2Joint.e_gearJoint = 6;
b2Joint.e_wheelJoint = 7;
b2Joint.e_weldJoint = 8;
b2Joint.e_frictionJoint = 9;
b2Joint.e_ropeJoint = 10;
b2Joint.e_motorJoint = 11;
b2Joint.Create = function (def) {
var joint = null;
switch (def.type) {
case b2Joint.e_distanceJoint:
joint = new b2DistanceJoint(def);
break;
case b2Joint.e_mouseJoint:
joint = new b2MouseJoint(def);
break;
case b2Joint.e_prismaticJoint:
joint = new b2PrismaticJoint(def);
break;
case b2Joint.e_revoluteJoint:
joint = new b2RevoluteJoint(def);
break;
case b2Joint.e_pulleyJoint:
joint = new b2PulleyJoint(def);
break;
case b2Joint.e_gearJoint:
joint = new b2GearJoint(def);
break;
case b2Joint.e_wheelJoint:
joint = new b2WheelJoint(def);
break;
case b2Joint.e_weldJoint:
joint = new b2WeldJoint(def);
break;
case b2Joint.e_frictionJoint:
joint = new b2FrictionJoint(def);
break;
case b2Joint.e_ropeJoint:
joint = new b2RopeJoint(def);
break;
case b2Joint.e_motorJoint:
joint = new b2MotorJoint(def);
break
}
return joint
};
b2Joint.Destroy = function (joint) {};
function b2RevoluteJointDef() {
this.parent.call(this);
this.type = b2Joint.e_revoluteJoint;
this.localAnchorA = new b2Vec2();
this.localAnchorB = new b2Vec2();
this.referenceAngle = 0;
this.lowerAngle = 0;
this.upperAngle = 0;
this.maxMotorTorque = 0;
this.motorSpeed = 0;
this.enableLimit = false;
this.enableMotor = false;
Object.seal(this)
}
b2RevoluteJointDef.prototype = {
Initialize: function (bA, bB, anchor) {
this.bodyA = bA;
this.bodyB = bB;
this.localAnchorA = this.bodyA.GetLocalPoint(anchor);
this.localAnchorB = this.bodyB.GetLocalPoint(anchor);
this.referenceAngle = this.bodyB.GetAngle() - this.bodyA.GetAngle()
},
_deserialize: function (data, bodies, joints) {
this.parent.prototype._deserialize.call(this, data, bodies, joints);
this.localAnchorA._deserialize(data.localAnchorA);
this.localAnchorB._deserialize(data.localAnchorB);
this.referenceAngle = data.referenceAngle;
this.lowerAngle = data.lowerAngle;
this.upperAngle = data.upperAngle;
this.maxMotorTorque = data.maxMotorTorque;
this.motorSpeed = data.motorSpeed;
this.enableLimit = data.enableLimit;
this.enableMotor = data.enableMotor
}
};
b2RevoluteJointDef._extend(b2JointDef);
function b2RevoluteJoint(def) {
this.parent.call(this, def);
this.m_localAnchorA = def.localAnchorA.Clone();
this.m_localAnchorB = def.localAnchorB.Clone();
this.m_referenceAngle = def.referenceAngle;
this.m_impulse = new b2Vec3();
this.m_motorImpulse = 0;
this.m_lowerAngle = def.lowerAngle;
this.m_upperAngle = def.upperAngle;
this.m_maxMotorTorque = def.maxMotorTorque;
this.m_motorSpeed = def.motorSpeed;
this.m_enableLimit = def.enableLimit;
this.m_enableMotor = def.enableMotor;
this.m_limitState = b2Joint.e_inactiveLimit;
this.m_indexA = 0;
this.m_indexB = 0;
this.m_rA = new b2Vec2();
this.m_rB = new b2Vec2();
this.m_localCenterA = new b2Vec2();
this.m_localCenterB = new b2Vec2();
this.m_invMassA = 0;
this.m_invMassB = 0;
this.m_invIA = 0;
this.m_invIB = 0;
this.m_mass = new b2Mat33();
this.m_motorMass = 0
}
b2RevoluteJoint.prototype = {
GetAnchorA: function () {
return this.m_bodyA.GetWorldPoint(this.m_localAnchorA)
},
GetAnchorB: function () {
return this.m_bodyB.GetWorldPoint(this.m_localAnchorB)
},
GetLocalAnchorA: function () {
return this.m_localAnchorA
},
GetLocalAnchorB: function () {
return this.m_localAnchorB
},
GetReferenceAngle: function () {
return this.m_referenceAngle
},
GetJointAngle: function () {
var bA = this.m_bodyA;
var bB = this.m_bodyB;
return bB.m_sweep.a - bA.m_sweep.a - this.m_referenceAngle
},
GetJointSpeed: function () {
var bA = this.m_bodyA;
var bB = this.m_bodyB;
return bB.m_angularVelocity - bA.m_angularVelocity
},
IsLimitEnabled: function () {
return this.m_enableLimit
},
EnableLimit: function (flag) {
if (flag != this.m_enableLimit) {
this.m_bodyA.SetAwake(true);
this.m_bodyB.SetAwake(true);
this.m_enableLimit = flag;
this.m_impulse.z = 0
}
},
GetLowerLimit: function () {
return this.m_lowerAngle
},
GetUpperLimit: function () {
return this.m_upperAngle
},
SetLimits: function (lower, upper) {
if (lower != this.m_lowerAngle || upper != this.m_upperAngle) {
this.m_bodyA.SetAwake(true);
this.m_bodyB.SetAwake(true);
this.m_impulse.z = 0;
this.m_lowerAngle = lower;
this.m_upperAngle = upper
}
},
IsMotorEnabled: function () {
return this.m_enableMotor
},
EnableMotor: function (flag) {
this.m_bodyA.SetAwake(true);
this.m_bodyB.SetAwake(true);
this.m_enableMotor = flag
},
SetMotorSpeed: function (speed) {
this.m_bodyA.SetAwake(true);
this.m_bodyB.SetAwake(true);
this.m_motorSpeed = speed
},
GetMotorSpeed: function () {
return this.m_motorSpeed
},
SetMaxMotorTorque: function (torque) {
this.m_bodyA.SetAwake(true);
this.m_bodyB.SetAwake(true);
this.m_maxMotorTorque = torque
},
GetMaxMotorTorque: function () {
return this.m_maxMotorTorque
},
GetReactionForce: function (inv_dt) {
var P = new b2Vec2(this.m_impulse.x, this.m_impulse.y);
return b2Vec2.Multiply(inv_dt, P)
},
GetReactionTorque: function (inv_dt) {
return inv_dt * this.m_impulse.z
},
GetMotorTorque: function (inv_dt) {
return inv_dt * this.m_motorImpulse
},
InitVelocityConstraints: function (data) {
this.m_indexA = this.m_bodyA.m_islandIndex;
this.m_indexB = this.m_bodyB.m_islandIndex;
this.m_localCenterA = this.m_bodyA.m_sweep.localCenter;
this.m_localCenterB = this.m_bodyB.m_sweep.localCenter;
this.m_invMassA = this.m_bodyA.m_invMass;
this.m_invMassB = this.m_bodyB.m_invMass;
this.m_invIA = this.m_bodyA.m_invI;
this.m_invIB = this.m_bodyB.m_invI;
var aA = data.positions[this.m_indexA].a;
var vA = data.velocities[this.m_indexA].v.Clone();
var wA = data.velocities[this.m_indexA].w;
var aB = data.positions[this.m_indexB].a;
var vB = data.velocities[this.m_indexB].v.Clone();
var wB = data.velocities[this.m_indexB].w;
var qA = new b2Rot(aA),
qB = new b2Rot(aB);
this.m_rA = b2Mul_r_v2(qA, b2Vec2.Subtract(this.m_localAnchorA, this.m_localCenterA));
this.m_rB = b2Mul_r_v2(qB, b2Vec2.Subtract(this.m_localAnchorB, this.m_localCenterB));
var mA = this.m_invMassA,
mB = this.m_invMassB;
var iA = this.m_invIA,
iB = this.m_invIB;
var fixedRotation = (iA + iB == 0);
this.m_mass.ex.x = mA + mB + this.m_rA.y * this.m_rA.y * iA + this.m_rB.y * this.m_rB.y * iB;
this.m_mass.ey.x = -this.m_rA.y * this.m_rA.x * iA - this.m_rB.y * this.m_rB.x * iB;
this.m_mass.ez.x = -this.m_rA.y * iA - this.m_rB.y * iB;
this.m_mass.ex.y = this.m_mass.ey.x;
this.m_mass.ey.y = mA + mB + this.m_rA.x * this.m_rA.x * iA + this.m_rB.x * this.m_rB.x * iB;
this.m_mass.ez.y = this.m_rA.x * iA + this.m_rB.x * iB;
this.m_mass.ex.z = this.m_mass.ez.x;
this.m_mass.ey.z = this.m_mass.ez.y;
this.m_mass.ez.z = iA + iB;
this.m_motorMass = iA + iB;
if (this.m_motorMass > 0) {
this.m_motorMass = 1 / this.m_motorMass
}
if (this.m_enableMotor == false || fixedRotation) {
this.m_motorImpulse = 0
}
if (this.m_enableLimit && fixedRotation == false) {
var jointAngle = aB - aA - this.m_referenceAngle;
if (b2Abs(this.m_upperAngle - this.m_lowerAngle) < 2 * b2_angularSlop) {
this.m_limitState = b2Joint.e_equalLimits
} else {
if (jointAngle <= this.m_lowerAngle) {
if (this.m_limitState != b2Joint.e_atLowerLimit) {
this.m_impulse.z = 0
}
this.m_limitState = b2Joint.e_atLowerLimit
} else {
if (jointAngle >= this.m_upperAngle) {
if (this.m_limitState != b2Joint.e_atUpperLimit) {
this.m_impulse.z = 0
}
this.m_limitState = b2Joint.e_atUpperLimit
} else {
this.m_limitState = b2Joint.e_inactiveLimit;
this.m_impulse.z = 0
}
}
}
} else {
this.m_limitState = b2Joint.e_inactiveLimit
}
if (data.step.warmStarting) {
this.m_impulse.Multiply(data.step.dtRatio);
this.m_motorImpulse *= data.step.dtRatio;
var P = new b2Vec2(this.m_impulse.x, this.m_impulse.y);
vA.Subtract(b2Vec2.Multiply(mA, P));
wA -= iA * (b2Cross_v2_v2(this.m_rA, P) + this.m_motorImpulse + this.m_impulse.z);
vB.Add(b2Vec2.Multiply(mB, P));
wB += iB * (b2Cross_v2_v2(this.m_rB, P) + this.m_motorImpulse + this.m_impulse.z)
} else {
this.m_impulse.SetZero();
this.m_motorImpulse = 0
}
data.velocities[this.m_indexA].v.Assign(vA);
data.velocities[this.m_indexA].w = wA;
data.velocities[this.m_indexB].v.Assign(vB);
data.velocities[this.m_indexB].w = wB
},
SolveVelocityConstraints: function (data) {
var vA = data.velocities[this.m_indexA].v.Clone();
var wA = data.velocities[this.m_indexA].w;
var vB = data.velocities[this.m_indexB].v.Clone();
var wB = data.velocities[this.m_indexB].w;
var mA = this.m_invMassA,
mB = this.m_invMassB;
var iA = this.m_invIA,
iB = this.m_invIB;
var fixedRotation = (iA + iB == 0);
if (this.m_enableMotor && this.m_limitState != b2Joint.e_equalLimits && fixedRotation == false) {
var Cdot = wB - wA - this.m_motorSpeed;
var impulse = -this.m_motorMass * Cdot;
var oldImpulse = this.m_motorImpulse;
var maxImpulse = data.step.dt * this.m_maxMotorTorque;
this.m_motorImpulse = b2Clamp(this.m_motorImpulse + impulse, -maxImpulse, maxImpulse);
impulse = this.m_motorImpulse - oldImpulse;
wA -= iA * impulse;
wB += iB * impulse
}
if (this.m_enableLimit && this.m_limitState != b2Joint.e_inactiveLimit && fixedRotation == false) {
var Cdot1 = b2Vec2.Subtract(b2Vec2.Subtract(b2Vec2.Add(vB, b2Cross_f_v2(wB, this.m_rB)), vA), b2Cross_f_v2(wA, this.m_rA));
var Cdot2 = wB - wA;
var Cdot = new b2Vec3(Cdot1.x, Cdot1.y, Cdot2);
var impulse = this.m_mass.Solve33(Cdot).Negate();
if (this.m_limitState == b2Joint.e_equalLimits) {
this.m_impulse.Add(impulse)
} else {
if (this.m_limitState == b2Joint.e_atLowerLimit) {
var newImpulse = this.m_impulse.z + impulse.z;
if (newImpulse < 0) {
var rhs = b2Vec2.Add(Cdot1.Negate(), b2Vec2.Multiply(this.m_impulse.z, new b2Vec2(this.m_mass.ez.x, this.m_mass.ez.y)));
var reduced = this.m_mass.Solve22(rhs);
impulse.x = reduced.x;
impulse.y = reduced.y;
impulse.z = -this.m_impulse.z;
this.m_impulse.x += reduced.x;
this.m_impulse.y += reduced.y;
this.m_impulse.z = 0
} else {
this.m_impulse.Add(impulse)
}
} else {
if (this.m_limitState == b2Joint.e_atUpperLimit) {
var newImpulse = this.m_impulse.z + impulse.z;
if (newImpulse > 0) {
var rhs = b2Vec2.Add(Cdot1.Negate(), b2Vec2.Multiply(this.m_impulse.z, new b2Vec2(this.m_mass.ez.x, this.m_mass.ez.y)));
var reduced = this.m_mass.Solve22(rhs);
impulse.x = reduced.x;
impulse.y = reduced.y;
impulse.z = -this.m_impulse.z;
this.m_impulse.x += reduced.x;
this.m_impulse.y += reduced.y;
this.m_impulse.z = 0
} else {
this.m_impulse.Add(impulse)
}
}
}
}
var P = new b2Vec2(impulse.x, impulse.y);
vA.Subtract(b2Vec2.Multiply(mA, P));
wA -= iA * (b2Cross_v2_v2(this.m_rA, P) + impulse.z);
vB.Add(b2Vec2.Multiply(mB, P));
wB += iB * (b2Cross_v2_v2(this.m_rB, P) + impulse.z)
} else {
var Cdot = b2Vec2.Subtract(b2Vec2.Subtract(b2Vec2.Add(vB, b2Cross_f_v2(wB, this.m_rB)), vA), b2Cross_f_v2(wA, this.m_rA));
var impulse = this.m_mass.Solve22(Cdot.Negate());
this.m_impulse.x += impulse.x;
this.m_impulse.y += impulse.y;
vA.Subtract(b2Vec2.Multiply(mA, impulse));
wA -= iA * b2Cross_v2_v2(this.m_rA, impulse);
vB.Add(b2Vec2.Multiply(mB, impulse));
wB += iB * b2Cross_v2_v2(this.m_rB, impulse)
}
data.velocities[this.m_indexA].v.Assign(vA);
data.velocities[this.m_indexA].w = wA;
data.velocities[this.m_indexB].v.Assign(vB);
data.velocities[this.m_indexB].w = wB
},
SolvePositionConstraints: function (data) {
var cA = data.positions[this.m_indexA].c.Clone();
var aA = data.positions[this.m_indexA].a;
var cB = data.positions[this.m_indexB].c.Clone();
var aB = data.positions[this.m_indexB].a;
var qA = new b2Rot(aA),
qB = new b2Rot(aB);
var angularError = 0;
var positionError = 0;
var fixedRotation = (this.m_invIA + this.m_invIB == 0);
if (this.m_enableLimit && this.m_limitState != b2Joint.e_inactiveLimit && fixedRotation == false) {
var angle = aB - aA - this.m_referenceAngle;
var limitImpulse = 0;
if (this.m_limitState == b2Joint.e_equalLimits) {
var C = b2Clamp(angle - this.m_lowerAngle, -b2_maxAngularCorrection, b2_maxAngularCorrection);
limitImpulse = -this.m_motorMass * C;
angularError = b2Abs(C)
} else {
if (this.m_limitState == b2Joint.e_atLowerLimit) {
var C = angle - this.m_lowerAngle;
angularError = -C;
C = b2Clamp(C + b2_angularSlop, -b2_maxAngularCorrection, 0);
limitImpulse = -this.m_motorMass * C
} else {
if (this.m_limitState == b2Joint.e_atUpperLimit) {
var C = angle - this.m_upperAngle;
angularError = C;
C = b2Clamp(C - b2_angularSlop, 0, b2_maxAngularCorrection);
limitImpulse = -this.m_motorMass * C
}
}
}
aA -= this.m_invIA * limitImpulse;
aB += this.m_invIB * limitImpulse
}
qA.Set(aA);
qB.Set(aB);
var rA = b2Mul_r_v2(qA, b2Vec2.Subtract(this.m_localAnchorA, this.m_localCenterA));
var rB = b2Mul_r_v2(qB, b2Vec2.Subtract(this.m_localAnchorB, this.m_localCenterB));
var C = b2Vec2.Subtract(b2Vec2.Subtract(b2Vec2.Add(cB, rB), cA), rA);
positionError = C.Length();
var mA = this.m_invMassA,
mB = this.m_invMassB;
var iA = this.m_invIA,
iB = this.m_invIB;
var K = new b2Mat22();
K.ex.x = mA + mB + iA * rA.y * rA.y + iB * rB.y * rB.y;
K.ex.y = -iA * rA.x * rA.y - iB * rB.x * rB.y;
K.ey.x = K.ex.y;
K.ey.y = mA + mB + iA * rA.x * rA.x + iB * rB.x * rB.x;
var impulse = K.Solve(C).Negate();
cA.Subtract(b2Vec2.Multiply(mA, impulse));
aA -= iA * b2Cross_v2_v2(rA, impulse);
cB.Add(b2Vec2.Multiply(mB, impulse));
aB += iB * b2Cross_v2_v2(rB, impulse);
data.positions[this.m_indexA].c.Assign(cA);
data.positions[this.m_indexA].a = aA;
data.positions[this.m_indexB].c.Assign(cB);
data.positions[this.m_indexB].a = aB;
return positionError <= b2_linearSlop && angularError <= b2_angularSlop
},
_serialize: function (out) {
var obj = out || {};
this.parent.prototype._serialize.call(this, obj);
obj.localAnchorA = this.m_localAnchorA._serialize();
obj.localAnchorB = this.m_localAnchorB._serialize();
obj.referenceAngle = this.m_referenceAngle;
obj.lowerAngle = this.m_lowerAngle;
obj.upperAngle = this.m_upperAngle;
obj.maxMotorTorque = this.m_maxMotorTorque;
obj.motorSpeed = this.m_motorSpeed;
obj.enableLimit = this.m_enableLimit;
obj.enableMotor = this.m_enableMotor;
return obj
}
};
b2RevoluteJoint._extend(b2Joint);
function b2MouseJointDef() {
this.parent.call(this);
this.type = b2Joint.e_mouseJoint;
this.target = new b2Vec2(0, 0);
this.maxForce = 0;
this.frequencyHz = 5;
this.dampingRatio = 0.7;
Object.seal(this)
}
b2MouseJointDef._extend(b2JointDef);
function b2MouseJoint(def) {
this.parent.call(this, def);
this.m_targetA = def.target.Clone();
this.m_localAnchorB = b2MulT_t_v2(this.m_bodyB.GetTransform(), this.m_targetA);
this.m_maxForce = def.maxForce;
this.m_impulse = new b2Vec2();
this.m_frequencyHz = def.frequencyHz;
this.m_dampingRatio = def.dampingRatio;
this.m_beta = 0;
this.m_gamma = 0;
this.m_indexA = 0;
this.m_indexB = 0;
this.m_rB = new b2Vec2();
this.m_localCenterB = new b2Vec2();
this.m_invMassB = 0;
this.m_invIB = 0;
this.m_mass = new b2Mat22();
this.m_C = new b2Vec2()
}
b2MouseJoint.prototype = {
GetAnchorA: function () {
return this.m_targetA
},
GetAnchorB: function () {
return this.m_bodyB.GetWorldPoint(this.m_localAnchorB)
},
GetReactionForce: function (inv_dt) {
return b2Vec2.Multiply(inv_dt, this.m_impulse)
},
GetReactionTorque: function (inv_dt) {
return inv_dt * 0
},
SetTarget: function (target) {
if (this.m_bodyB.IsAwake() == false) {
this.m_bodyB.SetAwake(true)
}
this.m_targetA.Assign(target)
},
GetTarget: function () {
return this.m_targetA
},
SetMaxForce: function (force) {
this.m_maxForce = force
},
GetMaxForce: function () {
return this.m_maxForce
},
SetFrequency: function (hz) {
this.m_frequencyHz = hz
},
GetFrequency: function () {
return this.m_frequencyHz
},
SetDampingRatio: function (ratio) {
this.m_dampingRatio = ratio
},
GetDampingRatio: function () {
return this.m_dampingRatio
},
ShiftOrigin: function (newOrigin) {
this.m_targetA.Subtract(newOrigin)
},
InitVelocityConstraints: function (data) {
this.m_indexB = this.m_bodyB.m_islandIndex;
this.m_localCenterB.Assign(this.m_bodyB.m_sweep.localCenter);
this.m_invMassB = this.m_bodyB.m_invMass;
this.m_invIB = this.m_bodyB.m_invI;
var cB = data.positions[this.m_indexB].c.Clone();
var aB = data.positions[this.m_indexB].a;
var vB = data.velocities[this.m_indexB].v.Clone();
var wB = data.velocities[this.m_indexB].w;
var qB = new b2Rot(aB);
var mass = this.m_bodyB.GetMass();
var omega = 2 * b2_pi * this.m_frequencyHz;
var d = 2 * mass * this.m_dampingRatio * omega;
var k = mass * (omega * omega);
var h = data.step.dt;
this.m_gamma = h * (d + h * k);
if (this.m_gamma != 0) {
this.m_gamma = 1 / this.m_gamma
}
this.m_beta = h * k * this.m_gamma;
this.m_rB.Assign(b2Mul_r_v2(qB, b2Vec2.Subtract(this.m_localAnchorB, this.m_localCenterB)));
var K = new b2Mat22();
K.ex.x = this.m_invMassB + this.m_invIB * this.m_rB.y * this.m_rB.y + this.m_gamma;
K.ex.y = -this.m_invIB * this.m_rB.x * this.m_rB.y;
K.ey.x = K.ex.y;
K.ey.y = this.m_invMassB + this.m_invIB * this.m_rB.x * this.m_rB.x + this.m_gamma;
this.m_mass.Assign(K.GetInverse());
this.m_C.Assign(b2Vec2.Subtract(b2Vec2.Add(cB, this.m_rB), this.m_targetA));
this.m_C.Multiply(this.m_beta);
wB *= 0.98;
if (data.step.warmStarting) {
this.m_impulse.Multiply(data.step.dtRatio);
vB.Add(b2Vec2.Multiply(this.m_invMassB, this.m_impulse));
wB += this.m_invIB * b2Cross_v2_v2(this.m_rB, this.m_impulse)
} else {
this.m_impulse.SetZero()
}
data.velocities[this.m_indexB].v.Assign(vB);
data.velocities[this.m_indexB].w = wB
},
SolveVelocityConstraints: function (data) {
var vB = data.velocities[this.m_indexB].v.Clone();
var wB = data.velocities[this.m_indexB].w;
var Cdot = b2Vec2.Add(vB, b2Cross_f_v2(wB, this.m_rB));
var impulse = b2Mul_m22_v2(this.m_mass, (b2Vec2.Add(b2Vec2.Add(Cdot, this.m_C), b2Vec2.Multiply(this.m_gamma, this.m_impulse))).Negate());
var oldImpulse = this.m_impulse.Clone();
this.m_impulse.Add(impulse);
var maxImpulse = data.step.dt * this.m_maxForce;
if (this.m_impulse.LengthSquared() > maxImpulse * maxImpulse) {
this.m_impulse.Multiply(maxImpulse / this.m_impulse.Length())
}
impulse.Assign(b2Vec2.Subtract(this.m_impulse, oldImpulse));
vB.Add(b2Vec2.Multiply(this.m_invMassB, impulse));
wB += this.m_invIB * b2Cross_v2_v2(this.m_rB, impulse);
data.velocities[this.m_indexB].v.Assign(vB);
data.velocities[this.m_indexB].w = wB
},
SolvePositionConstraints: function (data) {
return true
}
};
b2MouseJoint._extend(b2Joint);
function b2DistanceJointDef() {
this.parent.call(this);
this.type = b2Joint.e_distanceJoint;
this.localAnchorA = new b2Vec2(0, 0);
this.localAnchorB = new b2Vec2(0, 0);
this.length = 1;
this.frequencyHz = 0;
this.dampingRatio = 0;
Object.seal(this)
}
b2DistanceJointDef.prototype = {
Initialize: function (b1, b2, anchor1, anchor2) {
this.bodyA = b1;
this.bodyB = b2;
this.localAnchorA = this.bodyA.GetLocalPoint(anchor1);
this.localAnchorB = this.bodyB.GetLocalPoint(anchor2);
var d = b2Vec2.Subtract(anchor2, anchor1);
this.length = d.Length()
},
_deserialize: function (data, bodies, joints) {
this.parent.prototype._deserialize.call(this, data, bodies, joints);
this.localAnchorA._deserialize(data.localAnchorA);
this.localAnchorB._deserialize(data.localAnchorB);
this.length = data.length;
this.frequencyHz = data.frequencyHz;
this.dampingRatio = data.dampingRatio
}
};
b2DistanceJointDef._extend(b2JointDef);
function b2DistanceJoint(def) {
this.parent.call(this, def);
this.m_localAnchorA = def.localAnchorA.Clone();
this.m_localAnchorB = def.localAnchorB.Clone();
this.m_length = def.length;
this.m_frequencyHz = def.frequencyHz;
this.m_dampingRatio = def.dampingRatio;
this.m_impulse = 0;
this.m_gamma = 0;
this.m_bias = 0;
this.m_indexA = 0;
this.m_indexB = 0;
this.m_u = new b2Vec2();
this.m_rA = new b2Vec2();
this.m_rB = new b2Vec2();
this.m_localCenterA = new b2Vec2();
this.m_localCenterB = new b2Vec2();
this.m_invMassA = 0;
this.m_invMassB = 0;
this.m_invIA = 0;
this.m_invIB = 0;
this.m_mass = 0
}
b2DistanceJoint.prototype = {
GetAnchorA: function () {
return this.m_bodyA.GetWorldPoint(this.m_localAnchorA)
},
GetAnchorB: function () {
return this.m_bodyB.GetWorldPoint(this.m_localAnchorB)
},
GetReactionForce: function (inv_dt) {
var F = b2Vec2.Multiply((inv_dt * this.m_impulse), this.m_u);
return F
},
GetReactionTorque: function (inv_dt) {
return 0
},
GetLocalAnchorA: function () {
return this.m_localAnchorA
},
GetLocalAnchorB: function () {
return this.m_localAnchorB
},
SetLength: function (length) {
this.m_length = length
},
GetLength: function () {
return this.m_length
},
SetFrequency: function (hz) {
this.m_frequencyHz = hz
},
GetFrequency: function () {
return this.m_frequencyHz
},
SetDampingRatio: function (ratio) {
this.m_dampingRatio = ratio
},
GetDampingRatio: function () {
return this.m_dampingRatio
},
InitVelocityConstraints: function (data) {
this.m_indexA = this.m_bodyA.m_islandIndex;
this.m_indexB = this.m_bodyB.m_islandIndex;
this.m_localCenterA.Assign(this.m_bodyA.m_sweep.localCenter);
this.m_localCenterB.Assign(this.m_bodyB.m_sweep.localCenter);
this.m_invMassA = this.m_bodyA.m_invMass;
this.m_invMassB = this.m_bodyB.m_invMass;
this.m_invIA = this.m_bodyA.m_invI;
this.m_invIB = this.m_bodyB.m_invI;
var cA = data.positions[this.m_indexA].c.Clone();
var aA = data.positions[this.m_indexA].a;
var vA = data.velocities[this.m_indexA].v.Clone();
var wA = data.velocities[this.m_indexA].w;
var cB = data.positions[this.m_indexB].c.Clone();
var aB = data.positions[this.m_indexB].a;
var vB = data.velocities[this.m_indexB].v.Clone();
var wB = data.velocities[this.m_indexB].w;
var qA = new b2Rot(aA),
qB = new b2Rot(aB);
this.m_rA = b2Mul_r_v2(qA, b2Vec2.Subtract(this.m_localAnchorA, this.m_localCenterA));
this.m_rB = b2Mul_r_v2(qB, b2Vec2.Subtract(this.m_localAnchorB, this.m_localCenterB));
this.m_u = b2Vec2.Subtract(b2Vec2.Subtract(b2Vec2.Add(cB, this.m_rB), cA), this.m_rA);
var length = this.m_u.Length();
if (length > b2_linearSlop) {
this.m_u.Multiply(1 / length)
} else {
this.m_u.Set(0, 0)
}
var crAu = b2Cross_v2_v2(this.m_rA, this.m_u);
var crBu = b2Cross_v2_v2(this.m_rB, this.m_u);
var invMass = this.m_invMassA + this.m_invIA * crAu * crAu + this.m_invMassB + this.m_invIB * crBu * crBu;
this.m_mass = invMass != 0 ? 1 / invMass : 0;
if (this.m_frequencyHz > 0) {
var C = length - this.m_length;
var omega = 2 * b2_pi * this.m_frequencyHz;
var d = 2 * this.m_mass * this.m_dampingRatio * omega;
var k = this.m_mass * omega * omega;
var h = data.step.dt;
this.m_gamma = h * (d + h * k);
this.m_gamma = this.m_gamma != 0 ? 1 / this.m_gamma : 0;
this.m_bias = C * h * k * this.m_gamma;
invMass += this.m_gamma;
this.m_mass = invMass != 0 ? 1 / invMass : 0
} else {
this.m_gamma = 0;
this.m_bias = 0
}
if (data.step.warmStarting) {
this.m_impulse *= data.step.dtRatio;
var P = b2Vec2.Multiply(this.m_impulse, this.m_u);
vA.Subtract(b2Vec2.Multiply(this.m_invMassA, P));
wA -= this.m_invIA * b2Cross_v2_v2(this.m_rA, P);
vB.Add(b2Vec2.Multiply(this.m_invMassB, P));
wB += this.m_invIB * b2Cross_v2_v2(this.m_rB, P)
} else {
this.m_impulse = 0
}
data.velocities[this.m_indexA].v.Assign(vA);
data.velocities[this.m_indexA].w = wA;
data.velocities[this.m_indexB].v.Assign(vB);
data.velocities[this.m_indexB].w = wB
},
SolveVelocityConstraints: function (data) {
var vA = data.velocities[this.m_indexA].v.Clone();
var wA = data.velocities[this.m_indexA].w;
var vB = data.velocities[this.m_indexB].v.Clone();
var wB = data.velocities[this.m_indexB].w;
var vpA = b2Vec2.Add(vA, b2Cross_f_v2(wA, this.m_rA));
var vpB = b2Vec2.Add(vB, b2Cross_f_v2(wB, this.m_rB));
var Cdot = b2Dot_v2_v2(this.m_u, b2Vec2.Subtract(vpB, vpA));
var impulse = -this.m_mass * (Cdot + this.m_bias + this.m_gamma * this.m_impulse);
this.m_impulse += impulse;
var P = b2Vec2.Multiply(impulse, this.m_u);
vA.Subtract(b2Vec2.Multiply(this.m_invMassA, P));
wA -= this.m_invIA * b2Cross_v2_v2(this.m_rA, P);
vB.Add(b2Vec2.Multiply(this.m_invMassB, P));
wB += this.m_invIB * b2Cross_v2_v2(this.m_rB, P);
data.velocities[this.m_indexA].v.Assign(vA);
data.velocities[this.m_indexA].w = wA;
data.velocities[this.m_indexB].v.Assign(vB);
data.velocities[this.m_indexB].w = wB
},
SolvePositionConstraints: function (data) {
if (this.m_frequencyHz > 0) {
return true
}
var cA = data.positions[this.m_indexA].c.Clone();
var aA = data.positions[this.m_indexA].a;
var cB = data.positions[this.m_indexB].c.Clone();
var aB = data.positions[this.m_indexB].a;
var qA = new b2Rot(aA),
qB = new b2Rot(aB);
var rA = b2Mul_r_v2(qA, b2Vec2.Subtract(this.m_localAnchorA, this.m_localCenterA));
var rB = b2Mul_r_v2(qB, b2Vec2.Subtract(this.m_localAnchorB, this.m_localCenterB));
var u = b2Vec2.Subtract(b2Vec2.Subtract(b2Vec2.Add(cB, rB), cA), rA);
var length = u.Normalize();
var C = length - this.m_length;
C = b2Clamp(C, -b2_maxLinearCorrection, b2_maxLinearCorrection);
var impulse = -this.m_mass * C;
var P = b2Vec2.Multiply(impulse, u);
cA.Subtract(b2Vec2.Multiply(this.m_invMassA, P));
aA -= this.m_invIA * b2Cross_v2_v2(rA, P);
cB.Add(b2Vec2.Multiply(this.m_invMassB, P));
aB += this.m_invIB * b2Cross_v2_v2(rB, P);
data.positions[this.m_indexA].c.Assign(cA);
data.positions[this.m_indexA].a = aA;
data.positions[this.m_indexB].c.Assign(cB);
data.positions[this.m_indexB].a = aB;
return b2Abs(C) < b2_linearSlop
},
_serialize: function (out) {
var obj = out || {};
this.parent.prototype._serialize.call(this, obj);
obj.localAnchorA = this.m_localAnchorA._serialize();
obj.localAnchorB = this.m_localAnchorB._serialize();
obj.length = this.m_length;
obj.frequencyHz = this.m_frequencyHz;
obj.dampingRatio = this.m_dampingRatio;
return obj
}
};
b2DistanceJoint._extend(b2Joint);
function b2PrismaticJointDef() {
this.parent.call(this);
this.type = b2Joint.e_prismaticJoint;
this.localAnchorA = new b2Vec2();
this.localAnchorB = new b2Vec2();
this.localAxisA = new b2Vec2(1, 0);
this.referenceAngle = 0;
this.enableLimit = false;
this.lowerTranslation = 0;
this.upperTranslation = 0;
this.enableMotor = false;
this.maxMotorForce = 0;
this.motorSpeed = 0;
Object.seal(this)
}
b2PrismaticJointDef.prototype = {
Initialize: function (bA, bB, anchor, axis) {
this.bodyA = bA;
this.bodyB = bB;
this.localAnchorA = this.bodyA.GetLocalPoint(anchor);
this.localAnchorB = this.bodyB.GetLocalPoint(anchor);
this.localAxisA = this.bodyA.GetLocalVector(axis);
this.referenceAngle = this.bodyB.GetAngle() - this.bodyA.GetAngle()
},
_deserialize: function (data, bodies, joints) {
this.parent.prototype._deserialize.call(this, data, bodies, joints);
this.localAnchorA._deserialize(data.localAnchorA);
this.localAnchorB._deserialize(data.localAnchorB);
this.localAxisA._deserialize(data.localAxisA);
this.referenceAngle = data.referenceAngle;
this.enableLimit = data.enableLimit;
this.lowerTranslation = data.lowerTranslation;
this.upperTranslation = data.upperTranslation;
this.enableMotor = data.enableMotor;
this.maxMotorForce = data.maxMotorForce;
this.motorSpeed = data.motorSpeed
}
};
b2PrismaticJointDef._extend(b2JointDef);
function b2PrismaticJoint(def) {
this.parent.call(this, def);
this.m_localAnchorA = def.localAnchorA.Clone();
this.m_localAnchorB = def.localAnchorB.Clone();
this.m_localXAxisA = def.localAxisA.Clone();
this.m_localXAxisA.Normalize();
this.m_localYAxisA = b2Cross_f_v2(1, this.m_localXAxisA);
this.m_referenceAngle = def.referenceAngle;
this.m_impulse = new b2Vec3();
this.m_motorMass = 0;
this.m_motorImpulse = 0;
this.m_lowerTranslation = def.lowerTranslation;
this.m_upperTranslation = def.upperTranslation;
this.m_maxMotorForce = def.maxMotorForce;
this.m_motorSpeed = def.motorSpeed;
this.m_enableLimit = def.enableLimit;
this.m_enableMotor = def.enableMotor;
this.m_limitState = b2Joint.e_inactiveLimit;
this.m_axis = new b2Vec2();
this.m_perp = new b2Vec2();
this.m_indexA = 0;
this.m_indexB = 0;
this.m_localCenterA = new b2Vec2();
this.m_localCenterB = new b2Vec2();
this.m_invMassA = 0;
this.m_invMassB = 0;
this.m_invIA = 0;
this.m_invIB = 0;
this.m_s1 = 0, this.m_s2 = 0;
this.m_a1 = 0, this.m_a2 = 0;
this.m_K = new b2Mat33();
this.m_motorMass = 0
}
b2PrismaticJoint.prototype = {
GetAnchorA: function () {
return this.m_bodyA.GetWorldPoint(this.m_localAnchorA)
},
GetAnchorB: function () {
return this.m_bodyB.GetWorldPoint(this.m_localAnchorB)
},
GetReactionForce: function (inv_dt) {
return b2Vec2.Multiply(inv_dt, b2Vec2.Add(b2Vec2.Multiply(this.m_impulse.x, this.m_perp), b2Vec2.Multiply((this.m_motorImpulse + this.m_impulse.z), this.m_axis)))
},
GetReactionTorque: function (inv_dt) {
return inv_dt * this.m_impulse.y
},
GetLocalAnchorA: function () {
return this.m_localAnchorA
},
GetLocalAnchorB: function () {
return this.m_localAnchorB
},
GetLocalAxisA: function () {
return this.m_localXAxisA
},
GetReferenceAngle: function () {
return this.m_referenceAngle
},
GetJointTranslation: function () {
var pA = this.m_bodyA.GetWorldPoint(this.m_localAnchorA);
var pB = this.m_bodyB.GetWorldPoint(this.m_localAnchorB);
var d = b2Vec2.Subtract(pB, pA);
var axis = this.m_bodyA.GetWorldVector(this.m_localXAxisA);
var translation = b2Dot_v2_v2(d, axis);
return translation
},
GetJointSpeed: function () {
var bA = this.m_bodyA;
var bB = this.m_bodyB;
var rA = b2Mul_r_v2(bA.m_xf.q, b2Vec2.Subtract(this.m_localAnchorA, bA.m_sweep.localCenter));
var rB = b2Mul_r_v2(bB.m_xf.q, b2Vec2.Subtract(this.m_localAnchorB, bB.m_sweep.localCenter));
var p1 = b2Vec2.Add(bA.m_sweep.c, rA);
var p2 = b2Vec2.Add(bB.m_sweep.c, rB);
var d = b2Vec2.Subtract(p2, p1);
var axis = b2Mul_r_v2(bA.m_xf.q, this.m_localXAxisA);
var vA = bA.m_linearVelocity;
var vB = bB.m_linearVelocity;
var wA = bA.m_angularVelocity;
var wB = bB.m_angularVelocity;
var speed = b2Dot_v2_v2(d, b2Cross_f_v2(wA, axis)) + b2Dot_v2_v2(axis, b2Vec2.Subtract(b2Vec2.Subtract(b2Vec2.Add(vB, b2Cross_f_v2(wB, rB)), vA), b2Cross_f_v2(wA, rA)));
return speed
},
IsLimitEnabled: function () {
return this.m_enableLimit
},
EnableLimit: function (flag) {
if (flag != this.m_enableLimit) {
this.m_bodyA.SetAwake(true);
this.m_bodyB.SetAwake(true);
this.m_enableLimit = flag;
this.m_impulse.z = 0
}
},
GetLowerLimit: function () {
return this.m_lowerTranslation
},
GetUpperLimit: function () {
return this.m_upperTranslation
},
SetLimits: function (lower, upper) {
if (lower != this.m_lowerTranslation || upper != this.m_upperTranslation) {
this.m_bodyA.SetAwake(true);
this.m_bodyB.SetAwake(true);
this.m_lowerTranslation = lower;
this.m_upperTranslation = upper;
this.m_impulse.z = 0
}
},
IsMotorEnabled: function () {
return this.m_enableMotor
},
EnableMotor: function (flag) {
this.m_bodyA.SetAwake(true);
this.m_bodyB.SetAwake(true);
this.m_enableMotor = flag
},
SetMotorSpeed: function (speed) {
this.m_bodyA.SetAwake(true);
this.m_bodyB.SetAwake(true);
this.m_motorSpeed = speed
},
GetMotorSpeed: function () {
return this.m_motorSpeed
},
SetMaxMotorForce: function (force) {
this.m_bodyA.SetAwake(true);
this.m_bodyB.SetAwake(true);
this.m_maxMotorForce = force
},
GetMaxMotorForce: function () {
return this.m_maxMotorForce
},
GetMotorForce: function (inv_dt) {
return inv_dt * this.m_motorImpulse
},
InitVelocityConstraints: function (data) {
this.m_indexA = this.m_bodyA.m_islandIndex;
this.m_indexB = this.m_bodyB.m_islandIndex;
this.m_localCenterA = this.m_bodyA.m_sweep.localCenter;
this.m_localCenterB = this.m_bodyB.m_sweep.localCenter;
this.m_invMassA = this.m_bodyA.m_invMass;
this.m_invMassB = this.m_bodyB.m_invMass;
this.m_invIA = this.m_bodyA.m_invI;
this.m_invIB = this.m_bodyB.m_invI;
var cA = data.positions[this.m_indexA].c.Clone();
var aA = data.positions[this.m_indexA].a;
var vA = data.velocities[this.m_indexA].v.Clone();
var wA = data.velocities[this.m_indexA].w;
var cB = data.positions[this.m_indexB].c.Clone();
var aB = data.positions[this.m_indexB].a;
var vB = data.velocities[this.m_indexB].v.Clone();
var wB = data.velocities[this.m_indexB].w;
var qA = new b2Rot(aA),
qB = new b2Rot(aB);
var rA = b2Mul_r_v2(qA, b2Vec2.Subtract(this.m_localAnchorA, this.m_localCenterA));
var rB = b2Mul_r_v2(qB, b2Vec2.Subtract(this.m_localAnchorB, this.m_localCenterB));
var d = b2Vec2.Add(b2Vec2.Subtract(cB, cA), b2Vec2.Subtract(rB, rA));
var mA = this.m_invMassA,
mB = this.m_invMassB;
var iA = this.m_invIA,
iB = this.m_invIB;
this.m_axis = b2Mul_r_v2(qA, this.m_localXAxisA);
this.m_a1 = b2Cross_v2_v2(b2Vec2.Add(d, rA), this.m_axis);
this.m_a2 = b2Cross_v2_v2(rB, this.m_axis);
this.m_motorMass = mA + mB + iA * this.m_a1 * this.m_a1 + iB * this.m_a2 * this.m_a2;
if (this.m_motorMass > 0) {
this.m_motorMass = 1 / this.m_motorMass
}
this.m_perp = b2Mul_r_v2(qA, this.m_localYAxisA);
this.m_s1 = b2Cross_v2_v2(b2Vec2.Add(d, rA), this.m_perp);
this.m_s2 = b2Cross_v2_v2(rB, this.m_perp);
var k11 = mA + mB + iA * this.m_s1 * this.m_s1 + iB * this.m_s2 * this.m_s2;
var k12 = iA * this.m_s1 + iB * this.m_s2;
var k13 = iA * this.m_s1 * this.m_a1 + iB * this.m_s2 * this.m_a2;
var k22 = iA + iB;
if (k22 == 0) {
k22 = 1
}
var k23 = iA * this.m_a1 + iB * this.m_a2;
var k33 = mA + mB + iA * this.m_a1 * this.m_a1 + iB * this.m_a2 * this.m_a2;
this.m_K.ex.Set(k11, k12, k13);
this.m_K.ey.Set(k12, k22, k23);
this.m_K.ez.Set(k13, k23, k33);
if (this.m_enableLimit) {
var jointTranslation = b2Dot_v2_v2(this.m_axis, d);
if (b2Abs(this.m_upperTranslation - this.m_lowerTranslation) < 2 * b2_linearSlop) {
this.m_limitState = b2Joint.e_equalLimits
} else {
if (jointTranslation <= this.m_lowerTranslation) {
if (this.m_limitState != b2Joint.e_atLowerLimit) {
this.m_limitState = b2Joint.e_atLowerLimit;
this.m_impulse.z = 0
}
} else {
if (jointTranslation >= this.m_upperTranslation) {
if (this.m_limitState != b2Joint.e_atUpperLimit) {
this.m_limitState = b2Joint.e_atUpperLimit;
this.m_impulse.z = 0
}
} else {
this.m_limitState = b2Joint.e_inactiveLimit;
this.m_impulse.z = 0
}
}
}
} else {
this.m_limitState = b2Joint.e_inactiveLimit;
this.m_impulse.z = 0
}
if (this.m_enableMotor == false) {
this.m_motorImpulse = 0
}
if (data.step.warmStarting) {
this.m_impulse.Multiply(data.step.dtRatio);
this.m_motorImpulse *= data.step.dtRatio;
var P = b2Vec2.Add(b2Vec2.Multiply(this.m_impulse.x, this.m_perp), b2Vec2.Multiply((this.m_motorImpulse + this.m_impulse.z), this.m_axis));
var LA = this.m_impulse.x * this.m_s1 + this.m_impulse.y + (this.m_motorImpulse + this.m_impulse.z) * this.m_a1;
var LB = this.m_impulse.x * this.m_s2 + this.m_impulse.y + (this.m_motorImpulse + this.m_impulse.z) * this.m_a2;
vA.Subtract(b2Vec2.Multiply(mA, P));
wA -= iA * LA;
vB.Add(b2Vec2.Multiply(mB, P));
wB += iB * LB
} else {
this.m_impulse.SetZero();
this.m_motorImpulse = 0
}
data.velocities[this.m_indexA].v.Assign(vA);
data.velocities[this.m_indexA].w = wA;
data.velocities[this.m_indexB].v.Assign(vB);
data.velocities[this.m_indexB].w = wB
},
SolveVelocityConstraints: function (data) {
var vA = data.velocities[this.m_indexA].v.Clone();
var wA = data.velocities[this.m_indexA].w;
var vB = data.velocities[this.m_indexB].v.Clone();
var wB = data.velocities[this.m_indexB].w;
var mA = this.m_invMassA,
mB = this.m_invMassB;
var iA = this.m_invIA,
iB = this.m_invIB;
if (this.m_enableMotor && this.m_limitState != b2Joint.e_equalLimits) {
var Cdot = b2Dot_v2_v2(this.m_axis, b2Vec2.Subtract(vB, vA)) + this.m_a2 * wB - this.m_a1 * wA;
var impulse = this.m_motorMass * (this.m_motorSpeed - Cdot);
var oldImpulse = this.m_motorImpulse;
var maxImpulse = data.step.dt * this.m_maxMotorForce;
this.m_motorImpulse = b2Clamp(this.m_motorImpulse + impulse, -maxImpulse, maxImpulse);
impulse = this.m_motorImpulse - oldImpulse;
var P = b2Vec2.Multiply(impulse, this.m_axis);
var LA = impulse * this.m_a1;
var LB = impulse * this.m_a2;
vA.Subtract(b2Vec2.Multiply(mA, P));
wA -= iA * LA;
vB.Add(b2Vec2.Multiply(mB, P));
wB += iB * LB
}
var Cdot1 = new b2Vec2();
Cdot1.x = b2Dot_v2_v2(this.m_perp, b2Vec2.Subtract(vB, vA)) + this.m_s2 * wB - this.m_s1 * wA;
Cdot1.y = wB - wA;
if (this.m_enableLimit && this.m_limitState != b2Joint.e_inactiveLimit) {
var Cdot2;
Cdot2 = b2Dot_v2_v2(this.m_axis, b2Vec2.Subtract(vB, vA)) + this.m_a2 * wB - this.m_a1 * wA;
var Cdot = new b2Vec3(Cdot1.x, Cdot1.y, Cdot2);
var f1 = this.m_impulse.Clone();
var df = this.m_K.Solve33(Cdot.Negate());
this.m_impulse.Add(df);
if (this.m_limitState == b2Joint.e_atLowerLimit) {
this.m_impulse.z = b2Max(this.m_impulse.z, 0)
} else {
if (this.m_limitState == b2Joint.e_atUpperLimit) {
this.m_impulse.z = b2Min(this.m_impulse.z, 0)
}
}
var b = b2Vec2.Subtract(Cdot1.Negate(), b2Vec2.Multiply((this.m_impulse.z - f1.z), new b2Vec2(this.m_K.ez.x, this.m_K.ez.y)));
var f2r = b2Vec2.Add(this.m_K.Solve22(b), new b2Vec2(f1.x, f1.y));
this.m_impulse.x = f2r.x;
this.m_impulse.y = f2r.y;
df = b2Vec3.Subtract(this.m_impulse, f1);
var P = b2Vec2.Add(b2Vec2.Multiply(df.x, this.m_perp), b2Vec2.Multiply(df.z, this.m_axis));
var LA = df.x * this.m_s1 + df.y + df.z * this.m_a1;
var LB = df.x * this.m_s2 + df.y + df.z * this.m_a2;
vA.Subtract(b2Vec2.Multiply(mA, P));
wA -= iA * LA;
vB.Add(b2Vec2.Multiply(mB, P));
wB += iB * LB
} else {
var df = this.m_K.Solve22(Cdot1.Negate());
this.m_impulse.x += df.x;
this.m_impulse.y += df.y;
var P = b2Vec2.Multiply(df.x, this.m_perp);
var LA = df.x * this.m_s1 + df.y;
var LB = df.x * this.m_s2 + df.y;
vA.Subtract(b2Vec2.Multiply(mA, P));
wA -= iA * LA;
vB.Add(b2Vec2.Multiply(mB, P));
wB += iB * LB
}
data.velocities[this.m_indexA].v.Assign(vA);
data.velocities[this.m_indexA].w = wA;
data.velocities[this.m_indexB].v.Assign(vB);
data.velocities[this.m_indexB].w = wB
},
SolvePositionConstraints: function (data) {
var cA = data.positions[this.m_indexA].c.Clone();
var aA = data.positions[this.m_indexA].a;
var cB = data.positions[this.m_indexB].c.Clone();
var aB = data.positions[this.m_indexB].a;
var qA = new b2Rot(aA),
qB = new b2Rot(aB);
var mA = this.m_invMassA,
mB = this.m_invMassB;
var iA = this.m_invIA,
iB = this.m_invIB;
var rA = b2Mul_r_v2(qA, b2Vec2.Subtract(this.m_localAnchorA, this.m_localCenterA));
var rB = b2Mul_r_v2(qB, b2Vec2.Subtract(this.m_localAnchorB, this.m_localCenterB));
var d = b2Vec2.Subtract(b2Vec2.Subtract(b2Vec2.Add(cB, rB), cA), rA);
var axis = b2Mul_r_v2(qA, this.m_localXAxisA);
var a1 = b2Cross_v2_v2(b2Vec2.Add(d, rA), axis);
var a2 = b2Cross_v2_v2(rB, axis);
var perp = b2Mul_r_v2(qA, this.m_localYAxisA);
var s1 = b2Cross_v2_v2(b2Vec2.Add(d, rA), perp);
var s2 = b2Cross_v2_v2(rB, perp);
var impulse = new b2Vec3();
var C1 = new b2Vec2();
C1.x = b2Dot_v2_v2(perp, d);
C1.y = aB - aA - this.m_referenceAngle;
var linearError = b2Abs(C1.x);
var angularError = b2Abs(C1.y);
var active = false;
var C2 = 0;
if (this.m_enableLimit) {
var translation = b2Dot_v2_v2(axis, d);
if (b2Abs(this.m_upperTranslation - this.m_lowerTranslation) < 2 * b2_linearSlop) {
C2 = b2Clamp(translation, -b2_maxLinearCorrection, b2_maxLinearCorrection);
linearError = b2Max(linearError, b2Abs(translation));
active = true
} else {
if (translation <= this.m_lowerTranslation) {
C2 = b2Clamp(translation - this.m_lowerTranslation + b2_linearSlop, -b2_maxLinearCorrection, 0);
linearError = b2Max(linearError, this.m_lowerTranslation - translation);
active = true
} else {
if (translation >= this.m_upperTranslation) {
C2 = b2Clamp(translation - this.m_upperTranslation - b2_linearSlop, 0, b2_maxLinearCorrection);
linearError = b2Max(linearError, translation - this.m_upperTranslation);
active = true
}
}
}
}
if (active) {
var k11 = mA + mB + iA * s1 * s1 + iB * s2 * s2;
var k12 = iA * s1 + iB * s2;
var k13 = iA * s1 * a1 + iB * s2 * a2;
var k22 = iA + iB;
if (k22 == 0) {
k22 = 1
}
var k23 = iA * a1 + iB * a2;
var k33 = mA + mB + iA * a1 * a1 + iB * a2 * a2;
var K = new b2Mat33();
K.ex.Set(k11, k12, k13);
K.ey.Set(k12, k22, k23);
K.ez.Set(k13, k23, k33);
var C = new b2Vec3();
C.x = C1.x;
C.y = C1.y;
C.z = C2;
impulse = K.Solve33(C.Negate())
} else {
var k11 = mA + mB + iA * s1 * s1 + iB * s2 * s2;
var k12 = iA * s1 + iB * s2;
var k22 = iA + iB;
if (k22 == 0) {
k22 = 1
}
var K = new b2Mat22();
K.ex.Set(k11, k12);
K.ey.Set(k12, k22);
var impulse1 = K.Solve(C1.Negate());
impulse.x = impulse1.x;
impulse.y = impulse1.y;
impulse.z = 0
}
var P = b2Vec2.Add(b2Vec2.Multiply(impulse.x, perp), b2Vec2.Multiply(impulse.z, axis));
var LA = impulse.x * s1 + impulse.y + impulse.z * a1;
var LB = impulse.x * s2 + impulse.y + impulse.z * a2;
cA.Subtract(b2Vec2.Multiply(mA, P));
aA -= iA * LA;
cB.Add(b2Vec2.Multiply(mB, P));
aB += iB * LB;
data.positions[this.m_indexA].c.Assign(cA);
data.positions[this.m_indexA].a = aA;
data.positions[this.m_indexB].c.Assign(cB);
data.positions[this.m_indexB].a = aB;
return linearError <= b2_linearSlop && angularError <= b2_angularSlop
},
_serialize: function (out) {
var obj = out || {};
this.parent.prototype._serialize.call(this, obj);
obj.localAnchorA = this.m_localAnchorA._serialize();
obj.localAnchorB = this.m_localAnchorB._serialize();
obj.localAxisA = this.m_localXAxisA._serialize();
obj.referenceAngle = this.m_referenceAngle;
obj.enableLimit = this.m_enableLimit;
obj.lowerTranslation = this.m_lowerTranslation;
obj.upperTranslation = this.m_upperTranslation;
obj.enableMotor = this.m_enableMotor;
obj.maxMotorForce = this.m_maxMotorForce;
obj.motorSpeed = this.m_motorSpeed;
return obj
}
};
b2PrismaticJoint._extend(b2Joint);
function b2FrictionJointDef() {
this.parent.call(this);
this.type = b2Joint.e_frictionJoint;
this.localAnchorA = new b2Vec2();
this.localAnchorB = new b2Vec2();
this.maxForce = 0;
this.maxTorque = 0;
Object.seal(this)
}
b2FrictionJointDef.prototype = {
Initialize: function (bA, bB, anchor) {
this.bodyA = bA;
this.bodyB = bB;
this.localAnchorA.Assign(this.bodyA.GetLocalPoint(anchor));
this.localAnchorB.Assign(this.bodyB.GetLocalPoint(anchor))
},
_deserialize: function (data, bodies, joints) {
this.parent.prototype._deserialize.call(this, data, bodies, joints);
this.localAnchorA._deserialize(data.localAnchorA);
this.localAnchorB._deserialize(data.localAnchorB);
this.maxForce = data.maxForce;
this.maxTorque = data.maxTorque
}
};
b2FrictionJointDef._extend(b2JointDef);
function b2FrictionJoint(def) {
this.parent.call(this, def);
this.m_localAnchorA = def.localAnchorA.Clone();
this.m_localAnchorB = def.localAnchorB.Clone();
this.m_linearImpulse = new b2Vec2();
this.m_angularImpulse = 0;
this.m_maxForce = def.maxForce;
this.m_maxTorque = def.maxTorque;
this.m_indexA = 0;
this.m_indexB = 0;
this.m_rA = new b2Vec2();
this.m_rB = new b2Vec2();
this.m_localCenterA = new b2Vec2();
this.m_localCenterB = new b2Vec2();
this.m_invMassA = 0;
this.m_invMassB = 0;
this.m_invIA = 0;
this.m_invIB = 0;
this.m_linearMass = new b2Mat22();
this.m_angularMass = 0
}
b2FrictionJoint.prototype = {
GetAnchorA: function () {
return this.m_bodyA.GetWorldPoint(this.m_localAnchorA)
},
GetAnchorB: function () {
return this.m_bodyB.GetWorldPoint(this.m_localAnchorB)
},
GetReactionForce: function (inv_dt) {
return b2Vec2.Multiply(inv_dt, this.m_linearImpulse)
},
GetReactionTorque: function (inv_dt) {
return inv_dt * this.m_angularImpulse
},
GetLocalAnchorA: function () {
return this.m_localAnchorA
},
GetLocalAnchorB: function () {
return this.m_localAnchorB
},
SetMaxForce: function (force) {
this.m_maxForce = force
},
GetMaxForce: function () {
return this.m_maxForce
},
SetMaxTorque: function (torque) {
this.m_maxTorque = torque
},
GetMaxTorque: function () {
return this.m_maxTorque
},
InitVelocityConstraints: function (data) {
this.m_indexA = this.m_bodyA.m_islandIndex;
this.m_indexB = this.m_bodyB.m_islandIndex;
this.m_localCenterA.Assign(this.m_bodyA.m_sweep.localCenter);
this.m_localCenterB.Assign(this.m_bodyB.m_sweep.localCenter);
this.m_invMassA = this.m_bodyA.m_invMass;
this.m_invMassB = this.m_bodyB.m_invMass;
this.m_invIA = this.m_bodyA.m_invI;
this.m_invIB = this.m_bodyB.m_invI;
var aA = data.positions[this.m_indexA].a;
var vA = data.velocities[this.m_indexA].v.Clone();
var wA = data.velocities[this.m_indexA].w;
var aB = data.positions[this.m_indexB].a;
var vB = data.velocities[this.m_indexB].v.Clone();
var wB = data.velocities[this.m_indexB].w;
var qA = new b2Rot(aA),
qB = new b2Rot(aB);
this.m_rA = b2Mul_r_v2(qA, b2Vec2.Subtract(this.m_localAnchorA, this.m_localCenterA));
this.m_rB = b2Mul_r_v2(qB, b2Vec2.Subtract(this.m_localAnchorB, this.m_localCenterB));
var mA = this.m_invMassA,
mB = this.m_invMassB;
var iA = this.m_invIA,
iB = this.m_invIB;
var K = new b2Mat22();
K.ex.x = mA + mB + iA * this.m_rA.y * this.m_rA.y + iB * this.m_rB.y * this.m_rB.y;
K.ex.y = -iA * this.m_rA.x * this.m_rA.y - iB * this.m_rB.x * this.m_rB.y;
K.ey.x = K.ex.y;
K.ey.y = mA + mB + iA * this.m_rA.x * this.m_rA.x + iB * this.m_rB.x * this.m_rB.x;
this.m_linearMass = K.GetInverse();
this.m_angularMass = iA + iB;
if (this.m_angularMass > 0) {
this.m_angularMass = 1 / this.m_angularMass
}
if (data.step.warmStarting) {
this.m_linearImpulse.Multiply(data.step.dtRatio);
this.m_angularImpulse *= data.step.dtRatio;
var P = new b2Vec2(this.m_linearImpulse.x, this.m_linearImpulse.y);
vA.Subtract(b2Vec2.Multiply(mA, P));
wA -= iA * (b2Cross_v2_v2(this.m_rA, P) + this.m_angularImpulse);
vB.Add(b2Vec2.Multiply(mB, P));
wB += iB * (b2Cross_v2_v2(this.m_rB, P) + this.m_angularImpulse)
} else {
this.m_linearImpulse.SetZero();
this.m_angularImpulse = 0
}
data.velocities[this.m_indexA].v.Assign(vA);
data.velocities[this.m_indexA].w = wA;
data.velocities[this.m_indexB].v.Assign(vB);
data.velocities[this.m_indexB].w = wB
},
SolveVelocityConstraints: function (data) {
var vA = data.velocities[this.m_indexA].v.Clone();
var wA = data.velocities[this.m_indexA].w;
var vB = data.velocities[this.m_indexB].v.Clone();
var wB = data.velocities[this.m_indexB].w;
var mA = this.m_invMassA,
mB = this.m_invMassB;
var iA = this.m_invIA,
iB = this.m_invIB;
var h = data.step.dt;
var Cdot = wB - wA;
var impulse = -this.m_angularMass * Cdot;
var oldImpulse = this.m_angularImpulse;
var maxImpulse = h * this.m_maxTorque;
this.m_angularImpulse = b2Clamp(this.m_angularImpulse + impulse, -maxImpulse, maxImpulse);
impulse = this.m_angularImpulse - oldImpulse;
wA -= iA * impulse;
wB += iB * impulse;
var Cdot = b2Vec2.Add(vB, b2Vec2.Subtract(b2Cross_f_v2(wB, this.m_rB), b2Vec2.Subtract(vA, b2Cross_f_v2(wA, this.m_rA))));
var impulse = b2Mul_m22_v2(this.m_linearMass, Cdot).Negate();
var oldImpulse = this.m_linearImpulse.Clone();
this.m_linearImpulse.Add(impulse);
var maxImpulse = h * this.m_maxForce;
if (this.m_linearImpulse.LengthSquared() > maxImpulse * maxImpulse) {
this.m_linearImpulse.Normalize();
this.m_linearImpulse.Multiply(maxImpulse)
}
impulse = b2Vec2.Subtract(this.m_linearImpulse, oldImpulse);
vA.Subtract(b2Vec2.Multiply(mA, impulse));
wA -= iA * b2Cross_v2_v2(this.m_rA, impulse);
vB.Add(b2Vec2.Multiply(mB, impulse));
wB += iB * b2Cross_v2_v2(this.m_rB, impulse);
data.velocities[this.m_indexA].v.Assign(vA);
data.velocities[this.m_indexA].w = wA;
data.velocities[this.m_indexB].v.Assign(vB);
data.velocities[this.m_indexB].w = wB
},
SolvePositionConstraints: function (data) {
return true
},
_serialize: function (out) {
var obj = out || {};
this.parent.prototype._serialize.call(this, obj);
obj.localAnchorA = this.m_localAnchorA._serialize();
obj.localAnchorB = this.m_localAnchorB._serialize();
obj.maxForce = this.m_maxForce;
obj.maxTorque = this.m_maxTorque;
return obj
}
};
b2FrictionJoint._extend(b2Joint);
function b2WeldJointDef() {
this.parent.call(this);
this.type = b2Joint.e_weldJoint;
this.localAnchorA = new b2Vec2(0, 0);
this.localAnchorB = new b2Vec2(0, 0);
this.referenceAngle = 0;
this.frequencyHz = 0;
this.dampingRatio = 0;
Object.seal(this)
}
b2WeldJointDef.prototype = {
Initialize: function (bA, bB, anchor) {
this.bodyA = bA;
this.bodyB = bB;
this.localAnchorA.Assign(this.bodyA.GetLocalPoint(anchor));
this.localAnchorB.Assign(this.bodyB.GetLocalPoint(anchor));
this.referenceAngle = this.bodyB.GetAngle() - this.bodyA.GetAngle()
},
_deserialize: function (data, bodies, joints) {
this.parent.prototype._deserialize.call(this, data, bodies, joints);
this.localAnchorA._deserialize(data.localAnchorA);
this.localAnchorB._deserialize(data.localAnchorB);
this.referenceAngle = data.referenceAngle;
this.frequencyHz = data.frequencyHz;
this.dampingRatio = data.dampingRatio
}
};
b2WeldJointDef._extend(b2JointDef);
function b2WeldJoint(def) {
this.parent.call(this, def);
this.m_bias = 0;
this.m_gamma = 0;
this.m_indexA = 0;
this.m_indexB = 0;
this.m_rA = new b2Vec2();
this.m_rB = new b2Vec2();
this.m_localCenterA = new b2Vec2();
this.m_localCenterB = new b2Vec2();
this.m_invMassA = 0;
this.m_invMassB = 0;
this.m_invIA = 0;
this.m_invIB = 0;
this.m_mass = new b2Mat33();
this.m_localAnchorA = def.localAnchorA.Clone();
this.m_localAnchorB = def.localAnchorB.Clone();
this.m_referenceAngle = def.referenceAngle;
this.m_frequencyHz = def.frequencyHz;
this.m_dampingRatio = def.dampingRatio;
this.m_impulse = new b2Vec3()
}
b2WeldJoint.prototype = {
GetAnchorA: function () {
return this.m_bodyA.GetWorldPoint(this.m_localAnchorA)
},
GetAnchorB: function () {
return this.m_bodyB.GetWorldPoint(this.m_localAnchorB)
},
GetReactionForce: function (inv_dt) {
var P = new b2Vec2(this.m_impulse.x, this.m_impulse.y);
return b2Vec2.Multiply(inv_dt, P)
},
GetReactionTorque: function (inv_dt) {
return inv_dt * this.m_impulse.z
},
GetLocalAnchorA: function () {
return this.m_localAnchorA
},
GetLocalAnchorB: function () {
return this.m_localAnchorB
},
GetReferenceAngle: function () {
return this.m_referenceAngle
},
SetFrequency: function (hz) {
this.m_frequencyHz = hz
},
GetFrequency: function () {
return this.m_frequencyHz
},
SetDampingRatio: function (ratio) {
this.m_dampingRatio = ratio
},
GetDampingRatio: function () {
return this.m_dampingRatio
},
InitVelocityConstraints: function (data) {
this.m_indexA = this.m_bodyA.m_islandIndex;
this.m_indexB = this.m_bodyB.m_islandIndex;
this.m_localCenterA.Assign(this.m_bodyA.m_sweep.localCenter);
this.m_localCenterB.Assign(this.m_bodyB.m_sweep.localCenter);
this.m_invMassA = this.m_bodyA.m_invMass;
this.m_invMassB = this.m_bodyB.m_invMass;
this.m_invIA = this.m_bodyA.m_invI;
this.m_invIB = this.m_bodyB.m_invI;
var aA = data.positions[this.m_indexA].a;
var vA = data.velocities[this.m_indexA].v.Clone();
var wA = data.velocities[this.m_indexA].w;
var aB = data.positions[this.m_indexB].a;
var vB = data.velocities[this.m_indexB].v.Clone();
var wB = data.velocities[this.m_indexB].w;
var qA = new b2Rot(aA),
qB = new b2Rot(aB);
this.m_rA.Assign(b2Mul_r_v2(qA, b2Vec2.Subtract(this.m_localAnchorA, this.m_localCenterA)));
this.m_rB.Assign(b2Mul_r_v2(qB, b2Vec2.Subtract(this.m_localAnchorB, this.m_localCenterB)));
var mA = this.m_invMassA,
mB = this.m_invMassB;
var iA = this.m_invIA,
iB = this.m_invIB;
var K = new b2Mat33();
K.ex.x = mA + mB + this.m_rA.y * this.m_rA.y * iA + this.m_rB.y * this.m_rB.y * iB;
K.ey.x = -this.m_rA.y * this.m_rA.x * iA - this.m_rB.y * this.m_rB.x * iB;
K.ez.x = -this.m_rA.y * iA - this.m_rB.y * iB;
K.ex.y = K.ey.x;
K.ey.y = mA + mB + this.m_rA.x * this.m_rA.x * iA + this.m_rB.x * this.m_rB.x * iB;
K.ez.y = this.m_rA.x * iA + this.m_rB.x * iB;
K.ex.z = K.ez.x;
K.ey.z = K.ez.y;
K.ez.z = iA + iB;
if (this.m_frequencyHz > 0) {
K.GetInverse22(this.m_mass);
var invM = iA + iB;
var m = invM > 0 ? 1 / invM : 0;
var C = aB - aA - this.m_referenceAngle;
var omega = 2 * b2_pi * this.m_frequencyHz;
var d = 2 * m * this.m_dampingRatio * omega;
var k = m * omega * omega;
var h = data.step.dt;
this.m_gamma = h * (d + h * k);
this.m_gamma = this.m_gamma != 0 ? 1 / this.m_gamma : 0;
this.m_bias = C * h * k * this.m_gamma;
invM += this.m_gamma;
this.m_mass.ez.z = invM != 0 ? 1 / invM : 0
} else {
K.GetSymInverse33(this.m_mass);
this.m_gamma = 0;
this.m_bias = 0
}
if (data.step.warmStarting) {
this.m_impulse.Multiply(data.step.dtRatio);
var P = new b2Vec2(this.m_impulse.x, this.m_impulse.y);
vA.Subtract(b2Vec2.Multiply(mA, P));
wA -= iA * (b2Cross_v2_v2(this.m_rA, P) + this.m_impulse.z);
vB.Add(b2Vec2.Multiply(mB, P));
wB += iB * (b2Cross_v2_v2(this.m_rB, P) + this.m_impulse.z)
} else {
this.m_impulse.SetZero()
}
data.velocities[this.m_indexA].v.Assign(vA);
data.velocities[this.m_indexA].w = wA;
data.velocities[this.m_indexB].v.Assign(vB);
data.velocities[this.m_indexB].w = wB
},
SolveVelocityConstraints: function (data) {
var vA = data.velocities[this.m_indexA].v.Clone();
var wA = data.velocities[this.m_indexA].w;
var vB = data.velocities[this.m_indexB].v.Clone();
var wB = data.velocities[this.m_indexB].w;
var mA = this.m_invMassA,
mB = this.m_invMassB;
var iA = this.m_invIA,
iB = this.m_invIB;
if (this.m_frequencyHz > 0) {
var Cdot2 = wB - wA;
var impulse2 = -this.m_mass.ez.z * (Cdot2 + this.m_bias + this.m_gamma * this.m_impulse.z);
this.m_impulse.z += impulse2;
wA -= iA * impulse2;
wB += iB * impulse2;
var Cdot1 = b2Vec2.Subtract(b2Vec2.Subtract(b2Vec2.Add(vB, b2Cross_f_v2(wB, this.m_rB)), vA), b2Cross_f_v2(wA, this.m_rA));
var impulse1 = b2Mul22_m33_v2(this.m_mass, Cdot1).Negate();
this.m_impulse.x += impulse1.x;
this.m_impulse.y += impulse1.y;
var P = impulse1.Clone();
vA.Subtract(b2Vec2.Multiply(mA, P));
wA -= iA * b2Cross_v2_v2(this.m_rA, P);
vB.Add(b2Vec2.Multiply(mB, P));
wB += iB * b2Cross_v2_v2(this.m_rB, P)
} else {
var Cdot1 = b2Vec2.Subtract(b2Vec2.Subtract(b2Vec2.Add(vB, b2Cross_f_v2(wB, this.m_rB)), vA), b2Cross_f_v2(wA, this.m_rA));
var Cdot2 = wB - wA;
var Cdot = new b2Vec3(Cdot1.x, Cdot1.y, Cdot2);
var impulse = b2Mul_m33_v3(this.m_mass, Cdot).Negate();
this.m_impulse.Add(impulse);
var P = new b2Vec2(impulse.x, impulse.y);
vA.Subtract(b2Vec2.Multiply(mA, P));
wA -= iA * (b2Cross_v2_v2(this.m_rA, P) + impulse.z);
vB.Add(b2Vec2.Multiply(mB, P));
wB += iB * (b2Cross_v2_v2(this.m_rB, P) + impulse.z)
}
data.velocities[this.m_indexA].v.Assign(vA);
data.velocities[this.m_indexA].w = wA;
data.velocities[this.m_indexB].v.Assign(vB);
data.velocities[this.m_indexB].w = wB
},
SolvePositionConstraints: function (data) {
var cA = data.positions[this.m_indexA].c.Clone();
var aA = data.positions[this.m_indexA].a;
var cB = data.positions[this.m_indexB].c.Clone();
var aB = data.positions[this.m_indexB].a;
var qA = new b2Rot(aA),
qB = new b2Rot(aB);
var mA = this.m_invMassA,
mB = this.m_invMassB;
var iA = this.m_invIA,
iB = this.m_invIB;
var rA = b2Mul_r_v2(qA, b2Vec2.Subtract(this.m_localAnchorA, this.m_localCenterA));
var rB = b2Mul_r_v2(qB, b2Vec2.Subtract(this.m_localAnchorB, this.m_localCenterB));
var positionError, angularError;
var K = new b2Mat33();
K.ex.x = mA + mB + rA.y * rA.y * iA + rB.y * rB.y * iB;
K.ey.x = -rA.y * rA.x * iA - rB.y * rB.x * iB;
K.ez.x = -rA.y * iA - rB.y * iB;
K.ex.y = K.ey.x;
K.ey.y = mA + mB + rA.x * rA.x * iA + rB.x * rB.x * iB;
K.ez.y = rA.x * iA + rB.x * iB;
K.ex.z = K.ez.x;
K.ey.z = K.ez.y;
K.ez.z = iA + iB;
if (this.m_frequencyHz > 0) {
var C1 = b2Vec2.Subtract(b2Vec2.Subtract(b2Vec2.Add(cB, rB), cA), rA);
positionError = C1.Length();
angularError = 0;
var P = K.Solve22(C1).Negate();
cA.Subtract(b2Vec2.Multiply(mA, P));
aA -= iA * b2Cross_v2_v2(rA, P);
cB.Add(b2Vec2.Multiply(mB, P));
aB += iB * b2Cross_v2_v2(rB, P)
} else {
var C1 = b2Vec2.Subtract(b2Vec2.Subtract(b2Vec2.Add(cB, rB), cA), rA);
var C2 = aB - aA - this.m_referenceAngle;
positionError = C1.Length();
angularError = b2Abs(C2);
var C = new b2Vec3(C1.x, C1.y, C2);
var impulse = K.Solve33(C).Negate();
var P = new b2Vec2(impulse.x, impulse.y);
cA.Subtract(b2Vec2.Multiply(mA, P));
aA -= iA * (b2Cross_v2_v2(rA, P) + impulse.z);
cB.Add(b2Vec2.Multiply(mB, P));
aB += iB * (b2Cross_v2_v2(rB, P) + impulse.z)
}
data.positions[this.m_indexA].c.Assign(cA);
data.positions[this.m_indexA].a = aA;
data.positions[this.m_indexB].c.Assign(cB);
data.positions[this.m_indexB].a = aB;
return positionError <= b2_linearSlop && angularError <= b2_angularSlop
},
_serialize: function (out) {
var obj = out || {};
this.parent.prototype._serialize.call(this, obj);
obj.localAnchorA = this.m_localAnchorA._serialize();
obj.localAnchorB = this.m_localAnchorB._serialize();
obj.referenceAngle = this.m_referenceAngle;
obj.frequencyHz = this.m_frequencyHz;
obj.dampingRatio = this.m_dampingRatio;
return obj
}
};
b2WeldJoint._extend(b2Joint);
function b2WheelJointDef() {
this.parent.call(this);
this.type = b2Joint.e_wheelJoint;
this.localAnchorA = new b2Vec2();
this.localAnchorB = new b2Vec2();
this.localAxisA = new b2Vec2(1, 0);
this.enableMotor = false;
this.maxMotorTorque = 0;
this.motorSpeed = 0;
this.frequencyHz = 2;
this.dampingRatio = 0.7;
Object.seal(this)
}
b2WheelJointDef.prototype = {
Initialize: function (bA, bB, anchor, axis) {
this.bodyA = bA;
this.bodyB = bB;
this.localAnchorA.Assign(this.bodyA.GetLocalPoint(anchor));
this.localAnchorB.Assign(this.bodyB.GetLocalPoint(anchor));
this.localAxisA.Assign(this.bodyA.GetLocalVector(axis))
},
_deserialize: function (data, bodies, joints) {
this.parent.prototype._deserialize.call(this, data, bodies, joints);
this.localAnchorA._deserialize(data.localAnchorA);
this.localAnchorB._deserialize(data.localAnchorB);
this.localAxisA._deserialize(data.localAxisA);
this.enableMotor = data.enableMotor;
this.maxMotorTorque = data.maxMotorTorque;
this.motorSpeed = data.motorSpeed;
this.frequencyHz = data.frequencyHz;
this.dampingRatio = data.dampingRatio
}
};
b2WheelJointDef._extend(b2JointDef);
function b2WheelJoint(def) {
this.parent.call(this, def);
this.m_indexA = 0;
this.m_indexB = 0;
this.m_localCenterA = new b2Vec2();
this.m_localCenterB = new b2Vec2();
this.m_invMassA = 0;
this.m_invMassB = 0;
this.m_invIA = 0;
this.m_invIB = 0;
this.m_localAnchorA = def.localAnchorA.Clone();
this.m_localAnchorB = def.localAnchorB.Clone();
this.m_localXAxisA = def.localAxisA.Clone();
this.m_localYAxisA = b2Cross_f_v2(1, this.m_localXAxisA);
this.m_mass = 0;
this.m_impulse = 0;
this.m_motorMass = 0;
this.m_motorImpulse = 0;
this.m_springMass = 0;
this.m_springImpulse = 0;
this.m_maxMotorTorque = def.maxMotorTorque;
this.m_motorSpeed = def.motorSpeed;
this.m_enableMotor = def.enableMotor;
this.m_frequencyHz = def.frequencyHz;
this.m_dampingRatio = def.dampingRatio;
this.m_bias = 0;
this.m_gamma = 0;
this.m_ax = new b2Vec2();
this.m_ay = new b2Vec2();
this.m_sAx = this.m_sBx = 0;
this.m_sAy = this.m_sBy = 0
}
b2WheelJoint.prototype = {
GetAnchorA: function () {
return this.m_bodyA.GetWorldPoint(this.m_localAnchorA)
},
GetAnchorB: function () {
return this.m_bodyB.GetWorldPoint(this.m_localAnchorB)
},
GetReactionForce: function (inv_dt) {
return b2Vec2.Multiply(inv_dt, b2Vec2.Add(b2Vec2.Multiply(this.m_impulse, this.m_ay), b2Vec2.Multiply(this.m_springImpulse, this.m_ax)))
},
GetReactionTorque: function (inv_dt) {
return inv_dt * this.m_motorImpulse
},
GetLocalAnchorA: function () {
return this.m_localAnchorA
},
GetLocalAnchorB: function () {
return this.m_localAnchorB
},
GetLocalAxisA: function () {
return this.m_localXAxisA
},
GetJointTranslation: function () {
var bA = this.m_bodyA;
var bB = this.m_bodyB;
var pA = bA.GetWorldPoint(this.m_localAnchorA);
var pB = bB.GetWorldPoint(this.m_localAnchorB);
var d = b2Vec2.Subtract(pB, pA);
var axis = bA.GetWorldVector(this.m_localXAxisA);
var translation = b2Dot_v2_v2(d, axis);
return translation
},
GetJointSpeed: function () {
var wA = this.m_bodyA.m_angularVelocity;
var wB = this.m_bodyB.m_angularVelocity;
return wB - wA
},
IsMotorEnabled: function () {
return this.m_enableMotor
},
EnableMotor: function (flag) {
this.m_bodyA.SetAwake(true);
this.m_bodyB.SetAwake(true);
this.m_enableMotor = flag
},
SetMotorSpeed: function (speed) {
this.m_bodyA.SetAwake(true);
this.m_bodyB.SetAwake(true);
this.m_motorSpeed = speed
},
GetMotorSpeed: function () {
return this.m_motorSpeed
},
SetMaxMotorTorque: function (torque) {
this.m_bodyA.SetAwake(true);
this.m_bodyB.SetAwake(true);
this.m_maxMotorTorque = torque
},
GetMaxMotorTorque: function () {
return this.m_maxMotorTorque
},
GetMotorTorque: function (inv_dt) {
return inv_dt * this.m_motorImpulse
},
SetSpringFrequencyHz: function (hz) {
this.m_frequencyHz = hz
},
GetSpringFrequencyHz: function () {
return this.m_frequencyHz
},
SetSpringDampingRatio: function (ratio) {
this.m_dampingRatio = ratio
},
GetSpringDampingRatio: function () {
return this.m_dampingRatio
},
InitVelocityConstraints: function (data) {
this.m_indexA = this.m_bodyA.m_islandIndex;
this.m_indexB = this.m_bodyB.m_islandIndex;
this.m_localCenterA.Assign(this.m_bodyA.m_sweep.localCenter);
this.m_localCenterB.Assign(this.m_bodyB.m_sweep.localCenter);
this.m_invMassA = this.m_bodyA.m_invMass;
this.m_invMassB = this.m_bodyB.m_invMass;
this.m_invIA = this.m_bodyA.m_invI;
this.m_invIB = this.m_bodyB.m_invI;
var mA = this.m_invMassA,
mB = this.m_invMassB;
var iA = this.m_invIA,
iB = this.m_invIB;
var cA = data.positions[this.m_indexA].c.Clone();
var aA = data.positions[this.m_indexA].a;
var vA = data.velocities[this.m_indexA].v.Clone();
var wA = data.velocities[this.m_indexA].w;
var cB = data.positions[this.m_indexB].c.Clone();
var aB = data.positions[this.m_indexB].a;
var vB = data.velocities[this.m_indexB].v.Clone();
var wB = data.velocities[this.m_indexB].w;
var qA = new b2Rot(aA),
qB = new b2Rot(aB);
var rA = b2Mul_r_v2(qA, b2Vec2.Subtract(this.m_localAnchorA, this.m_localCenterA));
var rB = b2Mul_r_v2(qB, b2Vec2.Subtract(this.m_localAnchorB, this.m_localCenterB));
var d = b2Vec2.Subtract(b2Vec2.Subtract(b2Vec2.Add(cB, rB), cA), rA);
this.m_ay.Assign(b2Mul_r_v2(qA, this.m_localYAxisA));
this.m_sAy = b2Cross_v2_v2(b2Vec2.Add(d, rA), this.m_ay);
this.m_sBy = b2Cross_v2_v2(rB, this.m_ay);
this.m_mass = mA + mB + iA * this.m_sAy * this.m_sAy + iB * this.m_sBy * this.m_sBy;
if (this.m_mass > 0) {
this.m_mass = 1 / this.m_mass
}
this.m_springMass = 0;
this.m_bias = 0;
this.m_gamma = 0;
if (this.m_frequencyHz > 0) {
this.m_ax.Assign(b2Mul_r_v2(qA, this.m_localXAxisA));
this.m_sAx = b2Cross_v2_v2(b2Vec2.Add(d, rA), this.m_ax);
this.m_sBx = b2Cross_v2_v2(rB, this.m_ax);
var invMass = mA + mB + iA * this.m_sAx * this.m_sAx + iB * this.m_sBx * this.m_sBx;
if (invMass > 0) {
this.m_springMass = 1 / invMass;
var C = b2Dot_v2_v2(d, this.m_ax);
var omega = 2 * b2_pi * this.m_frequencyHz;
var d = 2 * this.m_springMass * this.m_dampingRatio * omega;
var k = this.m_springMass * omega * omega;
var h = data.step.dt;
this.m_gamma = h * (d + h * k);
if (this.m_gamma > 0) {
this.m_gamma = 1 / this.m_gamma
}
this.m_bias = C * h * k * this.m_gamma;
this.m_springMass = invMass + this.m_gamma;
if (this.m_springMass > 0) {
this.m_springMass = 1 / this.m_springMass
}
}
} else {
this.m_springImpulse = 0
}
if (this.m_enableMotor) {
this.m_motorMass = iA + iB;
if (this.m_motorMass > 0) {
this.m_motorMass = 1 / this.m_motorMass
}
} else {
this.m_motorMass = 0;
this.m_motorImpulse = 0
}
if (data.step.warmStarting) {
this.m_impulse *= data.step.dtRatio;
this.m_springImpulse *= data.step.dtRatio;
this.m_motorImpulse *= data.step.dtRatio;
var P = b2Vec2.Add(b2Vec2.Multiply(this.m_impulse, this.m_ay), b2Vec2.Multiply(this.m_springImpulse, this.m_ax));
var LA = this.m_impulse * this.m_sAy + this.m_springImpulse * this.m_sAx + this.m_motorImpulse;
var LB = this.m_impulse * this.m_sBy + this.m_springImpulse * this.m_sBx + this.m_motorImpulse;
vA.Subtract(b2Vec2.Multiply(this.m_invMassA, P));
wA -= this.m_invIA * LA;
vB.Add(b2Vec2.Multiply(this.m_invMassB, P));
wB += this.m_invIB * LB
} else {
this.m_impulse = 0;
this.m_springImpulse = 0;
this.m_motorImpulse = 0
}
data.velocities[this.m_indexA].v.Assign(vA);
data.velocities[this.m_indexA].w = wA;
data.velocities[this.m_indexB].v.Assign(vB);
data.velocities[this.m_indexB].w = wB
},
SolveVelocityConstraints: function (data) {
var mA = this.m_invMassA,
mB = this.m_invMassB;
var iA = this.m_invIA,
iB = this.m_invIB;
var vA = data.velocities[this.m_indexA].v.Clone();
var wA = data.velocities[this.m_indexA].w;
var vB = data.velocities[this.m_indexB].v.Clone();
var wB = data.velocities[this.m_indexB].w;
var Cdot = b2Dot_v2_v2(this.m_ax, b2Vec2.Subtract(vB, vA)) + this.m_sBx * wB - this.m_sAx * wA;
var impulse = -this.m_springMass * (Cdot + this.m_bias + this.m_gamma * this.m_springImpulse);
this.m_springImpulse += impulse;
var P = b2Vec2.Multiply(impulse, this.m_ax);
var LA = impulse * this.m_sAx;
var LB = impulse * this.m_sBx;
vA.Subtract(b2Vec2.Multiply(mA, P));
wA -= iA * LA;
vB.Add(b2Vec2.Multiply(mB, P));
wB += iB * LB;
var Cdot = wB - wA - this.m_motorSpeed;
var impulse = -this.m_motorMass * Cdot;
var oldImpulse = this.m_motorImpulse;
var maxImpulse = data.step.dt * this.m_maxMotorTorque;
this.m_motorImpulse = b2Clamp(this.m_motorImpulse + impulse, -maxImpulse, maxImpulse);
impulse = this.m_motorImpulse - oldImpulse;
wA -= iA * impulse;
wB += iB * impulse;
var Cdot = b2Dot_v2_v2(this.m_ay, b2Vec2.Subtract(vB, vA)) + this.m_sBy * wB - this.m_sAy * wA;
var impulse = -this.m_mass * Cdot;
this.m_impulse += impulse;
var P = b2Vec2.Multiply(impulse, this.m_ay);
var LA = impulse * this.m_sAy;
var LB = impulse * this.m_sBy;
vA.Subtract(b2Vec2.Multiply(mA, P));
wA -= iA * LA;
vB.Add(b2Vec2.Multiply(mB, P));
wB += iB * LB;
data.velocities[this.m_indexA].v.Assign(vA);
data.velocities[this.m_indexA].w = wA;
data.velocities[this.m_indexB].v.Assign(vB);
data.velocities[this.m_indexB].w = wB
},
SolvePositionConstraints: function (data) {
var cA = data.positions[this.m_indexA].c.Clone();
var aA = data.positions[this.m_indexA].a;
var cB = data.positions[this.m_indexB].c.Clone();
var aB = data.positions[this.m_indexB].a;
var qA = new b2Rot(aA),
qB = new b2Rot(aB);
var rA = b2Mul_r_v2(qA, b2Vec2.Subtract(this.m_localAnchorA, this.m_localCenterA));
var rB = b2Mul_r_v2(qB, b2Vec2.Subtract(this.m_localAnchorB, this.m_localCenterB));
var d = b2Vec2.Add(b2Vec2.Subtract(cB, cA), b2Vec2.Subtract(rB, rA));
var ay = b2Mul_r_v2(qA, this.m_localYAxisA);
var sAy = b2Cross_v2_v2(b2Vec2.Add(d, rA), ay);
var sBy = b2Cross_v2_v2(rB, ay);
var C = b2Dot_v2_v2(d, ay);
var k = this.m_invMassA + this.m_invMassB + this.m_invIA * this.m_sAy * this.m_sAy + this.m_invIB * this.m_sBy * this.m_sBy;
var impulse;
if (k != 0) {
impulse = -C / k
} else {
impulse = 0
}
var P = b2Vec2.Multiply(impulse, ay);
var LA = impulse * sAy;
var LB = impulse * sBy;
cA.Subtract(b2Vec2.Multiply(this.m_invMassA, P));
aA -= this.m_invIA * LA;
cB.Add(b2Vec2.Multiply(this.m_invMassB, P));
aB += this.m_invIB * LB;
data.positions[this.m_indexA].c.Assign(cA);
data.positions[this.m_indexA].a = aA;
data.positions[this.m_indexB].c.Assign(cB);
data.positions[this.m_indexB].a = aB;
return b2Abs(C) <= b2_linearSlop
},
_serialize: function (out) {
var obj = out || {};
this.parent.prototype._serialize.call(this, obj);
obj.localAnchorA = this.m_localAnchorA._serialize();
obj.localAnchorB = this.m_localAnchorB._serialize();
obj.localAxisA = this.m_localAxisA._serialize();
obj.enableMotor = this.m_enableMotor;
obj.maxMotorTorque = this.m_maxMotorTorque;
obj.motorSpeed = this.m_motorSpeed;
obj.frequencyHz = this.m_frequencyHz;
obj.dampingRatio = this.m_dampingRatio;
return obj
}
};
b2WheelJoint._extend(b2Joint);
function b2GearJointDef() {
this.parent.call(this);
this.type = b2Joint.e_gearJoint;
this.joint1 = null;
this.joint2 = null;
this.ratio = 1;
Object.seal(this)
}
b2GearJointDef.prototype = {
_deserialize: function (data, bodies, joints) {
this.parent.prototype._deserialize.call(this, data, bodies, joints);
this.joint1 = data.joint1;
this.joint2 = data.joint2;
this.ratio = data.ratio
}
};
b2GearJointDef._extend(b2JointDef);
function b2GearJoint(def) {
this.parent.call(this, def);
this.m_joint1 = def.joint1;
this.m_joint2 = def.joint2;
this.m_typeA = this.m_joint1.GetType();
this.m_typeB = this.m_joint2.GetType();
var coordinateA, coordinateB;
this.m_bodyC = this.m_joint1.GetBodyA();
this.m_bodyA = this.m_joint1.GetBodyB();
var xfA = this.m_bodyA.m_xf;
var aA = this.m_bodyA.m_sweep.a;
var xfC = this.m_bodyC.m_xf;
var aC = this.m_bodyC.m_sweep.a;
this.m_localAnchorA = new b2Vec2();
this.m_localAnchorB = new b2Vec2();
this.m_localAnchorC = new b2Vec2();
this.m_localAnchorD = new b2Vec2();
this.m_localAxisC = new b2Vec2();
this.m_localAxisD = new b2Vec2();
if (this.m_typeA == b2Joint.e_revoluteJoint) {
var revolute = def.joint1;
this.m_localAnchorC.Assign(revolute.m_localAnchorA);
this.m_localAnchorA.Assign(revolute.m_localAnchorB);
this.m_referenceAngleA = revolute.m_referenceAngle;
this.m_localAxisC.SetZero();
coordinateA = aA - aC - this.m_referenceAngleA
} else {
var prismatic = def.joint1;
this.m_localAnchorC.Assign(prismatic.m_localAnchorA);
this.m_localAnchorA.Assign(prismatic.m_localAnchorB);
this.m_referenceAngleA = prismatic.m_referenceAngle;
this.m_localAxisC.Assign(prismatic.m_localXAxisA);
var pC = this.m_localAnchorC;
var pA = b2MulT_r_v2(xfC.q, b2Vec2.Add(b2Mul_r_v2(xfA.q, this.m_localAnchorA), b2Vec2.Subtract(xfA.p, xfC.p)));
coordinateA = b2Dot_v2_v2(b2Vec2.Subtract(pA, pC), this.m_localAxisC)
}
this.m_bodyD = this.m_joint2.GetBodyA();
this.m_bodyB = this.m_joint2.GetBodyB();
var xfB = this.m_bodyB.m_xf;
var aB = this.m_bodyB.m_sweep.a;
var xfD = this.m_bodyD.m_xf;
var aD = this.m_bodyD.m_sweep.a;
if (this.m_typeB == b2Joint.e_revoluteJoint) {
var revolute = def.joint2;
this.m_localAnchorD.Assign(revolute.m_localAnchorA);
this.m_localAnchorB.Assign(revolute.m_localAnchorB);
this.m_referenceAngleB = revolute.m_referenceAngle;
this.m_localAxisD.SetZero();
coordinateB = aB - aD - this.m_referenceAngleB
} else {
var prismatic = def.joint2;
this.m_localAnchorD.Assign(prismatic.m_localAnchorA);
this.m_localAnchorB.Assign(prismatic.m_localAnchorB);
this.m_referenceAngleB = prismatic.m_referenceAngle;
this.m_localAxisD.Assign(prismatic.m_localXAxisA);
var pD = this.m_localAnchorD;
var pB = b2MulT_r_v2(xfD.q, b2Vec2.Add(b2Mul_r_v2(xfB.q, this.m_localAnchorB), b2Vec2.Subtract(xfB.p, xfD.p)));
coordinateB = b2Dot_v2_v2(b2Vec2.Subtract(pB, pD), this.m_localAxisD)
}
this.m_ratio = def.ratio;
this.m_constant = coordinateA + this.m_ratio * coordinateB;
this.m_impulse = 0;
this.m_indexA = this.m_indexB = this.m_indexC = this.m_indexD = 0;
this.m_lcA = new b2Vec2();
this.m_lcB = new b2Vec2();
this.m_lcC = new b2Vec2();
this.m_lcD = new b2Vec2();
this.m_mA = this.m_mB = this.m_mC = this.m_mD = 0;
this.m_iA = this.m_iB = this.m_iC = this.m_iD = 0;
this.m_JvAC = new b2Vec2(), this.m_JvBD = new b2Vec2();
this.m_JwA = this.m_JwB = this.m_JwC = this.m_JwD = 0;
this.m_mass = 0
}
b2GearJoint.prototype = {
GetAnchorA: function () {
return this.m_bodyA.GetWorldPoint(this.m_localAnchorA)
},
GetAnchorB: function () {
return this.m_bodyB.GetWorldPoint(this.m_localAnchorB)
},
GetReactionForce: function (inv_dt) {
var P = b2Vec2.Multiply(this.m_impulse, this.m_JvAC);
return b2Vec2.Multiply(inv_dt, P)
},
GetReactionTorque: function (inv_dt) {
var L = this.m_impulse * this.m_JwA;
return inv_dt * L
},
GetJoint1: function () {
return this.m_joint1
},
GetJoint2: function () {
return this.m_joint2
},
SetRatio: function (ratio) {
this.m_ratio = ratio
},
GetRatio: function () {
return this.m_ratio
},
InitVelocityConstraints: function (data) {
this.m_indexA = this.m_bodyA.m_islandIndex;
this.m_indexB = this.m_bodyB.m_islandIndex;
this.m_indexC = this.m_bodyC.m_islandIndex;
this.m_indexD = this.m_bodyD.m_islandIndex;
this.m_lcA.Assign(this.m_bodyA.m_sweep.localCenter);
this.m_lcB.Assign(this.m_bodyB.m_sweep.localCenter);
this.m_lcC.Assign(this.m_bodyC.m_sweep.localCenter);
this.m_lcD.Assign(this.m_bodyD.m_sweep.localCenter);
this.m_mA = this.m_bodyA.m_invMass;
this.m_mB = this.m_bodyB.m_invMass;
this.m_mC = this.m_bodyC.m_invMass;
this.m_mD = this.m_bodyD.m_invMass;
this.m_iA = this.m_bodyA.m_invI;
this.m_iB = this.m_bodyB.m_invI;
this.m_iC = this.m_bodyC.m_invI;
this.m_iD = this.m_bodyD.m_invI;
var aA = data.positions[this.m_indexA].a;
var vA = data.velocities[this.m_indexA].v.Clone();
var wA = data.velocities[this.m_indexA].w;
var aB = data.positions[this.m_indexB].a;
var vB = data.velocities[this.m_indexB].v.Clone();
var wB = data.velocities[this.m_indexB].w;
var aC = data.positions[this.m_indexC].a;
var vC = data.velocities[this.m_indexC].v.Clone();
var wC = data.velocities[this.m_indexC].w;
var aD = data.positions[this.m_indexD].a;
var vD = data.velocities[this.m_indexD].v.Clone();
var wD = data.velocities[this.m_indexD].w;
var qA = new b2Rot(aA),
qB = new b2Rot(aB),
qC = new b2Rot(aC),
qD = new b2Rot(aD);
this.m_mass = 0;
if (this.m_typeA == b2Joint.e_revoluteJoint) {
this.m_JvAC.SetZero();
this.m_JwA = 1;
this.m_JwC = 1;
this.m_mass += this.m_iA + this.m_iC
} else {
var u = b2Mul_r_v2(qC, this.m_localAxisC);
var rC = b2Mul_r_v2(qC, b2Vec2.Subtract(this.m_localAnchorC, this.m_lcC));
var rA = b2Mul_r_v2(qA, b2Vec2.Subtract(this.m_localAnchorA, this.m_lcA));
this.m_JvAC.Assign(u);
this.m_JwC = b2Cross_v2_v2(rC, u);
this.m_JwA = b2Cross_v2_v2(rA, u);
this.m_mass += this.m_mC + this.m_mA + this.m_iC * this.m_JwC * this.m_JwC + this.m_iA * this.m_JwA * this.m_JwA
}
if (this.m_typeB == b2Joint.e_revoluteJoint) {
this.m_JvBD.SetZero();
this.m_JwB = this.m_ratio;
this.m_JwD = this.m_ratio;
this.m_mass += this.m_ratio * this.m_ratio * (this.m_iB + this.m_iD)
} else {
var u = b2Mul_r_v2(qD, this.m_localAxisD);
var rD = b2Mul_r_v2(qD, b2Vec2.Subtract(this.m_localAnchorD, this.m_lcD));
var rB = b2Mul_r_v2(qB, b2Vec2.Subtract(this.m_localAnchorB, this.m_lcB));
this.m_JvBD.Assign(b2Vec2.Multiply(this.m_ratio, u));
this.m_JwD = this.m_ratio * b2Cross_v2_v2(rD, u);
this.m_JwB = this.m_ratio * b2Cross_v2_v2(rB, u);
this.m_mass += this.m_ratio * this.m_ratio * (this.m_mD + this.m_mB) + this.m_iD * this.m_JwD * this.m_JwD + this.m_iB * this.m_JwB * this.m_JwB
}
this.m_mass = this.m_mass > 0 ? 1 / this.m_mass : 0;
if (data.step.warmStarting) {
vA.Add(b2Vec2.Multiply((this.m_mA * this.m_impulse), this.m_JvAC));
wA += this.m_iA * this.m_impulse * this.m_JwA;
vB.Add(b2Vec2.Multiply((this.m_mB * this.m_impulse), this.m_JvBD));
wB += this.m_iB * this.m_impulse * this.m_JwB;
vC.Subtract(b2Vec2.Multiply((this.m_mC * this.m_impulse), this.m_JvAC));
wC -= this.m_iC * this.m_impulse * this.m_JwC;
vD.Subtract(b2Vec2.Multiply((this.m_mD * this.m_impulse), this.m_JvBD));
wD -= this.m_iD * this.m_impulse * this.m_JwD
} else {
this.m_impulse = 0
}
data.velocities[this.m_indexA].v.Assign(vA);
data.velocities[this.m_indexA].w = wA;
data.velocities[this.m_indexB].v.Assign(vB);
data.velocities[this.m_indexB].w = wB;
data.velocities[this.m_indexC].v.Assign(vC);
data.velocities[this.m_indexC].w = wC;
data.velocities[this.m_indexD].v.Assign(vD);
data.velocities[this.m_indexD].w = wD
},
SolveVelocityConstraints: function (data) {
var vA = data.velocities[this.m_indexA].v.Clone();
var wA = data.velocities[this.m_indexA].w;
var vB = data.velocities[this.m_indexB].v.Clone();
var wB = data.velocities[this.m_indexB].w;
var vC = data.velocities[this.m_indexC].v.Clone();
var wC = data.velocities[this.m_indexC].w;
var vD = data.velocities[this.m_indexD].v.Clone();
var wD = data.velocities[this.m_indexD].w;
var Cdot = b2Dot_v2_v2(this.m_JvAC, b2Vec2.Subtract(vA, vC)) + b2Dot_v2_v2(this.m_JvBD, b2Vec2.Subtract(vB, vD));
Cdot += (this.m_JwA * wA - this.m_JwC * wC) + (this.m_JwB * wB - this.m_JwD * wD);
var impulse = -this.m_mass * Cdot;
this.m_impulse += impulse;
vA.Add(b2Vec2.Multiply((this.m_mA * impulse), this.m_JvAC));
wA += this.m_iA * impulse * this.m_JwA;
vB.Add(b2Vec2.Multiply((this.m_mB * impulse), this.m_JvBD));
wB += this.m_iB * impulse * this.m_JwB;
vC.Subtract(b2Vec2.Multiply((this.m_mC * impulse), this.m_JvAC));
wC -= this.m_iC * impulse * this.m_JwC;
vD.Subtract(b2Vec2.Multiply((this.m_mD * impulse), this.m_JvBD));
wD -= this.m_iD * impulse * this.m_JwD;
data.velocities[this.m_indexA].v.Assign(vA);
data.velocities[this.m_indexA].w = wA;
data.velocities[this.m_indexB].v.Assign(vB);
data.velocities[this.m_indexB].w = wB;
data.velocities[this.m_indexC].v.Assign(vC);
data.velocities[this.m_indexC].w = wC;
data.velocities[this.m_indexD].v.Assign(vD);
data.velocities[this.m_indexD].w = wD
},
SolvePositionConstraints: function (data) {
var cA = data.positions[this.m_indexA].c.Clone();
var aA = data.positions[this.m_indexA].a;
var cB = data.positions[this.m_indexB].c.Clone();
var aB = data.positions[this.m_indexB].a;
var cC = data.positions[this.m_indexC].c.Clone();
var aC = data.positions[this.m_indexC].a;
var cD = data.positions[this.m_indexD].c.Clone();
var aD = data.positions[this.m_indexD].a;
var qA = new b2Rot(aA),
qB = new b2Rot(aB),
qC = new b2Rot(aC),
qD = new b2Rot(aD);
var linearError = 0;
var coordinateA, coordinateB;
var JvAC = new b2Vec2(),
JvBD = new b2Vec2();
var JwA, JwB, JwC, JwD;
var mass = 0;
if (this.m_typeA == b2Joint.e_revoluteJoint) {
JvAC.SetZero();
JwA = 1;
JwC = 1;
mass += this.m_iA + this.m_iC;
coordinateA = aA - aC - this.m_referenceAngleA
} else {
var u = b2Mul_r_v2(qC, this.m_localAxisC);
var rC = b2Mul_r_v2(qC, b2Vec2.Subtract(this.m_localAnchorC, this.m_lcC));
var rA = b2Mul_r_v2(qA, b2Vec2.Subtract(this.m_localAnchorA, this.m_lcA));
JvAC.Assign(u);
JwC = b2Cross_v2_v2(rC, u);
JwA = b2Cross_v2_v2(rA, u);
mass += this.m_mC + this.m_mA + this.m_iC * JwC * JwC + this.m_iA * JwA * JwA;
var pC = b2Vec2.Subtract(this.m_localAnchorC, this.m_lcC);
var pA = b2MulT_r_v2(qC, b2Vec2.Add(rA, b2Vec2.Subtract(cA, cC)));
coordinateA = b2Dot_v2_v2(b2Vec2.Subtract(pA, pC), this.m_localAxisC)
}
if (this.m_typeB == b2Joint.e_revoluteJoint) {
JvBD.SetZero();
JwB = this.m_ratio;
JwD = this.m_ratio;
mass += this.m_ratio * this.m_ratio * (this.m_iB + this.m_iD);
coordinateB = aB - aD - this.m_referenceAngleB
} else {
var u = b2Mul_r_v2(qD, this.m_localAxisD);
var rD = b2Mul_r_v2(qD, b2Vec2.Subtract(this.m_localAnchorD, this.m_lcD));
var rB = b2Mul_r_v2(qB, b2Vec2.Subtract(this.m_localAnchorB, this.m_lcB));
JvBD.Assign(b2Vec2.Multiply(this.m_ratio, u));
JwD = this.m_ratio * b2Cross_v2_v2(rD, u);
JwB = this.m_ratio * b2Cross_v2_v2(rB, u);
mass += this.m_ratio * this.m_ratio * (this.m_mD + this.m_mB) + this.m_iD * JwD * JwD + this.m_iB * JwB * JwB;
var pD = b2Vec2.Subtract(this.m_localAnchorD, this.m_lcD);
var pB = b2MulT_r_v2(qD, b2Vec2.Add(rB, b2Vec2.Subtract(cB, cD)));
coordinateB = b2Dot_v2_v2(b2Vec2.Subtract(pB, pD), this.m_localAxisD)
}
var C = (coordinateA + this.m_ratio * coordinateB) - this.m_constant;
var impulse = 0;
if (mass > 0) {
impulse = -C / mass
}
cA.Add(b2Vec2.Multiply(this.m_mA, b2Vec2.Multiply(impulse, JvAC)));
aA += this.m_iA * impulse * JwA;
cB.Add(b2Vec2.Multiply(this.m_mB, b2Vec2.Multiply(impulse, JvBD)));
aB += this.m_iB * impulse * JwB;
cC.Subtract(b2Vec2.Multiply(this.m_mC, b2Vec2.Multiply(impulse, JvAC)));
aC -= this.m_iC * impulse * JwC;
cD.Subtract(b2Vec2.Multiply(this.m_mD, b2Vec2.Multiply(impulse, JvBD)));
aD -= this.m_iD * impulse * JwD;
data.positions[this.m_indexA].c.Assign(cA);
data.positions[this.m_indexA].a = aA;
data.positions[this.m_indexB].c.Assign(cB);
data.positions[this.m_indexB].a = aB;
data.positions[this.m_indexC].c.Assign(cC);
data.positions[this.m_indexC].a = aC;
data.positions[this.m_indexD].c.Assign(cD);
data.positions[this.m_indexD].a = aD;
return linearError < b2_linearSlop
},
_serialize: function (out) {
var obj = out || {};
this.parent.prototype._serialize.call(this, obj);
obj.joint1 = this.m_joint1.__temp_joint_id;
obj.joint2 = this.m_joint2.__temp_joint_id;
obj.ratio = this.m_ratio;
return obj
}
};
b2GearJoint._extend(b2Joint);
function b2MotorJointDef() {
this.parent.call(this);
this.type = b2Joint.e_motorJoint;
this.linearOffset = new b2Vec2();
this.angularOffset = 0;
this.maxForce = 1;
this.maxTorque = 1;
this.correctionFactor = 0.3;
Object.seal(this)
}
b2MotorJointDef.prototype = {
Initialize: function (bA, bB) {
this.bodyA = bA;
this.bodyB = bB;
var xB = this.bodyB.GetPosition();
this.linearOffset.Assign(this.bodyA.GetLocalPoint(xB));
var angleA = this.bodyA.GetAngle();
var angleB = this.bodyB.GetAngle();
this.angularOffset = angleB - angleA
},
_deserialize: function (data, bodies, joints) {
this.parent.prototype._deserialize.call(this, data, bodies, joints);
this.linearOffset._deserialize(data.linearOffset);
this.angularOffset = data.angularOffset;
this.maxForce = data.maxForce;
this.maxTorque = data.maxTorque;
this.correctionFactor = data.correctionFactor
}
};
b2MotorJointDef._extend(b2JointDef);
function b2MotorJoint(def) {
this.parent.call(this, def);
this.m_linearOffset = def.linearOffset.Clone();
this.m_angularOffset = def.angularOffset;
this.m_linearImpulse = new b2Vec2();
this.m_angularImpulse = 0;
this.m_maxForce = def.maxForce;
this.m_maxTorque = def.maxTorque;
this.m_correctionFactor = def.correctionFactor;
this.m_indexA = 0;
this.m_indexB = 0;
this.m_rA = new b2Vec2();
this.m_rB = new b2Vec2();
this.m_localCenterA = new b2Vec2();
this.m_localCenterB = new b2Vec2();
this.m_linearError = new b2Vec2();
this.m_angularError = 0;
this.m_invMassA = 0;
this.m_invMassB = 0;
this.m_invIA = 0;
this.m_invIB = 0;
this.m_linearMass = new b2Mat22();
this.m_angularMass = 0
}
b2MotorJoint.prototype = {
GetAnchorA: function () {
return this.m_bodyA.GetPosition()
},
GetAnchorB: function () {
return this.m_bodyB.GetPosition()
},
GetReactionForce: function (inv_dt) {
return b2Vec2.Multiply(inv_dt, this.m_linearImpulse)
},
GetReactionTorque: function (inv_dt) {
return inv_dt * this.m_angularImpulse
},
SetLinearOffset: function (linearOffset) {
if (linearOffset.x != this.m_linearOffset.x || linearOffset.y != this.m_linearOffset.y) {
this.m_bodyA.SetAwake(true);
this.m_bodyB.SetAwake(true);
this.m_linearOffset.Assign(linearOffset)
}
},
GetLinearOffset: function () {
return this.m_linearOffset
},
SetAngularOffset: function (angularOffset) {
if (angularOffset != this.m_angularOffset) {
this.m_bodyA.SetAwake(true);
this.m_bodyB.SetAwake(true);
this.m_angularOffset = angularOffset
}
},
GetAngularOffset: function () {
return this.m_angularOffset
},
SetMaxForce: function (force) {
this.m_maxForce = force
},
GetMaxForce: function () {
return this.m_maxForce
},
SetMaxTorque: function (torque) {
this.m_maxTorque = torque
},
GetMaxTorque: function () {
return this.m_maxTorque
},
SetCorrectionFactor: function (factor) {
this.m_correctionFactor = factor
},
GetCorrectionFactor: function () {
return this.m_correctionFactor
},
InitVelocityConstraints: function (data) {
this.m_indexA = this.m_bodyA.m_islandIndex;
this.m_indexB = this.m_bodyB.m_islandIndex;
this.m_localCenterA.Assign(this.m_bodyA.m_sweep.localCenter);
this.m_localCenterB.Assign(this.m_bodyB.m_sweep.localCenter);
this.m_invMassA = this.m_bodyA.m_invMass;
this.m_invMassB = this.m_bodyB.m_invMass;
this.m_invIA = this.m_bodyA.m_invI;
this.m_invIB = this.m_bodyB.m_invI;
var cA = data.positions[this.m_indexA].c.Clone();
var aA = data.positions[this.m_indexA].a;
var vA = data.velocities[this.m_indexA].v.Clone();
var wA = data.velocities[this.m_indexA].w;
var cB = data.positions[this.m_indexB].c.Clone();
var aB = data.positions[this.m_indexB].a;
var vB = data.velocities[this.m_indexB].v.Clone();
var wB = data.velocities[this.m_indexB].w;
var qA = new b2Rot(aA),
qB = new b2Rot(aB);
this.m_rA.Assign(b2Mul_r_v2(qA, this.m_localCenterA.Negate()));
this.m_rB.Assign(b2Mul_r_v2(qB, this.m_localCenterB.Negate()));
var mA = this.m_invMassA,
mB = this.m_invMassB;
var iA = this.m_invIA,
iB = this.m_invIB;
var K = new b2Mat22();
K.ex.x = mA + mB + iA * this.m_rA.y * this.m_rA.y + iB * this.m_rB.y * this.m_rB.y;
K.ex.y = -iA * this.m_rA.x * this.m_rA.y - iB * this.m_rB.x * this.m_rB.y;
K.ey.x = K.ex.y;
K.ey.y = mA + mB + iA * this.m_rA.x * this.m_rA.x + iB * this.m_rB.x * this.m_rB.x;
this.m_linearMass.Assign(K.GetInverse());
this.m_angularMass = iA + iB;
if (this.m_angularMass > 0) {
this.m_angularMass = 1 / this.m_angularMass
}
this.m_linearError.Assign(b2Vec2.Subtract(b2Vec2.Subtract(b2Vec2.Subtract(b2Vec2.Add(cB, this.m_rB), cA), this.m_rA), b2Mul_r_v2(qA, this.m_linearOffset)));
this.m_angularError = aB - aA - this.m_angularOffset;
if (data.step.warmStarting) {
this.m_linearImpulse.Multiply(data.step.dtRatio);
this.m_angularImpulse *= data.step.dtRatio;
var P = new b2Vec2(this.m_linearImpulse.x, this.m_linearImpulse.y);
vA.Subtract(b2Vec2.Multiply(mA, P));
wA -= iA * (b2Cross_v2_v2(this.m_rA, P) + this.m_angularImpulse);
vB.Add(b2Vec2.Multiply(mB, P));
wB += iB * (b2Cross_v2_v2(this.m_rB, P) + this.m_angularImpulse)
} else {
this.m_linearImpulse.SetZero();
this.m_angularImpulse = 0
}
data.velocities[this.m_indexA].v.Assign(vA);
data.velocities[this.m_indexA].w = wA;
data.velocities[this.m_indexB].v.Assign(vB);
data.velocities[this.m_indexB].w = wB
},
SolveVelocityConstraints: function (data) {
var vA = data.velocities[this.m_indexA].v.Clone();
var wA = data.velocities[this.m_indexA].w;
var vB = data.velocities[this.m_indexB].v.Clone();
var wB = data.velocities[this.m_indexB].w;
var mA = this.m_invMassA,
mB = this.m_invMassB;
var iA = this.m_invIA,
iB = this.m_invIB;
var h = data.step.dt;
var inv_h = data.step.inv_dt;
var Cdot = wB - wA + inv_h * this.m_correctionFactor * this.m_angularError;
var impulse = -this.m_angularMass * Cdot;
var oldImpulse = this.m_angularImpulse;
var maxImpulse = h * this.m_maxTorque;
this.m_angularImpulse = b2Clamp(this.m_angularImpulse + impulse, -maxImpulse, maxImpulse);
impulse = this.m_angularImpulse - oldImpulse;
wA -= iA * impulse;
wB += iB * impulse;
var Cdot = b2Vec2.Add(b2Vec2.Subtract(b2Vec2.Subtract(b2Vec2.Add(vB, b2Cross_f_v2(wB, this.m_rB)), vA), b2Cross_f_v2(wA, this.m_rA)), b2Vec2.Multiply(inv_h, b2Vec2.Multiply(this.m_correctionFactor, this.m_linearError)));
var impulse = b2Mul_m22_v2(this.m_linearMass, Cdot).Negate();
var oldImpulse = this.m_linearImpulse;
this.m_linearImpulse.Add(impulse);
var maxImpulse = h * this.m_maxForce;
if (this.m_linearImpulse.LengthSquared() > maxImpulse * maxImpulse) {
this.m_linearImpulse.Normalize();
this.m_linearImpulse.Multiply(maxImpulse)
}
impulse.Assign(b2Vec2.Subtract(this.m_linearImpulse, oldImpulse));
vA.Subtract(b2Vec2.Multiply(mA, impulse));
wA -= iA * b2Cross_v2_v2(this.m_rA, impulse);
vB.Add(b2Vec2.Multiply(mB, impulse));
wB += iB * b2Cross_v2_v2(this.m_rB, impulse);
data.velocities[this.m_indexA].v.Assign(vA);
data.velocities[this.m_indexA].w = wA;
data.velocities[this.m_indexB].v.Assign(vB);
data.velocities[this.m_indexB].w = wB
},
SolvePositionConstraints: function (data) {
return true
},
_serialize: function (out) {
var obj = out || {};
this.parent.prototype._serialize.call(this, obj);
obj.linearOffset = this.m_linearOffset._serialize();
obj.angularOffset = this.m_angularOffset;
obj.maxForce = this.m_maxForce;
obj.maxTorque = this.m_maxTorque;
obj.correctionFactor = this.m_correctionFactor;
return obj
}
};
b2MotorJoint._extend(b2Joint);
var b2_minPulleyLength = 2;
function b2PulleyJointDef() {
this.parent.call(this);
this.type = b2Joint.e_pulleyJoint;
this.groundAnchorA = new b2Vec2(-1, 1);
this.groundAnchorB = new b2Vec2(1, 1);
this.localAnchorA = new b2Vec2(-1, 0);
this.localAnchorB = new b2Vec2(1, 0);
this.lengthA = 0;
this.lengthB = 0;
this.ratio = 1;
this.collideConnected = true;
Object.seal(this)
}
b2PulleyJointDef.prototype = {
Initialize: function (bA, bB, groundA, groundB, anchorA, anchorB, r) {
this.bodyA = bA;
this.bodyB = bB;
this.groundAnchorA.Assign(groundA);
this.groundAnchorB.Assign(groundB);
this.localAnchorA.Assign(this.bodyA.GetLocalPoint(anchorA));
this.localAnchorB.Assign(this.bodyB.GetLocalPoint(anchorB));
var dA = b2Vec2.Subtract(anchorA, groundA);
this.lengthA = dA.Length();
var dB = b2Vec2.Subtract(anchorB, groundB);
this.lengthB = dB.Length();
this.ratio = r
},
_deserialize: function (data, bodies, joints) {
this.parent.prototype._deserialize.call(this, data, bodies, joints);
this.groundAnchorA._deserialize(data.groundAnchorA);
this.groundAnchorB._deserialize(data.groundAnchorB);
this.localAnchorA._deserialize(data.localAnchorA);
this.localAnchorB._deserialize(data.localAnchorB);
this.lengthA = data.lengthA;
this.lengthB = data.lengthB;
this.ratio = data.ratio
}
};
b2PulleyJointDef._extend(b2JointDef);
function b2PulleyJoint(def) {
this.parent.call(this, def);
this.m_indexA = 0;
this.m_indexB = 0;
this.m_uA = new b2Vec2();
this.m_uB = new b2Vec2();
this.m_rA = new b2Vec2();
this.m_rB = new b2Vec2();
this.m_localCenterA = new b2Vec2();
this.m_localCenterB = new b2Vec2();
this.m_invMassA = 0;
this.m_invMassB = 0;
this.m_invIA = 0;
this.m_invIB = 0;
this.m_mass = 0;
this.m_groundAnchorA = def.groundAnchorA.Clone();
this.m_groundAnchorB = def.groundAnchorB.Clone();
this.m_localAnchorA = def.localAnchorA.Clone();
this.m_localAnchorB = def.localAnchorB.Clone();
this.m_lengthA = def.lengthA;
this.m_lengthB = def.lengthB;
this.m_ratio = def.ratio;
this.m_constant = def.lengthA + this.m_ratio * def.lengthB;
this.m_impulse = 0
}
b2PulleyJoint.prototype = {
GetAnchorA: function () {
return this.m_bodyA.GetWorldPoint(this.m_localAnchorA)
},
GetAnchorB: function () {
return this.m_bodyB.GetWorldPoint(this.m_localAnchorB)
},
GetReactionForce: function (inv_dt) {
var P = b2Vec2.Multiply(this.m_impulse, this.m_uB);
return b2Vec2.Multiply(inv_dt, P)
},
GetReactionTorque: function (inv_dt) {
return 0
},
GetGroundAnchorA: function () {
return this.m_groundAnchorA
},
GetGroundAnchorB: function () {
return this.m_groundAnchorB
},
GetLengthA: function () {
return this.m_lengthA
},
GetLengthB: function () {
return this.m_lengthB
},
GetRatio: function () {
return this.m_ratio
},
GetCurrentLengthA: function () {
var p = this.m_bodyA.GetWorldPoint(this.m_localAnchorA);
var s = this.m_groundAnchorA;
var d = b2Vec2.Subtract(p, s);
return d.Length()
},
GetCurrentLengthB: function () {
var p = this.m_bodyB.GetWorldPoint(this.m_localAnchorB);
var s = this.m_groundAnchorB;
var d = b2Vec2.Subtract(p, s);
return d.Length()
},
ShiftOrigin: function (newOrigin) {
this.m_groundAnchorA.Subtract(newOrigin);
this.m_groundAnchorB.Subtract(newOrigin)
},
InitVelocityConstraints: function (data) {
this.m_indexA = this.m_bodyA.m_islandIndex;
this.m_indexB = this.m_bodyB.m_islandIndex;
this.m_localCenterA.Assign(this.m_bodyA.m_sweep.localCenter);
this.m_localCenterB.Assign(this.m_bodyB.m_sweep.localCenter);
this.m_invMassA = this.m_bodyA.m_invMass;
this.m_invMassB = this.m_bodyB.m_invMass;
this.m_invIA = this.m_bodyA.m_invI;
this.m_invIB = this.m_bodyB.m_invI;
var cA = data.positions[this.m_indexA].c.Clone();
var aA = data.positions[this.m_indexA].a;
var vA = data.velocities[this.m_indexA].v.Clone();
var wA = data.velocities[this.m_indexA].w;
var cB = data.positions[this.m_indexB].c.Clone();
var aB = data.positions[this.m_indexB].a;
var vB = data.velocities[this.m_indexB].v.Clone();
var wB = data.velocities[this.m_indexB].w;
var qA = new b2Rot(aA),
qB = new b2Rot(aB);
this.m_rA.Assign(b2Mul_r_v2(qA, b2Vec2.Subtract(this.m_localAnchorA, this.m_localCenterA)));
this.m_rB.Assign(b2Mul_r_v2(qB, b2Vec2.Subtract(this.m_localAnchorB, this.m_localCenterB)));
this.m_uA.Assign(b2Vec2.Add(cA, b2Vec2.Subtract(this.m_rA, this.m_groundAnchorA)));
this.m_uB.Assign(b2Vec2.Add(cB, b2Vec2.Subtract(this.m_rB, this.m_groundAnchorB)));
var lengthA = this.m_uA.Length();
var lengthB = this.m_uB.Length();
if (lengthA > 10 * b2_linearSlop) {
this.m_uA.Multiply(1 / lengthA)
} else {
this.m_uA.SetZero()
}
if (lengthB > 10 * b2_linearSlop) {
this.m_uB.Multiply(1 / lengthB)
} else {
this.m_uB.SetZero()
}
var ruA = b2Cross_v2_v2(this.m_rA, this.m_uA);
var ruB = b2Cross_v2_v2(this.m_rB, this.m_uB);
var mA = this.m_invMassA + this.m_invIA * ruA * ruA;
var mB = this.m_invMassB + this.m_invIB * ruB * ruB;
this.m_mass = mA + this.m_ratio * this.m_ratio * mB;
if (this.m_mass > 0) {
this.m_mass = 1 / this.m_mass
}
if (data.step.warmStarting) {
this.m_impulse *= data.step.dtRatio;
var PA = b2Vec2.Multiply(-(this.m_impulse), this.m_uA);
var PB = b2Vec2.Multiply((-this.m_ratio * this.m_impulse), this.m_uB);
vA.Add(b2Vec2.Multiply(this.m_invMassA, PA));
wA += this.m_invIA * b2Cross_v2_v2(this.m_rA, PA);
vB.Add(b2Vec2.Multiply(this.m_invMassB, PB));
wB += this.m_invIB * b2Cross_v2_v2(this.m_rB, PB)
} else {
this.m_impulse = 0
}
data.velocities[this.m_indexA].v.Assign(vA);
data.velocities[this.m_indexA].w = wA;
data.velocities[this.m_indexB].v.Assign(vB);
data.velocities[this.m_indexB].w = wB
},
SolveVelocityConstraints: function (data) {
var vA = data.velocities[this.m_indexA].v.Clone();
var wA = data.velocities[this.m_indexA].w;
var vB = data.velocities[this.m_indexB].v.Clone();
var wB = data.velocities[this.m_indexB].w;
var vpA = b2Vec2.Add(vA, b2Cross_f_v2(wA, this.m_rA));
var vpB = b2Vec2.Add(vB, b2Cross_f_v2(wB, this.m_rB));
var Cdot = -b2Dot_v2_v2(this.m_uA, vpA) - this.m_ratio * b2Dot_v2_v2(this.m_uB, vpB);
var impulse = -this.m_mass * Cdot;
this.m_impulse += impulse;
var PA = b2Vec2.Multiply(-impulse, this.m_uA);
var PB = b2Vec2.Multiply(-this.m_ratio, b2Vec2.Multiply(impulse, this.m_uB));
vA.Add(b2Vec2.Multiply(this.m_invMassA, PA));
wA += this.m_invIA * b2Cross_v2_v2(this.m_rA, PA);
vB.Add(b2Vec2.Multiply(this.m_invMassB, PB));
wB += this.m_invIB * b2Cross_v2_v2(this.m_rB, PB);
data.velocities[this.m_indexA].v.Assign(vA);
data.velocities[this.m_indexA].w = wA;
data.velocities[this.m_indexB].v.Assign(vB);
data.velocities[this.m_indexB].w = wB
},
SolvePositionConstraints: function (data) {
var cA = data.positions[this.m_indexA].c.Clone();
var aA = data.positions[this.m_indexA].a;
var cB = data.positions[this.m_indexB].c.Clone();
var aB = data.positions[this.m_indexB].a;
var qA = new b2Rot(aA),
qB = new b2Rot(aB);
var rA = b2Mul_r_v2(qA, b2Vec2.Subtract(this.m_localAnchorA, this.m_localCenterA));
var rB = b2Mul_r_v2(qB, b2Vec2.Subtract(this.m_localAnchorB, this.m_localCenterB));
var uA = b2Vec2.Add(cA, b2Vec2.Subtract(rA, this.m_groundAnchorA));
var uB = b2Vec2.Add(cB, b2Vec2.Subtract(rB, this.m_groundAnchorB));
var lengthA = uA.Length();
var lengthB = uB.Length();
if (lengthA > 10 * b2_linearSlop) {
uA.Multiply(1 / lengthA)
} else {
uA.SetZero()
}
if (lengthB > 10 * b2_linearSlop) {
uB.Multiply(1 / lengthB)
} else {
uB.SetZero()
}
var ruA = b2Cross_v2_v2(rA, uA);
var ruB = b2Cross_v2_v2(rB, uB);
var mA = this.m_invMassA + this.m_invIA * ruA * ruA;
var mB = this.m_invMassB + this.m_invIB * ruB * ruB;
var mass = mA + this.m_ratio * this.m_ratio * mB;
if (mass > 0) {
mass = 1 / mass
}
var C = this.m_constant - lengthA - this.m_ratio * lengthB;
var linearError = b2Abs(C);
var impulse = -mass * C;
var PA = b2Vec2.Multiply(-impulse, uA);
var PB = b2Vec2.Multiply(-this.m_ratio, b2Vec2.Multiply(impulse, uB));
cA.Add(b2Vec2.Multiply(this.m_invMassA, PA));
aA += this.m_invIA * b2Cross_v2_v2(rA, PA);
cB.Add(b2Vec2.Multiply(this.m_invMassB, PB));
aB += this.m_invIB * b2Cross_v2_v2(rB, PB);
data.positions[this.m_indexA].c.Assign(cA);
data.positions[this.m_indexA].a = aA;
data.positions[this.m_indexB].c.Assign(cB);
data.positions[this.m_indexB].a = aB;
return linearError < b2_linearSlop
},
_serialize: function (out) {
var obj = out || {};
this.parent.prototype._serialize.call(this, obj);
obj.groundAnchorA = this.m_groundAnchorA._serialize();
obj.groundAnchorB = this.m_groundAnchorB._serialize();
obj.localAnchorA = this.m_localAnchorA._serialize();
obj.localAnchorB = this.m_localAnchorB._serialize();
obj.lengthA = this.m_lengthA;
obj.lengthB = this.m_lengthB;
obj.ratio = this.m_ratio;
return obj
}
};
b2PulleyJoint._extend(b2Joint);
function b2RopeJointDef() {
this.parent.call(this);
this.type = b2Joint.e_ropeJoint;
this.localAnchorA = new b2Vec2(-1, 0);
this.localAnchorB = new b2Vec2(1, 0);
this.maxLength = 0;
Object.seal(this)
}
b2RopeJointDef.prototype = {
_deserialize: function (data, bodies, joints) {
this.parent.prototype._deserialize.call(this, data, bodies, joints);
this.localAnchorA._deserialize(data.localAnchorA);
this.localAnchorB._deserialize(data.localAnchorB);
this.maxLength = data.maxLength
}
};
b2RopeJointDef._extend(b2JointDef);
function b2RopeJoint(def) {
this.parent.call(this, def);
this.m_localAnchorA = def.localAnchorA.Clone();
this.m_localAnchorB = def.localAnchorB.Clone();
this.m_maxLength = def.maxLength;
this.m_mass = 0;
this.m_impulse = 0;
this.m_state = b2Joint.e_inactiveLimit;
this.m_length = 0;
this.m_indexA = 0;
this.m_indexB = 0;
this.m_u = new b2Vec2();
this.m_rA = new b2Vec2();
this.m_rB = new b2Vec2();
this.m_localCenterA = new b2Vec2();
this.m_localCenterB = new b2Vec2();
this.m_invMassA = 0;
this.m_invMassB = 0;
this.m_invIA = 0;
this.m_invIB = 0
}
b2RopeJoint.prototype = {
GetAnchorA: function () {
return this.m_bodyA.GetWorldPoint(this.m_localAnchorA)
},
GetAnchorB: function () {
return this.m_bodyB.GetWorldPoint(this.m_localAnchorB)
},
GetReactionForce: function (inv_dt) {
var F = b2Vec2.Multiply((inv_dt * this.m_impulse), this.m_u);
return F
},
GetReactionTorque: function (inv_dt) {
return 0
},
GetLocalAnchorA: function () {
return this.m_localAnchorA
},
GetLocalAnchorB: function () {
return this.m_localAnchorB
},
SetMaxLength: function (length) {
this.m_maxLength = length
},
GetMaxLength: function () {
return this.m_maxLength
},
GetLimitState: function () {
return this.m_state
},
InitVelocityConstraints: function (data) {
this.m_indexA = this.m_bodyA.m_islandIndex;
this.m_indexB = this.m_bodyB.m_islandIndex;
this.m_localCenterA.Assign(this.m_bodyA.m_sweep.localCenter);
this.m_localCenterB.Assign(this.m_bodyB.m_sweep.localCenter);
this.m_invMassA = this.m_bodyA.m_invMass;
this.m_invMassB = this.m_bodyB.m_invMass;
this.m_invIA = this.m_bodyA.m_invI;
this.m_invIB = this.m_bodyB.m_invI;
var cA = data.positions[this.m_indexA].c.Clone();
var aA = data.positions[this.m_indexA].a;
var vA = data.velocities[this.m_indexA].v.Clone();
var wA = data.velocities[this.m_indexA].w;
var cB = data.positions[this.m_indexB].c.Clone();
var aB = data.positions[this.m_indexB].a;
var vB = data.velocities[this.m_indexB].v.Clone();
var wB = data.velocities[this.m_indexB].w;
var qA = new b2Rot(aA),
qB = new b2Rot(aB);
this.m_rA.Assign(b2Mul_r_v2(qA, b2Vec2.Subtract(this.m_localAnchorA, this.m_localCenterA)));
this.m_rB.Assign(b2Mul_r_v2(qB, b2Vec2.Subtract(this.m_localAnchorB, this.m_localCenterB)));
this.m_u.Assign(b2Vec2.Subtract(b2Vec2.Subtract(b2Vec2.Add(cB, this.m_rB), cA), this.m_rA));
this.m_length = this.m_u.Length();
var C = this.m_length - this.m_maxLength;
if (C > 0) {
this.m_state = b2Joint.e_atUpperLimit
} else {
this.m_state = b2Joint.e_inactiveLimit
}
if (this.m_length > b2_linearSlop) {
this.m_u.Multiply(1 / this.m_length)
} else {
this.m_u.SetZero();
this.m_mass = 0;
this.m_impulse = 0;
return
}
var crA = b2Cross_v2_v2(this.m_rA, this.m_u);
var crB = b2Cross_v2_v2(this.m_rB, this.m_u);
var invMass = this.m_invMassA + this.m_invIA * crA * crA + this.m_invMassB + this.m_invIB * crB * crB;
this.m_mass = invMass != 0 ? 1 / invMass : 0;
if (data.step.warmStarting) {
this.m_impulse *= data.step.dtRatio;
var P = b2Vec2.Multiply(this.m_impulse, this.m_u);
vA.Subtract(b2Vec2.Multiply(this.m_invMassA, P));
wA -= this.m_invIA * b2Cross_v2_v2(this.m_rA, P);
vB.Add(b2Vec2.Multiply(this.m_invMassB, P));
wB += this.m_invIB * b2Cross_v2_v2(this.m_rB, P)
} else {
this.m_impulse = 0
}
data.velocities[this.m_indexA].v.Assign(vA);
data.velocities[this.m_indexA].w = wA;
data.velocities[this.m_indexB].v.Assign(vB);
data.velocities[this.m_indexB].w = wB
},
SolveVelocityConstraints: function (data) {
var vA = data.velocities[this.m_indexA].v.Clone();
var wA = data.velocities[this.m_indexA].w;
var vB = data.velocities[this.m_indexB].v.Clone();
var wB = data.velocities[this.m_indexB].w;
var vpA = b2Vec2.Add(vA, b2Cross_f_v2(wA, this.m_rA));
var vpB = b2Vec2.Add(vB, b2Cross_f_v2(wB, this.m_rB));
var C = this.m_length - this.m_maxLength;
var Cdot = b2Dot_v2_v2(this.m_u, b2Vec2.Subtract(vpB, vpA));
if (C < 0) {
Cdot += data.step.inv_dt * C
}
var impulse = -this.m_mass * Cdot;
var oldImpulse = this.m_impulse;
this.m_impulse = b2Min(0, this.m_impulse + impulse);
impulse = this.m_impulse - oldImpulse;
var P = b2Vec2.Multiply(impulse, this.m_u);
vA.Subtract(b2Vec2.Multiply(this.m_invMassA, P));
wA -= this.m_invIA * b2Cross_v2_v2(this.m_rA, P);
vB.Add(b2Vec2.Multiply(this.m_invMassB, P));
wB += this.m_invIB * b2Cross_v2_v2(this.m_rB, P);
data.velocities[this.m_indexA].v.Assign(vA);
data.velocities[this.m_indexA].w = wA;
data.velocities[this.m_indexB].v.Assign(vB);
data.velocities[this.m_indexB].w = wB
},
SolvePositionConstraints: function (data) {
var cA = data.positions[this.m_indexA].c.Clone();
var aA = data.positions[this.m_indexA].a;
var cB = data.positions[this.m_indexB].c.Clone();
var aB = data.positions[this.m_indexB].a;
var qA = new b2Rot(aA),
qB = new b2Rot(aB);
var rA = b2Mul_r_v2(qA, b2Vec2.Subtract(this.m_localAnchorA, this.m_localCenterA));
var rB = b2Mul_r_v2(qB, b2Vec2.Subtract(this.m_localAnchorB, this.m_localCenterB));
var u = b2Vec2.Subtract(b2Vec2.Subtract(b2Vec2.Add(cB, rB), cA), rA);
var length = u.Normalize();
var C = length - this.m_maxLength;
C = b2Clamp(C, 0, b2_maxLinearCorrection);
var impulse = -this.m_mass * C;
var P = b2Vec2.Multiply(impulse, u);
cA.Subtract(b2Vec2.Multiply(this.m_invMassA, P));
aA -= this.m_invIA * b2Cross_v2_v2(rA, P);
cB.Add(b2Vec2.Multiply(this.m_invMassB, P));
aB += this.m_invIB * b2Cross_v2_v2(rB, P);
data.positions[this.m_indexA].c.Assign(cA);
data.positions[this.m_indexA].a = aA;
data.positions[this.m_indexB].c.Assign(cB);
data.positions[this.m_indexB].a = aB;
return length - this.m_maxLength < b2_linearSlop
},
_serialize: function (out) {
var obj = out || {};
this.parent.prototype._serialize.call(this, obj);
obj.localAnchorA = this.m_localAnchorA._serialize();
obj.localAnchorB = this.m_localAnchorB._serialize();
obj.maxLength = this.m_maxLength;
return obj
}
};
b2RopeJoint._extend(b2Joint);
var expf = Math.exp;
function b2RopeDef() {
this.vertices = null;
this.count = 0;
this.masses = null;
this.gravity = new b2Vec2();
this.damping = 0.1;
this.k2 = 0.9;
this.k3 = 0.1
}
function b2Rope() {
this.m_count = 0;
this.m_ps = null;
this.m_p0s = null;
this.m_vs = null;
this.m_ims = null;
this.m_Ls = null;
this.m_as = null;
this.m_damping = 0;
this.m_gravity = new b2Vec2();
this.m_k2 = 1;
this.m_k3 = 0.1
}
b2Rope.prototype = {
Initialize: function (def) {
this.m_count = def.count;
this.m_ps = new Array(this.m_count);
this.m_p0s = new Array(this.m_count);
this.m_vs = new Array(this.m_count);
this.m_ims = new Array(this.m_count);
for (var i = 0; i < this.m_count; ++i) {
this.m_ps[i] = def.vertices[i].Clone();
this.m_p0s[i] = def.vertices[i].Clone();
this.m_vs[i] = new b2Vec2();
var m = def.masses[i];
if (m > 0) {
this.m_ims[i] = 1 / m
} else {
this.m_ims[i] = 0
}
}
var count2 = this.m_count - 1;
var count3 = this.m_count - 2;
this.m_Ls = new Array(count2);
this.m_as = new Array(count3);
for (var i = 0; i < count2; ++i) {
var p1 = this.m_ps[i];
var p2 = this.m_ps[i + 1];
this.m_Ls[i] = b2Distance(p1, p2)
}
for (var i = 0; i < count3; ++i) {
var p1 = this.m_ps[i];
var p2 = this.m_ps[i + 1];
var p3 = this.m_ps[i + 2];
var d1 = b2Vec2.Subtract(p2, p1);
var d2 = b2Vec2.Subtract(p3, p2);
var a = b2Cross_v2_v2(d1, d2);
var b = b2Dot_v2_v2(d1, d2);
this.m_as[i] = b2Atan2(a, b)
}
this.m_gravity = def.gravity.Clone();
this.m_damping = def.damping;
this.m_k2 = def.k2;
this.m_k3 = def.k3
},
Step: function (h, iterations) {
if (h == 0) {
return
}
var d = expf(-h * this.m_damping);
for (var i = 0; i < this.m_count; ++i) {
this.m_p0s[i].Assign(this.m_ps[i]);
if (this.m_ims[i] > 0) {
this.m_vs[i].Add(b2Vec2.Multiply(h, this.m_gravity))
}
this.m_vs[i].Multiply(d);
this.m_ps[i].Add(b2Vec2.Multiply(h, this.m_vs[i]))
}
for (var i = 0; i < iterations; ++i) {
this.SolveC2();
this.SolveC3();
this.SolveC2()
}
var inv_h = 1 / h;
for (var i = 0; i < this.m_count; ++i) {
this.m_vs[i] = b2Vec2.Multiply(inv_h, b2Vec2.Subtract(this.m_ps[i], this.m_p0s[i]))
}
},
GetVertexCount: function () {
return this.m_count
},
GetVertices: function () {
return this.m_ps
},
Draw: function (draw) {
var c = new b2Color(0.4, 0.5, 0.7);
for (var i = 0; i < this.m_count - 1; ++i) {
draw.DrawSegment(this.m_ps[i], this.m_ps[i + 1], c)
}
},
SetAngle: function (angle) {
var count3 = this.m_count - 2;
for (var i = 0; i < count3; ++i) {
this.m_as[i] = angle
}
},
SolveC2: function () {
var count2 = this.m_count - 1;
for (var i = 0; i < count2; ++i) {
var p1 = this.m_ps[i];
var p2 = this.m_ps[i + 1];
var d = b2Vec2.Subtract(p2, p1);
var L = d.Normalize();
var im1 = this.m_ims[i];
var im2 = this.m_ims[i + 1];
if (im1 + im2 == 0) {
continue
}
var s1 = im1 / (im1 + im2);
var s2 = im2 / (im1 + im2);
p1.Subtract(b2Vec2.Multiply(this.m_k2 * s1 * (this.m_Ls[i] - L), d));
p2.Add(b2Vec2.Multiply(this.m_k2 * s2 * (this.m_Ls[i] - L), d))
}
},
SolveC3: function () {
var count3 = this.m_count - 2;
for (var i = 0; i < count3; ++i) {
var p1 = this.m_ps[i];
var p2 = this.m_ps[i + 1];
var p3 = this.m_ps[i + 2];
var m1 = this.m_ims[i];
var m2 = this.m_ims[i + 1];
var m3 = this.m_ims[i + 2];
var d1 = b2Vec2.Subtract(p2, p1);
var d2 = b2Vec2.Subtract(p3, p2);
var L1sqr = d1.LengthSquared();
var L2sqr = d2.LengthSquared();
if (L1sqr * L2sqr == 0) {
continue
}
var a = b2Cross_v2_v2(d1, d2);
var b = b2Dot_v2_v2(d1, d2);
var angle = b2Atan2(a, b);
var Jd1 = b2Vec2.Multiply((-1 / L1sqr), d1.Skew());
var Jd2 = b2Vec2.Multiply((1 / L2sqr), d2.Skew());
var J1 = b2Vec2.Negate(Jd1);
var J2 = b2Vec2.Subtract(Jd1, Jd2);
var J3 = Jd2;
var mass = m1 * b2Dot_v2_v2(J1, J1) + m2 * b2Dot_v2_v2(J2, J2) + m3 * b2Dot_v2_v2(J3, J3);
if (mass == 0) {
continue
}
mass = 1 / mass;
var C = angle - this.m_as[i];
while (C > b2_pi) {
angle -= 2 * b2_pi;
C = angle - this.m_as[i]
}
while (C < -b2_pi) {
angle += 2 * b2_pi;
C = angle - this.m_as[i]
}
var impulse = -this.m_k3 * mass * C;
p1.Add(b2Vec2.Multiply((m1 * impulse), J1));
p2.Add(b2Vec2.Multiply((m2 * impulse), J2));
p3.Add(b2Vec2.Multiply((m3 * impulse), J3))
}
}
};
var b2JsonSerializer = {
serialize: function (world) {
var shapes = [];
var i;
var serialized;
var b;
var f;
var shape;
for (b = world.GetBodyList(); b; b = b.GetNext()) {
for (f = b.GetFixtureList(); f; f = f.GetNext()) {
shape = f.GetShape();
f.__temp_shape_id = shapes.length;
shapes.push(shape._serialize())
}
}
var fixtures = [];
for (b = world.GetBodyList(); b; b = b.GetNext()) {
b.__temp_fixture_ids = [];
for (f = b.GetFixtureList(); f; f = f.GetNext()) {
serialized = f._serialize();
serialized.shape = f.__temp_shape_id;
delete f.__temp_shape_id;
b.__temp_fixture_ids.push(fixtures.length);
fixtures.push(serialized)
}
}
var bodies = [];
for (b = world.GetBodyList(); b; b = b.GetNext()) {
serialized = b._serialize();
serialized.fixtures = [];
for (i = 0; i < b.__temp_fixture_ids.length; ++i) {
serialized.fixtures.push(b.__temp_fixture_ids[i])
}
delete b.__temp_fixture_ids;
b.__temp_body_id = bodies.length;
bodies.push(serialized)
}
var joints = [];
var j;
for (j = world.GetJointList(), i = 0; j; j = j.GetNext(), ++i) {
j.__temp_joint_id = i
}
for (j = world.GetJointList(); j; j = j.GetNext()) {
if (j.GetType() === b2Joint.e_mouseJoint) {
continue
}
serialized = j._serialize();
serialized.bodyA = j.GetBodyA().__temp_body_id;
serialized.bodyB = j.GetBodyB().__temp_body_id;
joints.push(serialized)
}
for (j = world.GetJointList(); j; j = j.GetNext()) {
delete j.__temp_joint_id
}
for (b = world.GetBodyList(); b; b = b.GetNext()) {
delete b.__temp_body_id
}
return {
shapes: shapes,
fixtures: fixtures,
bodies: bodies,
joints: joints
}
},
deserialize: function (serialized, world, clear) {
var deserialized = JSON.parse(serialized);
if (clear) {
for (var b = world.GetBodyList(); b;) {
var next = b.GetNext();
world.DestroyBody(b);
b = next
}
for (var j = world.GetJointList(); j;) {
var next = j.GetNext();
world.DestroyJoint(j);
j = next
}
}
var shapes = [];
for (var i = 0; i < deserialized.shapes.length; ++i) {
var shapeData = deserialized.shapes[i];
var shape;
switch (shapeData.m_type) {
case b2Shape.e_circle:
shape = new b2CircleShape();
break;
case b2Shape.e_edge:
shape = new b2EdgeShape();
break;
case b2Shape.e_chain:
shape = new b2ChainShape();
break;
case b2Shape.e_polygon:
shape = new b2PolygonShape();
break
}
shape._deserialize(shapeData);
shapes.push(shape)
}
var fixtures = [];
for (i = 0; i < deserialized.fixtures.length; ++i) {
var fixtureData = deserialized.fixtures[i];
var fixture = new b2FixtureDef();
fixture._deserialize(fixtureData);
fixture.shape = shapes[fixtureData.shape];
fixtures.push(fixture)
}
var bodies = [];
for (i = 0; i < deserialized.bodies.length; ++i) {
var bodyData = deserialized.bodies[i];
var def = new b2BodyDef();
def._deserialize(bodyData);
var body = world.CreateBody(def);
for (var x = 0; x < bodyData.fixtures.length; ++x) {
body.CreateFixture(fixtures[bodyData.fixtures[x]])
}
bodies.push(body)
}
var joints = [];
var gears = [];
for (i = 0; i < deserialized.joints.length; ++i) {
var jointData = deserialized.joints[i];
var jointDef;
switch (jointData.type) {
case b2Joint.e_revoluteJoint:
jointDef = new b2RevoluteJointDef();
break;
case b2Joint.e_prismaticJoint:
jointDef = new b2PrismaticJointDef();
break;
case b2Joint.e_distanceJoint:
jointDef = new b2DistanceJointDef();
break;
case b2Joint.e_pulleyJoint:
jointDef = new b2PulleyJointDef();
break;
case b2Joint.e_gearJoint:
jointDef = new b2GearJointDef();
break;
case b2Joint.e_wheelJoint:
jointDef = new b2WheelJointDef();
break;
case b2Joint.e_weldJoint:
jointDef = new b2WeldJointDef();
break;
case b2Joint.e_frictionJoint:
jointDef = new b2FrictionJointDef();
break;
case b2Joint.e_ropeJoint:
jointDef = new b2RopeJointDef();
break;
case b2Joint.e_motorJoint:
jointDef = new b2MotorJointDef();
break;
default:
throw new Error("unknown joint")
}
jointDef._deserialize(jointData, bodies);
if (jointData.type === b2Joint.e_gearJoint) {
gears.push([jointDef, joints.length]);
joints.push(null)
} else {
var joint = world.CreateJoint(jointDef);
joints.push(joint)
}
}
for (i = 0; i < gears.length; ++i) {
gears[i][0].joint1 = joints[gears[i][0].joint1];
gears[i][0].joint2 = joints[gears[i][0].joint2];
joint = world.CreateJoint(gears[i][0]);
joints[gears[i][1]] = joint
}
}
};
var b2RUBELoader = (function () {
function parseVector(obj) {
return new b2Vec2(obj ? (obj.x || 0) : 0, obj ? (obj.y || 0) : 0)
}
function parseVectorArray(obj) {
var vals = new Array(obj.x.length);
for (var i = 0; i < vals.length; ++i) {
vals[i] = new b2Vec2(obj.x[i], obj.y[i])
}
return vals
}
function parseProperty(obj, instance) {
var name = obj.name;
var val;
if (typeof (obj["int"]) !== "undefined") {
val = obj["int"]
} else {
if (typeof (obj["float"]) !== "undefined") {
val = obj["float"]
} else {
if (typeof (obj.string) !== "undefined") {
val = obj.string
} else {
if (typeof (obj.bool) !== "undefined") {
val = obj.bool
} else {
if (typeof (obj.vec2) !== "undefined") {
val = parseVector(obj.vec2)
} else {
throw new Error("unknown property type")
}
}
}
}
}
if (instance.hasOwnProperty(name)) {
throw new Error("custom property possibly overwriting an existing one")
}
instance[name] = val
}
function parseFixture(obj, body) {
var def = new b2FixtureDef();
def.density = obj.density || 0;
def.filter.categoryBits = typeof (obj["filter-categoryBits"]) === "undefined" ? 1 : obj["filter-categoryBits"];
def.filter.maskBits = typeof (obj["filter-maskBits"]) === "undefined" ? 65535 : obj["filter-maskBits"];
def.filter.groupIndex = typeof (obj["filter-groupIndex"]) === "undefined" ? 0 : obj["filter-groupIndex"];
def.friction = obj.friction || 0;
def.restitution = obj.restitution || 0;
def.isSensor = obj.sensor || 0;
var shape;
if (typeof (obj.circle) !== "undefined") {
shape = new b2CircleShape();
shape.m_p = parseVector(obj.circle.center);
shape.m_radius = obj.circle.radius || 0
} else {
if (typeof (obj.polygon) !== "undefined") {
var vertices = parseVectorArray(obj.polygon.vertices);
shape = new b2PolygonShape();
shape.Set(vertices, vertices.length)
} else {
if (typeof (obj.chain) !== "undefined") {
var vertices = parseVectorArray(obj.chain.vertices);
shape = new b2ChainShape();
shape.m_count = vertices.length;
shape.m_vertices = vertices;
if (shape.m_hasNextVertex = obj.chain.hasNextVertex) {
shape.m_nextVertex = parseVector(obj.chain.nextVertex)
}
if (shape.m_hasPrevVertex = obj.chain.hasPrevVertex) {
shape.m_prevVertex = parseVector(obj.chain.prevVertex)
}
} else {
throw new Error("unknown shape type")
}
}
}
def.shape = shape;
var fixture = body.CreateFixture(def);
fixture.name = obj.name;
if (obj.customProperties) {
for (var i = 0; i < obj.customProperties.length; ++i) {
parseProperty(obj, fixture)
}
}
}
function parseBody(obj, world) {
var def = new b2BodyDef();
def.type = obj.type || b2Body.b2_staticBody;
def.angle = obj.angle || 0;
def.angularDamping = obj.angularDamping || 0;
def.angularVelocity = obj.angularVelocity || 0;
def.awake = obj.awake || false;
def.bullet = obj.bullet || false;
def.fixedRotation = obj.fixedRotation || false;
def.linearDamping = obj.linearDamping || false;
def.linearVelocity = parseVector(obj.linearVelocity);
def.gravityScale = typeof (obj.gravityScale) !== "undefined" ? obj.gravityScale : 1;
var md = new b2MassData();
md.mass = obj["massData-mass"] || 0;
md.center = parseVector(obj["massData-center"]);
md.I = obj["massData-I"] || 0;
def.position = parseVector(obj.position);
var body = world.CreateBody(def);
body.name = obj.name;
body.SetMassData(md);
if (obj.fixture) {
for (var i = 0; i < obj.fixture.length; ++i) {
parseFixture(obj.fixture[i], body)
}
}
if (obj.customProperties) {
for (i = 0; i < obj.customProperties.length; ++i) {
parseProperty(obj, body)
}
}
return body
}
var jointsList = {
revolute: b2RevoluteJointDef,
distance: b2DistanceJointDef,
prismatic: b2PrismaticJointDef,
wheel: b2WheelJointDef,
rope: b2RopeJointDef,
motor: b2MotorJointDef,
weld: b2WeldJointDef,
friction: b2FrictionJointDef
};
function parseJoint(obj, world, bodies) {
if (!jointsList[obj.type]) {
throw new Error("unknown joint type")
}
var jd = new jointsList[obj.type]();
switch (jd.type) {
case b2Joint.e_revoluteJoint:
jd.localAnchorA = parseVector(obj.anchorA);
jd.localAnchorB = parseVector(obj.anchorB);
jd.enableLimit = obj.enableLimit || false;
jd.enableMotor = obj.enableMotor || false;
jd.lowerAngle = obj.lowerLimit || 0;
jd.maxMotorTorque = obj.maxMotorTorque || 0;
jd.motorSpeed = obj.motorSpeed || 0;
jd.referenceAngle = obj.refAngle || 0;
jd.upperAngle = obj.upperLimit || 0;
break;
case b2Joint.e_distanceJoint:
jd.localAnchorA = parseVector(obj.anchorA);
jd.localAnchorB = parseVector(obj.anchorB);
jd.dampingRatio = obj.dampingRatio || 0;
jd.frequencyHz = obj.frequency || 0;
jd.length = obj.length || 0;
break;
case b2Joint.e_prismaticJoint:
jd.localAnchorA = parseVector(obj.anchorA);
jd.localAnchorB = parseVector(obj.anchorB);
jd.enableLimit = obj.enableLimit || false;
jd.enableMotor = obj.enableMotor || false;
jd.localAxisA = parseVector(obj.localAxisA);
jd.lowerTranslation = obj.lowerLimit || 0;
jd.maxMotorForce = obj.maxMotorForce || 0;
jd.motorSpeed = obj.motorSpeed || 0;
jd.referenceAngle = obj.refAngle || 0;
jd.upperTranslation = obj.upperLimit || 0;
break;
case b2Joint.e_wheelJoint:
jd.localAnchorA = parseVector(obj.anchorA);
jd.localAnchorB = parseVector(obj.anchorB);
jd.enableMotor = obj.enableMotor || false;
jd.localAxisA = parseVector(obj.localAxisA);
jd.maxMotorTorque = obj.maxMotorTorque || 0;
jd.motorSpeed = obj.motorSpeed || 0;
jd.dampingRatio = obj.springDampingRatio || 0;
jd.frequencyHz = obj.springFrequency || 0;
break;
case b2Joint.e_ropeJoint:
jd.localAnchorA = parseVector(obj.anchorA);
jd.localAnchorB = parseVector(obj.anchorB);
jd.maxLength = obj.maxLength || 0;
break;
case b2Joint.e_motorJoint:
jd.linearOffset = parseVector(obj.anchorA);
jd.angularOffset = obj.refAngle || 0;
jd.maxForce = obj.maxForce || 0;
jd.maxTorque = obj.maxTorque || 0;
jd.correctionFactor = obj.correctionFactor || 0;
break;
case b2Joint.e_weldJoint:
jd.localAnchorA = parseVector(obj.anchorA);
jd.localAnchorB = parseVector(obj.anchorB);
jd.referenceAngle = obj.refAngle || 0;
jd.dampingRatio = obj.dampingRatio || 0;
jd.frequencyHz = obj.frequencyHz || 0;
break;
case b2Joint.e_frictionJoint:
jd.localAnchorA = parseVector(obj.anchorA);
jd.localAnchorB = parseVector(obj.anchorB);
jd.maxForce = obj.maxForce || 0;
jd.maxTorque = obj.maxTorque || 0;
break;
default:
throw new Error("wat?")
}
jd.bodyA = bodies[obj.bodyA || 0];
jd.bodyB = bodies[obj.bodyB || 0];
jd.collideConnected = obj.collideConnected || false;
var joint = world.CreateJoint(jd);
joint.name = obj.name;
if (obj.customProperties) {
for (var i = 0; i < obj.customProperties.length; ++i) {
parseProperty(obj, joint)
}
}
return joint
}
function b2RubeParameters() {
this.world = null;
this.positionIterations = 0;
this.velocityIterations = 0;
this.stepsPerSecond = 0;
this.fixtures = {};
this.bodies = {};
this.joints = {};
Object.seal(this)
}
function parseWorld(obj, world) {
var params = new b2RubeParameters();
params.world = world = world || new b2World(new b2Vec2(0, 0));
params.positionIterations = obj.positionIterations || 0;
params.velocityIterations = obj.velocityIterations || 0;
params.stepsPerSecond = obj.stepsPerSecond || 0;
if (obj.gravity) {
world.SetGravity(parseVector(obj.gravity))
}
world.SetAllowSleeping(obj.allowSleep || false);
world.SetAutoClearForces(obj.autoClearForces || false);
world.SetWarmStarting(obj.warmStarting || false);
world.SetContinuousPhysics(obj.continuousPhysics || false);
world.SetSubStepping(obj.subStepping || false);
var bodies = [];
var bl = obj.body;
if (bl) {
for (var i = 0; i < bl.length; ++i) {
var body = parseBody(bl[i], world);
bodies.push(body);
for (var f = body.GetFixtureList(); f; f = f.GetNext()) {
if (!params.fixtures[f.name]) {
params.fixtures[f.name] = []
}
params.fixtures[f.name].push(f)
}
if (!params.bodies[body.name]) {
params.bodies[body.name] = []
}
params.bodies[body.name].push(body)
}
}
var joints = [];
var jl = obj.joint;
if (jl) {
for (i = 0; i < jl.length; ++i) {
var joint = parseJoint(jl[i], world, bodies);
joints.push(joint);
if (!params.joints[joint.name]) {
params.joints[joint.name] = []
}
params.joints[joint.name].push(joint)
}
}
return params
}
return {
parseWorld: parseWorld
}
})();
var mappings = [{
trimmed: "version",
name: "b2_version",
def: b2_version
}, {
trimmed: "Vec2",
name: "b2Vec2",
def: b2Vec2
}, {
trimmed: "Vec3",
name: "b2Vec3",
def: b2Vec3
}, {
trimmed: "Mat22",
name: "b2Mat22",
def: b2Mat22
}, {
trimmed: "Mat33",
name: "b2Mat33",
def: b2Mat33
}, {
trimmed: "Rot",
name: "b2Rot",
def: b2Rot
}, {
trimmed: "Transform",
name: "b2Transform",
def: b2Transform
}, {
trimmed: "Sweep",
name: "b2Sweep",
def: b2Sweep
}, {
trimmed: "Dot_v2_v2",
name: "b2Dot_v2_v2",
def: b2Dot_v2_v2
}, {
trimmed: "Cross_v2_v2",
name: "b2Cross_v2_v2",
def: b2Cross_v2_v2
}, {
trimmed: "Cross_v2_f",
name: "b2Cross_v2_f",
def: b2Cross_v2_f
}, {
trimmed: "Cross_f_v2",
name: "b2Cross_f_v2",
def: b2Cross_f_v2
}, {
trimmed: "Mul_m22_v2",
name: "b2Mul_m22_v2",
def: b2Mul_m22_v2
}, {
trimmed: "MulT_m22_v2",
name: "b2MulT_m22_v2",
def: b2MulT_m22_v2
}, {
trimmed: "Distance",
name: "b2Distance",
def: b2Distance
}, {
trimmed: "DistanceSquared",
name: "b2DistanceSquared",
def: b2DistanceSquared
}, {
trimmed: "Dot_v3_v3",
name: "b2Dot_v3_v3",
def: b2Dot_v3_v3
}, {
trimmed: "Cross_v3_v3",
name: "b2Cross_v3_v3",
def: b2Cross_v3_v3
}, {
trimmed: "Mul_m22_m22",
name: "b2Mul_m22_m22",
def: b2Mul_m22_m22
}, {
trimmed: "MulT_m22_m22",
name: "b2MulT_m22_m22",
def: b2MulT_m22_m22
}, {
trimmed: "Mul_m33_v3",
name: "b2Mul_m33_v3",
def: b2Mul_m33_v3
}, {
trimmed: "Mul22_m33_v2",
name: "b2Mul22_m33_v2",
def: b2Mul22_m33_v2
}, {
trimmed: "Mul_r_r",
name: "b2Mul_r_r",
def: b2Mul_r_r
}, {
trimmed: "MulT_r_r",
name: "b2MulT_r_r",
def: b2MulT_r_r
}, {
trimmed: "Mul_r_v2",
name: "b2Mul_r_v2",
def: b2Mul_r_v2
}, {
trimmed: "MulT_r_v2",
name: "b2MulT_r_v2",
def: b2MulT_r_v2
}, {
trimmed: "Mul_t_v2",
name: "b2Mul_t_v2",
def: b2Mul_t_v2
}, {
trimmed: "Min_v2",
name: "b2Min_v2",
def: b2Min_v2
}, {
trimmed: "Max_v2",
name: "b2Max_v2",
def: b2Max_v2
}, {
trimmed: "Clamp",
name: "b2Clamp",
def: b2Clamp
}, {
trimmed: "MulT_t_v2",
name: "b2MulT_t_v2",
def: b2MulT_t_v2
}, {
trimmed: "Mul_t_t",
name: "b2Mul_t_t",
def: b2Mul_t_t
}, {
trimmed: "MulT_t_t",
name: "b2MulT_t_t",
def: b2MulT_t_t
}, {
trimmed: "Clamp_v2",
name: "b2Clamp_v2",
def: b2Clamp_v2
}, {
trimmed: "NextPowerOfTwo",
name: "b2NextPowerOfTwo",
def: b2NextPowerOfTwo
}, {
trimmed: "Abs_v2",
name: "b2Abs_v2",
def: b2Abs_v2
}, {
trimmed: "Abs_m22",
name: "b2Abs_m22",
def: b2Abs_m22
}, {
trimmed: "IsPowerOfTwo",
name: "b2IsPowerOfTwo",
def: b2IsPowerOfTwo
}, {
trimmed: "RandomFloat",
name: "b2RandomFloat",
def: b2RandomFloat
}, {
trimmed: "Timer",
name: "b2Timer",
def: b2Timer
}, {
trimmed: "Color",
name: "b2Color",
def: b2Color
}, {
trimmed: "Draw",
name: "b2Draw",
def: b2Draw
}, {
trimmed: "ContactID",
name: "b2ContactID",
def: b2ContactID
}, {
trimmed: "ManifoldPoint",
name: "b2ManifoldPoint",
def: b2ManifoldPoint
}, {
trimmed: "Manifold",
name: "b2Manifold",
def: b2Manifold
}, {
trimmed: "WorldManifold",
name: "b2WorldManifold",
def: b2WorldManifold
}, {
trimmed: "GetPointStates",
name: "b2GetPointStates",
def: b2GetPointStates
}, {
trimmed: "ClipVertex",
name: "b2ClipVertex",
def: b2ClipVertex
}, {
trimmed: "RayCastInput",
name: "b2RayCastInput",
def: b2RayCastInput
}, {
trimmed: "RayCastOutput",
name: "b2RayCastOutput",
def: b2RayCastOutput
}, {
trimmed: "AABB",
name: "b2AABB",
def: b2AABB
}, {
trimmed: "CollideCircles",
name: "b2CollideCircles",
def: b2CollideCircles
}, {
trimmed: "CollidePolygonAndCircle",
name: "b2CollidePolygonAndCircle",
def: b2CollidePolygonAndCircle
}, {
trimmed: "FindMaxSeparation",
name: "b2FindMaxSeparation",
def: b2FindMaxSeparation
}, {
trimmed: "FindIncidentEdge",
name: "b2FindIncidentEdge",
def: b2FindIncidentEdge
}, {
trimmed: "CollidePolygons",
name: "b2CollidePolygons",
def: b2CollidePolygons
}, {
trimmed: "CollideEdgeAndCircle",
name: "b2CollideEdgeAndCircle",
def: b2CollideEdgeAndCircle
}, {
trimmed: "EPAxis",
name: "b2EPAxis",
def: b2EPAxis
}, {
trimmed: "TempPolygon",
name: "b2TempPolygon",
def: b2TempPolygon
}, {
trimmed: "ReferenceFace",
name: "b2ReferenceFace",
def: b2ReferenceFace
}, {
trimmed: "EPCollider",
name: "b2EPCollider",
def: b2EPCollider
}, {
trimmed: "CollideEdgeAndPolygon",
name: "b2CollideEdgeAndPolygon",
def: b2CollideEdgeAndPolygon
}, {
trimmed: "ClipSegmentToLine",
name: "b2ClipSegmentToLine",
def: b2ClipSegmentToLine
}, {
trimmed: "TestShapeOverlap",
name: "b2TestShapeOverlap",
def: b2TestShapeOverlap
}, {
trimmed: "TestOverlap",
name: "b2TestOverlap",
def: b2TestOverlap
}, {
trimmed: "Shape",
name: "b2Shape",
def: b2Shape
}, {
trimmed: "CircleShape",
name: "b2CircleShape",
def: b2CircleShape
}, {
trimmed: "EdgeShape",
name: "b2EdgeShape",
def: b2EdgeShape
}, {
trimmed: "ChainShape",
name: "b2ChainShape",
def: b2ChainShape
}, {
trimmed: "PolygonShape",
name: "b2PolygonShape",
def: b2PolygonShape
}, {
trimmed: "Pair",
name: "b2Pair",
def: b2Pair
}, {
trimmed: "PairLessThan",
name: "b2PairLessThan",
def: b2PairLessThan
}, {
trimmed: "BroadPhase",
name: "b2BroadPhase",
def: b2BroadPhase
}, {
trimmed: "DistanceProxy",
name: "b2DistanceProxy",
def: b2DistanceProxy
}, {
trimmed: "SimplexCache",
name: "b2SimplexCache",
def: b2SimplexCache
}, {
trimmed: "DistanceInput",
name: "b2DistanceInput",
def: b2DistanceInput
}, {
trimmed: "DistanceOutput",
name: "b2DistanceOutput",
def: b2DistanceOutput
}, {
trimmed: "SimplexVertex",
name: "b2SimplexVertex",
def: b2SimplexVertex
}, {
trimmed: "Simplex",
name: "b2Simplex",
def: b2Simplex
}, {
trimmed: "DistanceFunc",
name: "b2DistanceFunc",
def: b2DistanceFunc
}, {
trimmed: "TreeNode",
name: "b2TreeNode",
def: b2TreeNode
}, {
trimmed: "DynamicTree",
name: "b2DynamicTree",
def: b2DynamicTree
}, {
trimmed: "TOIInput",
name: "b2TOIInput",
def: b2TOIInput
}, {
trimmed: "TOIOutput",
name: "b2TOIOutput",
def: b2TOIOutput
}, {
trimmed: "SeparationFunction",
name: "b2SeparationFunction",
def: b2SeparationFunction
}, {
trimmed: "TimeOfImpact",
name: "b2TimeOfImpact",
def: b2TimeOfImpact
}, {
trimmed: "BodyDef",
name: "b2BodyDef",
def: b2BodyDef
}, {
trimmed: "Body",
name: "b2Body",
def: b2Body
}, {
trimmed: "Filter",
name: "b2Filter",
def: b2Filter
}, {
trimmed: "FixtureDef",
name: "b2FixtureDef",
def: b2FixtureDef
}, {
trimmed: "Fixture",
name: "b2Fixture",
def: b2Fixture
}, {
trimmed: "DestructionListener",
name: "b2DestructionListener",
def: b2DestructionListener
}, {
trimmed: "ContactFilter",
name: "b2ContactFilter",
def: b2ContactFilter
}, {
trimmed: "ContactImpulse",
name: "b2ContactImpulse",
def: b2ContactImpulse
}, {
trimmed: "ContactListener",
name: "b2ContactListener",
def: b2ContactListener
}, {
trimmed: "QueryCallback",
name: "b2QueryCallback",
def: b2QueryCallback
}, {
trimmed: "RayCastCallback",
name: "b2RayCastCallback",
def: b2RayCastCallback
}, {
trimmed: "TimeStep",
name: "b2TimeStep",
def: b2TimeStep
}, {
trimmed: "Position",
name: "b2Position",
def: b2Position
}, {
trimmed: "Velocity",
name: "b2Velocity",
def: b2Velocity
}, {
trimmed: "SolverData",
name: "b2SolverData",
def: b2SolverData
}, {
trimmed: "World",
name: "b2World",
def: b2World
}, {
trimmed: "MixFriction",
name: "b2MixFriction",
def: b2MixFriction
}, {
trimmed: "MixRestitution",
name: "b2MixRestitution",
def: b2MixRestitution
}, {
trimmed: "ContactRegister",
name: "b2ContactRegister",
def: b2ContactRegister
}, {
trimmed: "ContactEdge",
name: "b2ContactEdge",
def: b2ContactEdge
}, {
trimmed: "Contact",
name: "b2Contact",
def: b2Contact
}, {
trimmed: "CircleContact",
name: "b2CircleContact",
def: b2CircleContact
}, {
trimmed: "PolygonContact",
name: "b2PolygonContact",
def: b2PolygonContact
}, {
trimmed: "ChainAndCircleContact",
name: "b2ChainAndCircleContact",
def: b2ChainAndCircleContact
}, {
trimmed: "ChainAndPolygonContact",
name: "b2ChainAndPolygonContact",
def: b2ChainAndPolygonContact
}, {
trimmed: "EdgeAndCircleContact",
name: "b2EdgeAndCircleContact",
def: b2EdgeAndCircleContact
}, {
trimmed: "EdgeAndPolygonContact",
name: "b2EdgeAndPolygonContact",
def: b2EdgeAndPolygonContact
}, {
trimmed: "PolygonAndCircleContact",
name: "b2PolygonAndCircleContact",
def: b2PolygonAndCircleContact
}, {
trimmed: "defaultFilter",
name: "b2_defaultFilter",
def: b2_defaultFilter
}, {
trimmed: "defaultListener",
name: "b2_defaultListener",
def: b2_defaultListener
}, {
trimmed: "ContactManager",
name: "b2ContactManager",
def: b2ContactManager
}, {
trimmed: "VelocityConstraintPoint",
name: "b2VelocityConstraintPoint",
def: b2VelocityConstraintPoint
}, {
trimmed: "ContactPositionConstraint",
name: "b2ContactPositionConstraint",
def: b2ContactPositionConstraint
}, {
trimmed: "ContactVelocityConstraint",
name: "b2ContactVelocityConstraint",
def: b2ContactVelocityConstraint
}, {
trimmed: "PositionSolverManifold",
name: "b2PositionSolverManifold",
def: b2PositionSolverManifold
}, {
trimmed: "ContactSolverDef",
name: "b2ContactSolverDef",
def: b2ContactSolverDef
}, {
trimmed: "ContactSolver",
name: "b2ContactSolver",
def: b2ContactSolver
}, {
trimmed: "Island",
name: "b2Island",
def: b2Island
}, {
trimmed: "Jacobian",
name: "b2Jacobian",
def: b2Jacobian
}, {
trimmed: "JointEdge",
name: "b2JointEdge",
def: b2JointEdge
}, {
trimmed: "JointDef",
name: "b2JointDef",
def: b2JointDef
}, {
trimmed: "Joint",
name: "b2Joint",
def: b2Joint
}, {
trimmed: "RevoluteJointDef",
name: "b2RevoluteJointDef",
def: b2RevoluteJointDef
}, {
trimmed: "RevoluteJoint",
name: "b2RevoluteJoint",
def: b2RevoluteJoint
}, {
trimmed: "MouseJointDef",
name: "b2MouseJointDef",
def: b2MouseJointDef
}, {
trimmed: "MouseJoint",
name: "b2MouseJoint",
def: b2MouseJoint
}, {
trimmed: "DistanceJointDef",
name: "b2DistanceJointDef",
def: b2DistanceJointDef
}, {
trimmed: "DistanceJoint",
name: "b2DistanceJoint",
def: b2DistanceJoint
}, {
trimmed: "PrismaticJointDef",
name: "b2PrismaticJointDef",
def: b2PrismaticJointDef
}, {
trimmed: "PrismaticJoint",
name: "b2PrismaticJoint",
def: b2PrismaticJoint
}, {
trimmed: "FrictionJointDef",
name: "b2FrictionJointDef",
def: b2FrictionJointDef
}, {
trimmed: "FrictionJoint",
name: "b2FrictionJoint",
def: b2FrictionJoint
}, {
trimmed: "WeldJointDef",
name: "b2WeldJointDef",
def: b2WeldJointDef
}, {
trimmed: "WeldJoint",
name: "b2WeldJoint",
def: b2WeldJoint
}, {
trimmed: "WheelJointDef",
name: "b2WheelJointDef",
def: b2WheelJointDef
}, {
trimmed: "WheelJoint",
name: "b2WheelJoint",
def: b2WheelJoint
}, {
trimmed: "GearJointDef",
name: "b2GearJointDef",
def: b2GearJointDef
}, {
trimmed: "GearJoint",
name: "b2GearJoint",
def: b2GearJoint
}, {
trimmed: "MotorJointDef",
name: "b2MotorJointDef",
def: b2MotorJointDef
}, {
trimmed: "MotorJoint",
name: "b2MotorJoint",
def: b2MotorJoint
}, {
trimmed: "PulleyJointDef",
name: "b2PulleyJointDef",
def: b2PulleyJointDef
}, {
trimmed: "PulleyJoint",
name: "b2PulleyJoint",
def: b2PulleyJoint
}, {
trimmed: "RopeJointDef",
name: "b2RopeJointDef",
def: b2RopeJointDef
}, {
trimmed: "RopeJoint",
name: "b2RopeJoint",
def: b2RopeJoint
}, {
trimmed: "RopeDef",
name: "b2RopeDef",
def: b2RopeDef
}, {
trimmed: "Rope",
name: "b2Rope",
def: b2Rope
}, {
trimmed: "maxManifoldPoints",
name: "b2_maxManifoldPoints",
def: b2_maxManifoldPoints
}, {
trimmed: "maxPolygonVertices",
name: "b2_maxPolygonVertices",
def: b2_maxPolygonVertices
}, {
trimmed: "aabbExtension",
name: "b2_aabbExtension",
def: b2_aabbExtension
}, {
trimmed: "aabbMultiplier",
name: "b2_aabbMultiplier",
def: b2_aabbMultiplier
}, {
trimmed: "linearSlop",
name: "b2_linearSlop",
def: b2_linearSlop
}, {
trimmed: "angularSlop",
name: "b2_angularSlop",
def: b2_angularSlop
}, {
trimmed: "polygonRadius",
name: "b2_polygonRadius",
def: b2_polygonRadius
}, {
trimmed: "maxSubSteps",
name: "b2_maxSubSteps",
def: b2_maxSubSteps
}, {
trimmed: "maxTOIContacts",
name: "b2_maxTOIContacts",
def: b2_maxTOIContacts
}, {
trimmed: "velocityThreshold",
name: "b2_velocityThreshold",
def: b2_velocityThreshold
}, {
trimmed: "maxLinearCorrection",
name: "b2_maxLinearCorrection",
def: b2_maxLinearCorrection
}, {
trimmed: "maxAngularCorrection",
name: "b2_maxAngularCorrection",
def: b2_maxAngularCorrection
}, {
trimmed: "maxTranslation",
name: "b2_maxTranslation",
def: b2_maxTranslation
}, {
trimmed: "maxTranslationSquared",
name: "b2_maxTranslationSquared",
def: b2_maxTranslationSquared
}, {
trimmed: "maxRotation",
name: "b2_maxRotation",
def: b2_maxRotation
}, {
trimmed: "maxRotationSquared",
name: "b2_maxRotationSquared",
def: b2_maxRotationSquared
}, {
trimmed: "baumgarte",
name: "b2_baumgarte",
def: b2_baumgarte
}, {
trimmed: "toiBaugarte",
name: "b2_toiBaugarte",
def: b2_toiBaugarte
}, {
trimmed: "timeToSleep",
name: "b2_timeToSleep",
def: b2_timeToSleep
}, {
trimmed: "linearSleepTolerance",
name: "b2_linearSleepTolerance",
def: b2_linearSleepTolerance
}, {
trimmed: "angularSleepTolerance",
name: "b2_angularSleepTolerance",
def: b2_angularSleepTolerance
}, {
trimmed: "epsilon",
name: "b2_epsilon",
def: b2_epsilon
}, {
trimmed: "JsonSerializer",
name: "b2JsonSerializer",
def: b2JsonSerializer
}, {
trimmed: "RUBELoader",
name: "b2RUBELoader",
def: b2RUBELoader
}, {
trimmed: "Profiler",
name: "b2Profiler",
def: b2Profiler
}];
if (typeof (b2_compatibility) !== "undefined" && typeof (window) !== "undefined") {
for (var i = 0; i < mappings.length; ++i) {
window[mappings[i].name] = mappings[i].def
}
} else {
var b2 = {};
for (var i = 0; i < mappings.length; ++i) {
b2[mappings[i].trimmed] = mappings[i].def
}
if (typeof (module) !== "undefined") {
module.exports = b2
} else {
window.b2 = b2
}
}