Mirrors/phaser
2
0
Fork 0
mirror of https://github.com/photonstorm/phaser synced 2024-11-30 16:39:34 +00:00
Code Issues Projects Releases Packages Wiki Activity
phaser/typescript/box2d.d.ts
Richard Davey 43b4fd3caf Fixed defs (#2568) and added in Box2D defs.
2016-06-17 11:52:46 +01:00

3785 lines
154 KiB
TypeScript
Raw Blame History

declare class box2d {
static DEBUG: boolean;
static ENABLE_ASSERTS: boolean;
static b2Assert(condition: boolean, opt_message?: string, ...var_args: any[]): void;
static b2_maxFloat: number;
static b2_epsilon: number;
static b2_epsilon_sq: number;
static b2_pi: number;
// The maximum number of contact points between two convex
// shapes. Do not change this value.
static b2_maxManifoldPoints: number;
// The maximum number of vertices on a convex polygon. You
// cannot increase this too much because b2BlockAllocator has a
// maximum object size.
static b2_maxPolygonVertices: number;
// This is used to fatten AABBs in the dynamic tree. This allows
// proxies to move by a small amount without triggering a tree
// adjustment.
// This is in meters.
static b2_aabbExtension: number;
// This is used to fatten AABBs in the dynamic tree. This is
// used to predict the future position based on the current
// displacement.
// This is a dimensionless multiplier.
static b2_aabbMultiplier: number;
// A small length used as a collision and constraint tolerance.
// Usually it is chosen to be numerically significant, but
// visually insignificant.
static b2_linearSlop: number;
// A small angle used as a collision and constraint tolerance.
// Usually it is chosen to be numerically significant, but
// visually insignificant.
static b2_angularSlop: number;
// The radius of the polygon/edge shape skin. This should not be
// modified. Making this smaller means polygons will have an
// insufficient buffer for continuous collision.
// Making it larger may create artifacts for vertex collision.
static b2_polygonRadius: number;
// Maximum number of sub-steps per contact in continuous physics
// simulation.
static b2_maxSubSteps: number;
// Maximum number of contacts to be handled to solve a TOI
// impact.
static b2_maxTOIContacts: number;
// A velocity threshold for elastic collisions. Any collision
// with a relative linear velocity below this threshold will be
// treated as inelastic.
static b2_velocityThreshold: number;
// The maximum linear position correction used when solving
// constraints. This helps to prevent overshoot.
static b2_maxLinearCorrection: number;
// The maximum angular position correction used when solving
// constraints. This helps to prevent overshoot.
static b2_maxAngularCorrection: number;
// The maximum linear velocity of a body. This limit is very
// large and is used to prevent numerical problems. You
// shouldn't need to adjust this.
static b2_maxTranslation: number;
static b2_maxTranslationSquared: number;
// The maximum angular velocity of a body. This limit is very
// large and is used to prevent numerical problems. You
// shouldn't need to adjust this.
static b2_maxRotation: number;
static b2_maxRotationSquared: number;
// This scale factor controls how fast overlap is resolved.
// Ideally this would be 1 so that overlap is removed in one
// time step. However using values close to 1 often lead to
// overshoot.
static b2_baumgarte: number;
static b2_toiBaumgarte: number;
// The time that a body must be still before it will go to
// sleep.
static b2_timeToSleep: number;
// A body cannot sleep if its linear velocity is above this
// tolerance.
static b2_linearSleepTolerance: number;
// A body cannot sleep if its angular velocity is above this
// tolerance.
static b2_angularSleepTolerance: number;
// Implement this function to use your own memory allocator.
static b2Alloc(size: number): any;
// If you implement b2Alloc, you should also implement this
// function.
static b2Free(mem: any): void;
// Logging function.
// You can modify this to use your logging facility.
static b2Log(...var_args: any[]): void;
// Current version.
static b2_version: box2d.b2Version;
static b2_changelist: number;
static b2ParseInt(v: string): number;
static b2ParseUInt(v: string): number;
static b2MakeArray(length?: number, init?: (length: number) => any): Array<any>;
static b2MakeNumberArray(length?: number): Array<number>;
static b2_pi_over_180: number;
static b2_180_over_pi: number;
static b2_two_pi: number;
static b2Abs(n: number): number;
static b2Min(a: number, b: number): number;
static b2Max(a: number, b: number): number;
static b2Clamp(a: number, lo: number, hi: number): number;
static b2Swap(a: Array<number>, b: Array<number>): void;
// This function is used to ensure that a floating point number
// is not a NaN or infinity.
static b2IsValid(n: number): boolean;
static b2Sq(n: number): number;
// This is a approximate yet fast inverse square-root.
static b2InvSqrt(n: number): number;
static b2Sqrt(n: number): number;
static b2Pow(x: number, y: number): number;
static b2DegToRad(degrees: number): number;
static b2RadToDeg(radians: number): number;
static b2Cos(radians: number): number;
static b2Sin(radians: number): number;
static b2Acos(n: number): number;
static b2Asin(n: number): number;
static b2Atan2(y: number, x: number): number;
// Next Largest Power of 2
// Given a binary integer value x, the next largest power of 2
// can be computed by a SWAR algorithm that recursively "folds"
// the upper bits into the lower bits. This process yields a bit
// vector with the same most significant 1 as x, but all 1's
// below it. Adding 1 to that value yields the next largest
// power of 2. For a 32-bit value:
static b2NextPowerOfTwo(x: number): number;
static b2IsPowerOfTwo(x: number): boolean;
static b2Random(): number;
static b2RandomRange(lo: number, hi: number): number;
static b2Vec2_zero: box2d.b2Vec2;
static b2AbsV(v: box2d.b2Vec2, out: box2d.b2Vec2): box2d.b2Vec2;
static b2MinV(a: box2d.b2Vec2, b: box2d.b2Vec2, out: box2d.b2Vec2): box2d.b2Vec2;
static b2MaxV(a: box2d.b2Vec2, b: box2d.b2Vec2, out: box2d.b2Vec2): box2d.b2Vec2;
static b2ClampV(v: box2d.b2Vec2, lo: box2d.b2Vec2, hi: box2d.b2Vec2, out: box2d.b2Vec2): box2d.b2Vec2;
static b2RotateV(v: box2d.b2Vec2, c: number, s: number, out: box2d.b2Vec2): box2d.b2Vec2;
static b2RotateRadiansV(v: box2d.b2Vec2, radians: number, out: box2d.b2Vec2): box2d.b2Vec2;
static b2RotateDegreesV(v: box2d.b2Vec2, degrees: number, out: box2d.b2Vec2): box2d.b2Vec2;
// Perform the dot product on two vectors.
// a.x * b.x + a.y * b.y
static b2DotVV(a: box2d.b2Vec2, b: box2d.b2Vec2): number;
// Perform the cross product on two vectors. In 2D this produces a scalar.
// a.x * b.y - a.y * b.x
static b2CrossVV(a: box2d.b2Vec2, b: box2d.b2Vec2): number;
// Perform the cross product on a vector and a scalar. In 2D
// this produces a vector.
static b2CrossVS(v: box2d.b2Vec2, s: number, out: box2d.b2Vec2): box2d.b2Vec2;
// box2d.b2CrossVS(v, 1.0, out)
static b2CrossVOne(v: box2d.b2Vec2, out: box2d.b2Vec2): box2d.b2Vec2;
// Perform the cross product on a scalar and a vector. In 2D
// this produces a vector.
static b2CrossSV(s: number, v: box2d.b2Vec2, out: box2d.b2Vec2): box2d.b2Vec2;
// box2d.b2CrossSV(1.0, v, out)
static b2CrossOneV(v: box2d.b2Vec2, out: box2d.b2Vec2): box2d.b2Vec2;
// Add two vectors component-wise.
static b2AddVV(a: box2d.b2Vec2, b: box2d.b2Vec2, out: box2d.b2Vec2): box2d.b2Vec2;
// Subtract two vectors component-wise.
static b2SubVV(a: box2d.b2Vec2, b: box2d.b2Vec2, out: box2d.b2Vec2): box2d.b2Vec2;
static b2MulSV(s: number, v: box2d.b2Vec2, out: box2d.b2Vec2): box2d.b2Vec2;
// out = a + (s * b)
static b2AddVMulSV(a: box2d.b2Vec2, s: number, b: box2d.b2Vec2, out: box2d.b2Vec2): box2d.b2Vec2;
// out = a - (s * b)
static b2SubVMulSV(a: box2d.b2Vec2, s: number, b: box2d.b2Vec2, out: box2d.b2Vec2): box2d.b2Vec2;
// out = a + b2CrossSV(s, v)
static b2AddVCrossSV(a: box2d.b2Vec2, s: number, v: box2d.b2Vec2, out: box2d.b2Vec2): box2d.b2Vec2;
// Get the center of two vectors.
static b2MidVV(a: box2d.b2Vec2, b: box2d.b2Vec2, out: box2d.b2Vec2): box2d.b2Vec2;
// Get the extent of two vectors (half-widths).
static b2ExtVV(a: box2d.b2Vec2, b: box2d.b2Vec2, out: box2d.b2Vec2): box2d.b2Vec2;
static b2IsEqualToV(a: box2d.b2Vec2, b: box2d.b2Vec2): boolean;
static b2DistanceVV(a: box2d.b2Vec2, b: box2d.b2Vec2): number;
static b2DistanceSquaredVV(a: box2d.b2Vec2, b: box2d.b2Vec2): number;
static b2NegV(v: box2d.b2Vec2, out: box2d.b2Vec2): box2d.b2Vec2;
// Perform the dot product on two vectors.
static b2DotV3V3(a: box2d.b2Vec3, b: box2d.b2Vec3): number;
// Perform the cross product on two vectors.
static b2CrossV3V3(a: box2d.b2Vec3, b: box2d.b2Vec3, out: box2d.b2Vec3): box2d.b2Vec3;
static b2AbsM(M: box2d.b2Mat22, out: box2d.b2Mat22): box2d.b2Mat22;
// Multiply a matrix times a vector. If a rotation matrix is
// provided, then this transforms the vector from one frame to
// another.
static b2MulMV(M: box2d.b2Mat22, v: box2d.b2Vec2, out: box2d.b2Vec2): box2d.b2Vec2;
// Multiply a matrix transpose times a vector. If a rotation
// matrix is provided, then this transforms the vector from one
// frame to another (inverse transform).
static b2MulTMV(M: box2d.b2Mat22, v: box2d.b2Vec2, out: box2d.b2Vec2): box2d.b2Vec2;
static b2AddMM(A: box2d.b2Mat22, B: box2d.b2Mat22, out: box2d.b2Mat22): box2d.b2Mat22;
static b2MulMM(A: box2d.b2Mat22, B: box2d.b2Mat22, out: box2d.b2Mat22): box2d.b2Mat22;
static b2MulTMM(A: box2d.b2Mat22, B: box2d.b2Mat22, out: box2d.b2Mat22): box2d.b2Mat22;
// Multiply a matrix times a vector.
static b2MulM33V3(A: box2d.b2Mat33, v: box2d.b2Vec3, out: box2d.b2Vec3): box2d.b2Vec3;
static b2MulM33XYZ(A: box2d.b2Mat33, x: number, y: number, z: number, out: box2d.b2Vec3): box2d.b2Vec3;
static b2MulM33V2(A: box2d.b2Mat33, v: box2d.b2Vec2, out: box2d.b2Vec2): box2d.b2Vec2;
static b2MulM33XY(A: box2d.b2Mat33, x: number, y: number, out: box2d.b2Vec2): box2d.b2Vec2;
// Multiply two rotations: q * r
static b2MulRR(q: box2d.b2Rot, r: box2d.b2Rot, out: box2d.b2Rot): box2d.b2Rot;
// Transpose multiply two rotations: qT * r
static b2MulTRR(q: box2d.b2Rot, r: box2d.b2Rot, out: box2d.b2Rot): box2d.b2Rot;
// Rotate a vector
static b2MulRV(q: box2d.b2Rot, v: box2d.b2Vec2, out: box2d.b2Vec2): box2d.b2Vec2;
// Inverse rotate a vector
static b2MulTRV(q: box2d.b2Rot, v: box2d.b2Vec2, out: box2d.b2Vec2): box2d.b2Vec2;
static b2MulXV(T: box2d.b2Transform, v: box2d.b2Vec2, out: box2d.b2Vec2): box2d.b2Vec2;
static b2MulTXV(T: box2d.b2Transform, v: box2d.b2Vec2, out: box2d.b2Vec2): box2d.b2Vec2;
// v2 = A.q.Rot(B.q.Rot(v1) + B.p) + A.p
// = (A.q * B.q).Rot(v1) + A.q.Rot(B.p) + A.p
static b2MulXX(A: box2d.b2Transform, B: box2d.b2Transform, out: box2d.b2Transform): box2d.b2Transform;
// v2 = A.q' * (B.q * v1 + B.p - A.p)
// = A.q' * B.q * v1 + A.q' * (B.p - A.p)
static b2MulTXX(A: box2d.b2Transform, B: box2d.b2Transform, out: box2d.b2Transform): box2d.b2Transform;
static b2_gjkCalls: number;
static b2_gjkIters: number;
static b2_gjkMaxIters: number;
// Compute the closest points between two shapes. Supports any combination of:
// box2d.b2CircleShape, box2d.b2PolygonShape, box2d.b2EdgeShape. The simplex cache is input/output.
// On the first call set box2d.b2SimplexCache.count to zero.
static b2Distance(output: box2d.b2DistanceOutput, cache: box2d.b2SimplexCache, input: box2d.b2DistanceInput): void;
// Compute the point states given two manifolds. The states
// pertain to the transition from manifold1 to manifold2. So
// state1 is either persist or remove while state2 is either add
// or persist.
static b2GetPointStates(state1: Array<box2d.b2PointState>, state2: Array<box2d.b2PointState>, manifold1: box2d.b2Manifold, manifold2: box2d.b2Manifold): void;
static b2TestOverlapAABB(a: box2d.b2AABB, b: box2d.b2AABB): boolean;
// Clipping for contact manifolds.
// Sutherland-Hodgman clipping.
static b2ClipSegmentToLine(vOut: Array<box2d.b2ClipVertex>, vIn: Array<box2d.b2ClipVertex>, normal: box2d.b2Vec2, offset: number, vertexIndexA: number): number;
static b2TestOverlapShape(shapeA: box2d.b2Shape, shapeB: box2d.b2Shape, xfA: box2d.b2Transform, xfB: box2d.b2Transform): boolean;
static b2_toiTime: number;
static b2_toiMaxTime: number;
static b2_toiCalls: number;
static b2_toiIters: number;
static b2_toiMaxIters: number;
static b2_toiRootIters: number;
static b2_toiMaxRootIters: number;
// Compute the upper bound on time before two shapes penetrate.
// Time is represented as a fraction between [0,tMax]. This uses
// a swept separating axis and may miss some intermediate,
// non-tunneling collision. If you change the time interval, you
// should call this function again.
// Note: use box2d.b2Distance to compute the contact point and
// normal at the time of impact.
static b2TimeOfImpact(output: box2d.b2TOIOutput, input: box2d.b2TOIInput): void;
// Friction mixing law. The idea is to allow either fixture to
// drive the restitution to zero. For example, anything slides
// on ice.
static b2MixFriction(friction1: number, friction2: number): number;
// Restitution mixing law. The idea is allow for anything to
// bounce off an inelastic surface. For example, a superball
// bounces on anything.
static b2MixRestitution(restitution1: number, restitution2: number): number;
// Compute the collision manifold between an edge and a circle.
// Compute contact points for edge versus circle.
// This accounts for edge connectivity.
static b2CollideEdgeAndCircle(manifold: box2d.b2Manifold, edgeA: box2d.b2EdgeShape, xfA: box2d.b2Transform, circleB: box2d.b2CircleShape, xfB: box2d.b2Transform): void;
// Compute the collision manifold between an edge and a polygon.
static b2CollideEdgeAndPolygon(manifold: box2d.b2Manifold, edgeA: box2d.b2EdgeShape, xfA: box2d.b2Transform, polygonB: box2d.b2PolygonShape, xfB: box2d.b2Transform): void;
// Find the max separation between poly1 and poly2 using edge
// normals from poly1.
static b2FindMaxSeparation(edgeIndex: Array<number>, poly1: box2d.b2PolygonShape, xf1: box2d.b2Transform, poly2: box2d.b2PolygonShape, xf2: box2d.b2Transform): number;
static b2FindIncidentEdge(c: Array<box2d.b2ClipVertex>, poly1: box2d.b2PolygonShape, xf1: box2d.b2Transform, edge1: number, poly2: box2d.b2PolygonShape, xf2: box2d.b2Transform): void;
// Find edge normal of max separation on A - return if separating axis is found
// Find edge normal of max separation on B - return if separation axis is found
// Choose reference edge as min(minA, minB)
// Find incident edge
// Clip
// The normal points from 1 to 2
static b2CollidePolygons(manifold: box2d.b2Manifold, polyA: box2d.b2PolygonShape, xfA: box2d.b2Transform, polyB: box2d.b2PolygonShape, xfB: box2d.b2Transform): void;
// Compute the collision manifold between two circles.
static b2CollideCircles(manifold: box2d.b2Manifold, circleA: box2d.b2CircleShape, xfA: box2d.b2Transform, circleB: box2d.b2CircleShape, xfB: box2d.b2Transform): void;
// Compute the collision manifold between a polygon and a
// circle.
static b2CollidePolygonAndCircle(manifold: box2d.b2Manifold, polygonA: box2d.b2PolygonShape, xfA: box2d.b2Transform, circleB: box2d.b2CircleShape, xfB: box2d.b2Transform): void;
// This is used to sort pairs.
static b2PairLessThan(pair1: box2d.b2Pair, pair2: box2d.b2Pair): number;
static b2_minPulleyLength: number;
}
declare module box2d {
enum b2JointType {
e_unknownJoint = 0,
e_revoluteJoint = 1,
e_prismaticJoint = 2,
e_distanceJoint = 3,
e_pulleyJoint = 4,
e_mouseJoint = 5,
e_gearJoint = 6,
e_wheelJoint = 7,
e_weldJoint = 8,
e_frictionJoint = 9,
e_ropeJoint = 10,
e_motorJoint = 11,
e_areaJoint = 12
}
enum b2LimitState {
e_inactiveLimit = 0,
e_atLowerLimit = 1,
e_atUpperLimit = 2,
e_equalLimits = 3
}
enum b2ContactFeatureType {
e_vertex = 0,
e_face = 1
}
enum b2ManifoldType {
e_unknown = -1,
e_circles = 0,
e_faceA = 1,
e_faceB = 2
}
// This is used for determining the state of contact points.
enum b2PointState {
b2_nullState = 0, ///< point does not exist
b2_addState = 1, ///< point was added in the update
b2_persistState = 2, ///< point persisted across the update
b2_removeState = 3 ///< point was removed in the update
}
enum b2TOIOutputState {
e_unknown = 0,
e_failed = 1,
e_overlapped = 2,
e_touching = 3,
e_separated = 4
}
enum b2SeparationFunctionType {
e_unknown = -1,
e_points = 0,
e_faceA = 1,
e_faceB = 2
}
// Flags stored in m_flags
enum b2ContactFlag {
e_none = 0,
e_islandFlag = 0x0001, /// Used when crawling contact graph when forming islands.
e_touchingFlag = 0x0002, /// Set when the shapes are touching.
e_enabledFlag = 0x0004, /// This contact can be disabled (by user)
e_filterFlag = 0x0008, /// This contact needs filtering because a fixture filter was changed.
e_bulletHitFlag = 0x0010, /// This bullet contact had a TOI event
e_toiFlag = 0x0020 /// This contact has a valid TOI in m_toi
}
enum b2ShapeType {
e_unknown = -1,
e_circleShape = 0,
e_edgeShape = 1,
e_polygonShape = 2,
e_chainShape = 3,
e_shapeTypeCount = 4
}
enum b2EPAxisType {
e_unknown = 0,
e_edgeA = 1,
e_edgeB = 2
}
enum b2EPColliderVertexType {
e_isolated = 0,
e_concave = 1,
e_convex = 2
}
enum b2DrawFlags {
e_none = 0,
e_shapeBit = 0x0001, ///< draw shapes
e_jointBit = 0x0002, ///< draw joint connections
e_aabbBit = 0x0004, ///< draw axis aligned bounding boxes
e_pairBit = 0x0008, ///< draw broad-phase pairs
e_centerOfMassBit = 0x0010, ///< draw center of mass frame
e_controllerBit = 0x0020, /// @see box2d.b2Controller list
e_all = 0x003f
}
// The body type.
// enum= zero mass, zero velocity, may be manually moved
// kinematic= zero mass, non-zero velocity set by user, moved by solver
// dynamic= positive mass, non-zero velocity determined by forces, moved by solver
enum b2BodyType {
b2_unknown = -1,
b2_staticBody = 0,
b2_kinematicBody = 1,
b2_dynamicBody = 2,
b2_bulletBody = 3 // TODO_ERIN
}
enum b2BodyFlag {
e_none = 0,
e_islandFlag = 0x0001,
e_awakeFlag = 0x0002,
e_autoSleepFlag = 0x0004,
e_bulletFlag = 0x0008,
e_fixedRotationFlag = 0x0010,
e_activeFlag = 0x0020,
e_toiFlag = 0x0040
}
enum b2WorldFlag {
e_none = 0,
e_newFixture = 0x1,
e_locked = 0x2,
e_clearForces = 0x4
}
class b2Version {
// Version numberinf scheme See
// http://en.wikipedia.org/wiki/Software_versioning
constructor(major?: number, minor?: number, revision?: number);
major: number;
minor: number;
revision: number;
toString(): string;
}
class b2Vec2 {
// A 2D column vector.
constructor(x?: number, y?: number);
x: number;
y: number;
static ZERO: b2Vec2;
static UNITX: b2Vec2;
static UNITY: b2Vec2;
static s_t0: b2Vec2;
static s_t1: b2Vec2;
static s_t2: b2Vec2;
static s_t3: b2Vec2;
static MakeArray(length?: number): Array<b2Vec2>;
Clone(): b2Vec2;
// Set this vector to all zeros.
SetZero(): b2Vec2;
// Set this vector to some specified coordinates.
SetXY(x: number, y: number): b2Vec2;
Copy(other: b2Vec2): b2Vec2;
// Add a vector to this vector.
SelfAdd(v: b2Vec2): b2Vec2;
SelfAddXY(x: number, y: number): b2Vec2;
// Subtract a vector from this vector.
SelfSub(v: b2Vec2): b2Vec2;
SelfSubXY(x: number, y: number): b2Vec2;
// Multiply this vector by a scalar.
SelfMul(s: number): b2Vec2;
// this += s * v
SelfMulAdd(s: number, v: b2Vec2): b2Vec2;
// this -= s * v
SelfMulSub(s: number, v: b2Vec2): b2Vec2;
Dot(v: b2Vec2): number;
Cross(v: b2Vec2): number;
// Get the length of this vector (the norm).
Length(): number;
GetLength(): number;
// Get the length squared. For performance, use this instead of
// b2Vec2::Length (if possible).
LengthSquared(): number;
GetLengthSquared(): number;
// Convert this vector into a unit vector. Returns the length.
Normalize(): number;
SelfNormalize(): b2Vec2;
SelfRotate(c: number, s: number): b2Vec2;
SelfRotateRadians(radians: number): b2Vec2;
SelfRotateDegrees(degrees: number): b2Vec2;
// Does this vector contain finite coordinates?
IsValid(): boolean;
SelfCrossVS(s: number): b2Vec2;
SelfCrossSV(s: number): b2Vec2;
SelfMinV(v: b2Vec2): b2Vec2;
SelfMaxV(v: b2Vec2): b2Vec2;
SelfAbs(): b2Vec2;
SelfNeg(): b2Vec2;
// Get the skew vector such that dot(skew_vec, other) ===
// cross(vec, other)
SelfSkew(): b2Vec2;
}
class b2Vec3 {
constructor(x?: number, y?: number, z?: number);
x: number;
y: number;
z: number;
static ZERO: b2Vec3;
static s_t0: b2Vec3;
Clone(): b2Vec3;
SetZero(): b2Vec3;
SetXYZ(x: number, y: number, z: number): b2Vec3;
Copy(other: b2Vec3): b2Vec3;
SelfNeg(): b2Vec3;
SelfAdd(v: b2Vec3): b2Vec3;
SelfAddXYZ(x: number, y: number, z: number): b2Vec3;
SelfSub(v: b2Vec3): b2Vec3;
SelfSubXYZ(x: number, y: number, z: number): b2Vec3;
SelfMul(s: number): b2Vec3;
}
class b2Mat22 {
// A 2-by-2 matrix. Stored in column-major order.
constructor();
ex: b2Vec2;
ey: b2Vec2;
static IDENTITY: b2Mat22;
Clone(): b2Mat22;
// Construct this matrix using columns.
static FromVV(c1: b2Vec2, c2: b2Vec2): b2Mat22;
// Construct this matrix using scalars.
static FromSSSS(r1c1: number, r1c2: number, r2c1: number, r2c2: number): b2Mat22;
// Construct this matrix using an angle. This matrix becomes an
// orthonormal rotation matrix.
static FromAngleRadians(radians: number): b2Mat22;
// Initialize this matrix using scalars.
SetSSSS(r1c1: number, r1c2: number, r2c1: number, r2c2: number): b2Mat22;
// Initialize this matrix using columns.
SetVV(c1: b2Vec2, c2: b2Vec2): b2Mat22;
// Initialize this matrix using an angle. This matrix becomes an
// orthonormal rotation matrix.
SetAngle(radians: number): b2Mat22;
Copy(other: b2Mat22): b2Mat22;
// Set this to the identity matrix.
SetIdentity(): b2Mat22;
// Set this matrix to all zeros.
SetZero(): b2Mat22;
// Extract the angle from this matrix (assumed to be a rotation
// matrix).
GetAngle(): number;
GetInverse(out: b2Mat22): b2Mat22;
// Solve A * x = b, where b is a column vector. This is more
// efficient than computing the inverse in one-shot cases.
Solve(b_x: number, b_y: number, out: b2Vec2): b2Vec2;
SelfAbs(): b2Mat22;
SelfInv(): b2Mat22;
SelfAddM(M: b2Mat22): b2Mat22;
SelfSubM(M: b2Mat22): b2Mat22;
}
class b2Mat33 {
// A 3-by-3 matrix. Stored in column-major order.
constructor();
ex: b2Vec3;
ey: b2Vec3;
ez: b2Vec3;
static IDENTITY: b2Mat33;
Clone(): b2Mat33;
SetVVV(c1: b2Vec3, c2: b2Vec3, c3: b2Vec3): b2Mat33;
Copy(other: b2Mat33): b2Mat33;
SetIdentity(): b2Mat33;
// Set this matrix to all zeros.
SetZero(): b2Mat33;
SelfAddM(M: b2Mat33): b2Mat33;
// Solve A * x = b, where b is a column vector. This is more
// efficient than computing the inverse in one-shot cases.
Solve33(b_x: number, b_y: number, b_z: number, out: b2Vec3): b2Vec3;
// Solve A * x = b, where b is a column vector. This is more
// efficient than computing the inverse in one-shot cases. Solve
// only the upper 2-by-2 matrix equation.
Solve22(b_x: number, b_y: number, out: b2Vec2): b2Vec2;
// Get the inverse of this matrix as a 2-by-2.
// Returns the zero matrix if singular.
GetInverse22(M: b2Mat33): void;
// Get the symmetric inverse of this matrix as a 3-by-3.
// Returns the zero matrix if singular.
GetSymInverse33(M: b2Mat33): void;
}
class b2Rot {
// Rotation
// Initialize from an angle in radians
constructor(angle?: number);
angle: number;
s: number;
c: number;
static IDENTITY: b2Rot;
Clone(): b2Rot;
Copy(other: b2Rot): b2Rot;
// Set using an angle in radians.
SetAngle(angle: number): b2Rot;
// Set to the identity rotation
SetIdentity(): b2Rot;
// Get the angle in radians
GetAngle(): number;
// Get the x-axis
GetXAxis(out: b2Vec2): b2Vec2;
// Get the y-axis
GetYAxis(out: b2Vec2): b2Vec2;
}
class b2Transform {
// A transform contains translation and rotation. It is used to
// represent the position and orientation of rigid frames.
constructor();
p: b2Vec2;
q: b2Rot;
static IDENTITY: b2Transform;
Clone(): b2Transform;
Copy(other: b2Transform): b2Transform;
// Set this to the identity transform.
SetIdentity(): b2Transform;
// Set this based on the position and angle.
SetPositionRotation(position: b2Vec2, q: b2Rot): b2Transform;
SetPositionAngleRadians(pos: b2Vec2, a: number): b2Transform;
SetPosition(position: b2Vec2): b2Transform;
SetPositionXY(x: number, y: number): b2Transform;
SetRotation(rotation: b2Rot): b2Transform;
SetRotationAngleRadians(radians: number): b2Transform;
GetPosition(): b2Vec2;
GetRotation(): b2Rot;
GetRotationAngle(): number;
GetAngle(): number;
}
class b2Sweep {
// This describes the motion of a body/shape for TOI computation.
// Shapes are defined with respect to the body origin, which may
// no coincide with the center of mass. However, to support dynamics
// we must interpolate the center of mass position.
constructor();
localCenter: b2Vec2;
c0: b2Vec2;
c: b2Vec2;
a0: number;
a: number;
// Fraction of the current time step in the range [0,1]
// c0 and a0 are the positions at alpha0.
alpha0: number;
Clone(): b2Sweep;
Copy(other: b2Sweep): b2Sweep;
// Get the interpolated transform at a specific time.
GetTransform(xf: b2Transform, beta: number): b2Transform;
// Advance the sweep forward, yielding a new initial state.
Advance(alpha: number): void;
// Normalize an angle in radians to be between -pi and pi
// (actually 0 and 2*pi)
Normalize(): void;
}
class b2ControllerEdge {
// A controller edge is used to connect bodies and controllers
// together in a bipartite graph.
constructor();
controller: b2Controller;
body: b2Body;
prevBody: b2ControllerEdge;
nextBody: b2ControllerEdge;
prevController: b2ControllerEdge;
nextController: b2ControllerEdge;
}
class b2Controller {
// Base class for controllers. Controllers are a convience for
// encapsulating common per-step functionality.
constructor();
m_world: b2World;
m_bodyList: b2ControllerEdge;
m_bodyCount: number;
m_prev: b2Controller;
m_next: b2Controller;
// Controllers override this to implement per-step
// functionality.
Step(step: b2TimeStep): void;
// Controllers override this to provide debug drawing.
Draw(debugDraw: b2Draw): void;
// Get the next controller in the world's body list.
GetNext(): b2Controller;
// Get the previous controller in the world's body list.
GetPrev(): b2Controller;
// Get the parent world of this body.
GetWorld(): b2World;
// Get the attached body list
GetBodyList(): b2ControllerEdge;
// Adds a body to the controller list.
AddBody(body: b2Body): void;
// Removes a body from the controller list.
RemoveBody(body: b2Body): void;
// Removes all bodies from the controller list.
Clear(): void;
}
class b2ConstantAccelController extends b2Controller {
// Applies a force every frame
constructor();
// The acceleration to apply
A: b2Vec2;
Step(step: b2TimeStep): void;
// The force to apply
F: b2Vec2;
}
class b2Jacobian {
constructor();
linear: b2Vec2;
angularA: number;
angularB: number;
SetZero(): b2Jacobian;
Set(x: b2Vec2, a1: number, a2: number): b2Jacobian;
}
class b2JointEdge {
// A joint edge is used to connect bodies and joints together in
// a joint graph where each body is a node and each joint is an
// edge. A joint edge belongs to a doubly linked list maintained
// in each attached body. Each joint has two joint nodes, one
// for each attached body.
constructor();
other: b2Body;
joint: b2Joint;
prev: b2JointEdge;
next: b2JointEdge;
}
class b2JointDef {
// Joint definitions are used to construct joints.
constructor(type: b2JointType);
// The joint type is set automatically for concrete joint types.
type: b2JointType;
// Use this to attach application specific data to your joints.
userData: any;
// The first attached body.
bodyA: b2Body;
// The second attached body.
bodyB: b2Body;
// Set this flag to true if the attached bodies should collide.
collideConnected: boolean;
}
class b2Joint {
// The base joint class. Joints are used to constraint two
// bodies together in various fashions. Some joints also feature
// limits and motors.
constructor();
m_type: b2JointType;
m_prev: b2Joint;
m_next: b2Joint;
m_edgeA: b2JointEdge;
m_edgeB: b2JointEdge;
m_bodyA: b2Body;
m_bodyB: b2Body;
m_index: number;
m_islandFlag: boolean;
m_collideConnected: boolean;
m_userData: any;
// Get the anchor point on bodyA in world coordinates.
GetAnchorA(out: b2Vec2): b2Vec2;
// Get the anchor point on bodyB in world coordinates.
GetAnchorB(out: b2Vec2): b2Vec2;
// Get the reaction force on bodyB at the joint anchor in
// Newtons.
GetReactionForce(inv_dt: number, out: b2Vec2): b2Vec2;
// Get the reaction torque on bodyB in N*m.
GetReactionTorque(inv_dt: number): number;
InitVelocityConstraints(data: b2SolverData): void;
SolveVelocityConstraints(data: b2SolverData): void;
// This returns true if the position errors are within
// tolerance.
SolvePositionConstraints(data: b2SolverData): boolean;
// Get the type of the concrete joint.
GetType(): b2JointType;
// Get the first body attached to this joint.
GetBodyA(): b2Body;
// Get the second body attached to this joint.
GetBodyB(): b2Body;
// Get the next joint the world joint list.
GetNext(): b2Joint;
// Get the user data pointer.
GetUserData(): any;
// Set the user data pointer.
SetUserData(data: any): void;
// Get collide connected.
// Note: modifying the collide connect flag won't work correctly
// because the flag is only checked when fixture AABBs begin to
// overlap.
GetCollideConnected(): boolean;
// Dump this joint to the log file.
Dump(): void;
// Short-cut function to determine if either body is inactive.
IsActive(): boolean;
// Shift the origin for any points stored in world coordinates.
ShiftOrigin(newOrigin: b2Vec2): void;
}
class b2RevoluteJointDef extends b2JointDef {
// Revolute joint definition. This requires defining an anchor
// point where the bodies are joined. The definition uses local
// anchor points so that the initial configuration can violate
// the constraint slightly. You also need to specify the initial
// relative angle for joint limits. This helps when saving and
// loading a game.
// The local anchor points are measured from the body's origin
// rather than the center of mass because:
// 1. you might not know where the center of mass will be.
// 2. if you add/remove shapes from a body and recompute the
// mass, the joints will be broken.
constructor();
// The local anchor point relative to bodyA's origin.
localAnchorA: b2Vec2;
// The local anchor point relative to bodyB's origin.
localAnchorB: b2Vec2;
// The bodyB angle minus bodyA angle in the reference state
// (radians).
referenceAngle: number;
// A flag to enable joint limits.
enableLimit: boolean;
// The lower angle for the joint limit (radians).
lowerAngle: number;
// The upper angle for the joint limit (radians).
upperAngle: number;
// A flag to enable the joint motor.
enableMotor: boolean;
// The desired motor speed. Usually in radians per second.
motorSpeed: number;
// The maximum motor torque used to achieve the desired motor
// speed.
// Usually in N-m.
maxMotorTorque: number;
Initialize(bA: b2Body, bB: b2Body, anchor: b2Vec2): void;
}
class b2RevoluteJoint extends b2Joint {
// A revolute joint constrains two bodies to share a common
// point while they are free to rotate about the point. The
// relative rotation about the shared point is the joint angle.
// You can limit the relative rotation with a joint limit that
// specifies a lower and upper angle. You can use a motor to
// drive the relative rotation about the shared point. A maximum
// motor torque is provided so that infinite forces are not
// generated.
constructor(def: b2RevoluteJointDef);
m_localAnchorA: b2Vec2;
m_localAnchorB: b2Vec2;
m_impulse: b2Vec3;
m_motorImpulse: number;
m_enableMotor: boolean;
m_maxMotorTorque: number;
m_motorSpeed: number;
m_enableLimit: boolean;
m_referenceAngle: number;
m_lowerAngle: number;
m_upperAngle: number;
m_indexA: number;
m_indexB: number;
m_rA: b2Vec2;
m_rB: b2Vec2;
m_localCenterA: b2Vec2;
m_localCenterB: b2Vec2;
m_invMassA: number;
m_invMassB: number;
m_invIA: number;
m_invIB: number;
m_mass: b2Mat33;
m_motorMass: number;
m_limitState: b2LimitState;
m_qA: b2Rot;
m_qB: b2Rot;
m_lalcA: b2Vec2;
m_lalcB: b2Vec2;
m_K: b2Mat22;
InitVelocityConstraints(data: b2SolverData): void;
SolveVelocityConstraints(data: b2SolverData): void;
SolvePositionConstraints(data: b2SolverData): boolean;
GetAnchorA(out: b2Vec2): b2Vec2;
GetAnchorB(out: b2Vec2): b2Vec2;
// Get the reaction force given the inverse time step.
// Unit is N.
GetReactionForce(inv_dt: number, out: b2Vec2): b2Vec2;
// Get the reaction torque due to the joint limit given the
// inverse time step.
// Unit is N*m.
GetReactionTorque(inv_dt: number): number;
// The local anchor point relative to bodyA's origin.
GetLocalAnchorA(out: b2Vec2): b2Vec2;
// The local anchor point relative to bodyB's origin.
GetLocalAnchorB(out?: b2Vec2): b2Vec2;
// Get the reference angle.
GetReferenceAngle(): number;
GetJointAngleRadians(): number;
GetJointSpeed(): number;
IsMotorEnabled(): boolean;
EnableMotor(flag: boolean): void;
// Get the current motor torque given the inverse time step.
// Unit is N*m.
GetMotorTorque(inv_dt: number): number;
GetMotorSpeed(): number;
SetMaxMotorTorque(torque: number): void;
GetMaxMotorTorque(): number;
IsLimitEnabled(): boolean;
EnableLimit(flag: boolean): void;
GetLowerLimit(): number;
GetUpperLimit(): number;
SetLimits(lower: number, upper: number): void;
SetMotorSpeed(speed: number): void;
// Dump to b2Log.
Dump(): void;
}
class b2PrismaticJointDef extends b2JointDef {
// Prismatic joint definition. This requires defining a line of
// motion using an axis and an anchor point. The definition uses
// local anchor points and a local axis so that the initial
// configuration can violate the constraint slightly. The joint
// translation is zero when the local anchor points coincide in
// world space. Using local anchors and a local axis helps when
// saving and loading a game.
constructor();
// The local anchor point relative to bodyA's origin.
localAnchorA: b2Vec2;
// The local anchor point relative to bodyB's origin.
localAnchorB: b2Vec2;
// The local translation unit axis in bodyA.
localAxisA: b2Vec2;
// The constrained angle between the bodies: bodyB_angle -
// bodyA_angle.
referenceAngle: number;
// Enable/disable the joint limit.
enableLimit: boolean;
// The lower translation limit, usually in meters.
lowerTranslation: number;
// The upper translation limit, usually in meters.
upperTranslation: number;
// Enable/disable the joint motor.
enableMotor: boolean;
// The maximum motor torque, usually in N-m.
maxMotorForce: number;
// The desired motor speed in radians per second.
motorSpeed: number;
// Initialize the bodies, anchors, axis, and reference angle
// using the world anchor and unit world axis.
Initialize(bA: b2Body, bB: b2Body, anchor: b2Vec2, axis: b2Vec2): void;
}
class b2PrismaticJoint extends b2Joint {
// A prismatic joint. This joint provides one degree of freedom:
// translation along an axis fixed in bodyA. Relative rotation
// is prevented. You can use a joint limit to restrict the range
// of motion and a joint motor to drive the motion or to model
// joint friction.
constructor(def: b2PrismaticJointDef);
m_localAnchorA: b2Vec2;
m_localAnchorB: b2Vec2;
m_localXAxisA: b2Vec2;
m_localYAxisA: b2Vec2;
m_referenceAngle: number;
m_impulse: b2Vec3;
m_motorImpulse: number;
m_lowerTranslation: number;
m_upperTranslation: number;
m_maxMotorForce: number;
m_motorSpeed: number;
m_enableLimit: boolean;
m_enableMotor: boolean;
m_limitState: b2LimitState;
m_indexA: number;
m_indexB: number;
m_localCenterA: b2Vec2;
m_localCenterB: b2Vec2;
m_invMassA: number;
m_invMassB: number;
m_invIA: number;
m_invIB: number;
m_axis: b2Vec2;
m_perp: b2Vec2;
m_s1: number;
m_s2: number;
m_a1: number;
m_a2: number;
m_K: b2Mat33;
m_K3: b2Mat33;
m_K2: b2Mat22;
m_motorMass: number;
m_qA: b2Rot;
m_qB: b2Rot;
m_lalcA: b2Vec2;
m_lalcB: b2Vec2;
m_rA: b2Vec2;
m_rB: b2Vec2;
InitVelocityConstraints(data: b2SolverData): void;
SolveVelocityConstraints(data: b2SolverData): void;
SolvePositionConstraints(data: b2SolverData): boolean;
GetAnchorA(out: b2Vec2): b2Vec2;
GetAnchorB(out: b2Vec2): b2Vec2;
GetReactionForce(inv_dt: number, out: b2Vec2): b2Vec2;
GetReactionTorque(inv_dt: number): number;
// The local anchor point relative to bodyA's origin.
GetLocalAnchorA(out: b2Vec2): b2Vec2;
// The local anchor point relative to bodyB's origin.
GetLocalAnchorB(out: b2Vec2): b2Vec2;
// The local joint axis relative to bodyA.
GetLocalAxisA(out: b2Vec2): b2Vec2;
// Get the reference angle.
GetReferenceAngle(): number;
GetJointTranslation(): number;
GetJointSpeed(): number;
IsLimitEnabled(): boolean;
EnableLimit(flag: boolean): void;
GetLowerLimit(): number;
GetUpperLimit(): number;
SetLimits(upper: number, lower: number): void;
IsMotorEnabled(): boolean;
EnableMotor(flag: boolean): void;
SetMotorSpeed(speed: number): void;
GetMotorSpeed(): number;
SetMaxMotorForce(force: number): void;
GetMaxMotorForce(): number;
GetMotorForce(inv_dt: number): number;
// Dump to b2Log
Dump(): void;
}
class b2GearJointDef extends b2JointDef {
// Gear joint definition. This definition requires two existing
// revolute or prismatic joints (any combination will work).
constructor();
// The first revolute/prismatic joint attached to the gear
// joint.
joint1: b2Joint;
// The second revolute/prismatic joint attached to the gear
// joint.
joint2: b2Joint;
// The gear ratio.
ratio: number;
}
class b2GearJoint extends b2Joint {
// A gear joint is used to connect two joints together. Either
// joint can be a revolute or prismatic joint. You specify a
// gear ratio to bind the motions together:
// coordinateA + ratio * coordinateB = constant
// The ratio can be negative or positive. If one joint is a
// revolute joint and the other joint is a prismatic joint, then
// the ratio will have units of length or units of 1/length.
// warning You have to manually destroy the gear joint if jointA
// or jointB is destroyed.
constructor(def: b2GearJointDef);
m_joint1: b2Joint;
m_joint2: b2Joint;
m_typeA: b2JointType;
m_typeB: b2JointType;
m_bodyC: b2Body;
m_bodyD: b2Body;
m_localAnchorA: b2Vec2;
m_localAnchorB: b2Vec2;
m_localAnchorC: b2Vec2;
m_localAnchorD: b2Vec2;
m_localAxisC: b2Vec2;
m_localAxisD: b2Vec2;
m_referenceAngleA: number;
m_referenceAngleB: number;
m_constant: number;
m_ratio: number;
m_impulse: number;
m_indexA: number;
m_indexB: number;
m_indexC: number;
m_indexD: number;
m_lcA: b2Vec2;
m_lcB: b2Vec2;
m_lcC: b2Vec2;
m_lcD: b2Vec2;
m_mA: number;
m_mB: number;
m_mC: number;
m_mD: number;
m_iA: number;
m_iB: number;
m_iC: number;
m_iD: number;
m_JvAC: b2Vec2;
m_JvBD: b2Vec2;
m_JwA: number;
m_JwB: number;
m_JwC: number;
m_JwD: number;
m_mass: number;
m_qA: b2Rot;
m_qB: b2Rot;
m_qC: b2Rot;
m_qD: b2Rot;
m_lalcA: b2Vec2;
m_lalcB: b2Vec2;
m_lalcC: b2Vec2;
m_lalcD: b2Vec2;
InitVelocityConstraints(data: b2SolverData): void;
SolveVelocityConstraints(data: b2SolverData): void;
SolvePositionConstraints(data: b2SolverData): boolean;
GetAnchorA(out: b2Vec2): b2Vec2;
GetAnchorB(out: b2Vec2): b2Vec2;
GetReactionForce(inv_dt: number, out: b2Vec2): b2Vec2;
GetReactionTorque(inv_dt: number): number;
// Get the first joint.
GetJoint1(): b2Joint;
// Get the second joint.
GetJoint2(): b2Joint;
GetRatio(): number;
SetRatio(ratio: number): void;
// Dump joint to dmLog
Dump(): void;
}
class b2DistanceProxy {
// A distance proxy is used by the GJK algorithm.
// It encapsulates any shape.
constructor();
m_buffer: Array<b2Vec2>;
m_vertices: Array<b2Vec2>;
m_count: number;
m_radius: number;
Reset(): b2DistanceProxy;
// Initialize the proxy using the given shape. The shape must
// remain in scope while the proxy is in use.
SetShape(shape: b2Shape, index: number): void;
// Get the supporting vertex index in the given direction.
GetSupport(d: b2Vec2): number;
// Get the supporting vertex in the given direction.
GetSupportVertex(d: b2Vec2, out: b2Vec2): b2Vec2;
// Get the vertex count.
GetVertexCount(): number;
// Get a vertex by index. Used by box2d.b2Distance.
GetVertex(index: number): b2Vec2;
}
class b2SimplexCache {
// Used to warm start box2d.b2Distance.
// Set count to zero on first call.
constructor();
metric: number;
count: number;
indexA: Array<number>;
indexB: Array<number>;
Reset(): b2SimplexCache;
}
class b2DistanceInput {
// Input for box2d.b2Distance.
// You have to option to use the shape radii in the computation.
constructor();
proxyA: b2DistanceProxy;
proxyB: b2DistanceProxy;
transformA: b2Transform;
transformB: b2Transform;
useRadii: boolean;
Reset(): b2DistanceInput;
}
class b2DistanceOutput {
// Output for box2d.b2Distance.
constructor();
pointA: b2Vec2;
pointB: b2Vec2;
distance: number;
iterations: number;
Reset(): b2DistanceOutput;
}
class b2SimplexVertex {
constructor();
wA: b2Vec2;
wB: b2Vec2;
w: b2Vec2;
a: number;
indexA: number;
indexB: number;
Copy(other: b2SimplexVertex): b2SimplexVertex;
}
class b2Simplex {
constructor();
m_v1: b2SimplexVertex;
m_v2: b2SimplexVertex;
m_v3: b2SimplexVertex;
m_vertices: Array<b2SimplexVertex>;
m_count: number;
ReadCache(cache: b2SimplexCache, proxyA: b2DistanceProxy, transformA: b2Transform, proxyB: b2DistanceProxy, transformB: b2Transform): void;
WriteCache(cache: b2SimplexCache): void;
GetSearchDirection(out: b2Vec2): b2Vec2;
GetClosestPoint(out: b2Vec2): b2Vec2;
GetWitnessPoints(pA: b2Vec2, pB: b2Vec2): void;
GetMetric(): number;
// Solve a line segment using barycentric coordinates.
//
// p = a1 * w1 + a2 * w2
// a1 + a2 = 1
//
// The vector from the origin to the closest point on the line is
// perpendicular to the line.
// e12 = w2 - w1
// dot(p, e) = 0
// a1 * dot(w1, e) + a2 * dot(w2, e) = 0
//
// 2-by-2 linear system
// [1 1 ][a1] = [1]
// [w1.e12 w2.e12][a2] = [0]
//
// Define
// d12_1 = dot(w2, e12)
// d12_2 = -dot(w1, e12)
// d12 = d12_1 + d12_2
//
// Solution
// a1 = d12_1 / d12
// a2 = d12_2 / d12
//
Solve2(): void;
// Possible regions:
// - points[2]
// - edge points[0]-points[2]
// - edge points[1]-points[2]
// - inside the triangle
Solve3(): void;
}
class b2WeldJointDef extends b2JointDef {
// Weld joint definition. You need to specify local anchor
// points where they are attached and the relative body angle.
// The position of the anchor points is important for computing
// the reaction torque.
constructor();
// The local anchor point relative to bodyA's origin.
localAnchorA: b2Vec2;
// The local anchor point relative to bodyB's origin.
localAnchorB: b2Vec2;
// The bodyB angle minus bodyA angle in the reference state
// (radians).
referenceAngle: number;
// The mass-spring-damper frequency in Hertz. Rotation only.
// Disable softness with a value of 0.
frequencyHz: number;
// The damping ratio. 0 = no damping, 1 = critical damping.
dampingRatio: number;
Initialize(bA: b2Body, bB: b2Body, anchor: b2Vec2): void;
}
class b2WeldJoint extends b2Joint {
// A weld joint essentially glues two bodies together. A weld
// joint may distort somewhat because the island constraint
// solver is approximate.
constructor(def: b2WeldJointDef);
m_frequencyHz: number;
m_dampingRatio: number;
m_bias: number;
m_localAnchorA: b2Vec2;
m_localAnchorB: b2Vec2;
m_referenceAngle: number;
m_gamma: number;
m_impulse: b2Vec3;
m_indexA: number;
m_indexB: number;
m_rA: b2Vec2;
m_rB: b2Vec2;
m_localCenterA: b2Vec2;
m_localCenterB: b2Vec2;
m_invMassA: number;
m_invMassB: number;
m_invIA: number;
m_invIB: number;
m_mass: b2Mat33;
m_qA: b2Rot;
m_qB: b2Rot;
m_lalcA: b2Vec2;
m_lalcB: b2Vec2;
m_K: b2Mat33;
InitVelocityConstraints(data: b2SolverData): void;
SolveVelocityConstraints(data: b2SolverData): void;
SolvePositionConstraints(data: b2SolverData): boolean;
GetAnchorA(out: b2Vec2): b2Vec2;
GetAnchorB(out: b2Vec2): b2Vec2;
GetReactionForce(inv_dt: number, out: b2Vec2): b2Vec2;
GetReactionTorque(inv_dt: number): number;
// The local anchor point relative to bodyA's origin.
GetLocalAnchorA(out: b2Vec2): b2Vec2;
// The local anchor point relative to bodyB's origin.
GetLocalAnchorB(out: b2Vec2): b2Vec2;
// Get the reference angle.
GetReferenceAngle(): number;
// Set/get frequency in Hz.
SetFrequency(hz: number): void;
GetFrequency(): number;
// Set/get damping ratio.
SetDampingRatio(ratio: number): void;
GetDampingRatio(): number;
// Dump to b2Log
Dump(): void;
}
class b2RopeJointDef extends b2JointDef {
// Rope joint definition. This requires two body anchor points
// and a maximum lengths.
// Note: by default the connected objects will not collide. see
// collideConnected in box2d.b2JointDef.
constructor();
// The local anchor point relative to bodyA's origin.
localAnchorA: b2Vec2;
// The local anchor point relative to bodyB's origin.
localAnchorB: b2Vec2;
// The maximum length of the rope.
// Warning: this must be larger than box2d.b2_linearSlop or the
// joint will have no effect.
maxLength: number;
}
class b2RopeJoint extends b2Joint {
// A rope joint enforces a maximum distance between two points
// on two bodies. It has no other effect.
// Warning: if you attempt to change the maximum length during
// the simulation you will get some non-physical behavior. A
// model that would allow you to dynamically modify the length
// would have some sponginess, so I chose not to implement it
// that way. See box2d.b2DistanceJoint if you want to
// dynamically control length.
constructor(def: b2RopeJointDef);
m_localAnchorA: b2Vec2;
m_localAnchorB: b2Vec2;
m_maxLength: number;
m_length: number;
m_impulse: number;
m_indexA: number;
m_indexB: number;
m_u: b2Vec2;
m_rA: b2Vec2;
m_rB: b2Vec2;
m_localCenterA: b2Vec2;
m_localCenterB: b2Vec2;
m_invMassA: number;
m_invMassB: number;
m_invIA: number;
m_invIB: number;
m_mass: number;
m_state: b2LimitState;
m_qA: b2Rot;
m_qB: b2Rot;
m_lalcA: b2Vec2;
m_lalcB: b2Vec2;
InitVelocityConstraints(data: b2SolverData): void;
SolveVelocityConstraints(data: b2SolverData): void;
SolvePositionConstraints(data: b2SolverData): boolean;
GetAnchorA(out: b2Vec2): b2Vec2;
GetAnchorB(out: b2Vec2): b2Vec2;
GetReactionForce(inv_dt: number, out: b2Vec2): b2Vec2;
GetReactionTorque(inv_dt: number): number;
// The local anchor point relative to bodyA's origin.
GetLocalAnchorA(out: b2Vec2): b2Vec2;
// The local anchor point relative to bodyB's origin.
GetLocalAnchorB(out: b2Vec2): b2Vec2;
// Set/Get the maximum length of the rope.
SetMaxLength(length: number): void;
GetMaxLength(): number;
GetLimitState(): b2LimitState;
// Dump joint to dmLog
Dump(): void;
}
class b2GravityController extends b2Controller {
// Applies simplified gravity between every pair of bodies
constructor();
// Specifies the strength of the gravitiation force
G: number;
// If true, gravity is proportional to r^-2, otherwise r^-1
invSqr: boolean;
Step(step: b2TimeStep): void;
}
class b2Profile {
// Profiling data. Times are in milliseconds.
constructor();
step: number;
collide: number;
solve: number;
solveInit: number;
solveVelocity: number;
solvePosition: number;
broadphase: number;
solveTOI: number;
Reset(): b2Profile;
}
class b2TimeStep {
// This is an internal structure.
constructor();
dt: number;
inv_dt: number;
dtRatio: number;
velocityIterations: number;
positionIterations: number;
warmStarting: boolean;
Copy(step: b2TimeStep): b2TimeStep;
}
class b2Position {
// This is an internal structure.
constructor();
c: b2Vec2;
a: number;
static MakeArray(length: number): Array<b2Position>;
}
class b2Velocity {
// This is an internal structure.
constructor();
v: b2Vec2;
w: number;
static MakeArray(length: number): Array<b2Velocity>;
}
class b2SolverData {
// Solver Data
constructor();
step: b2TimeStep;
positions: Array<b2Position>;
velocities: Array<b2Velocity>;
}
class b2ContactFeature {
// The features that intersect to form the contact point
// This must be 4 bytes or less.
constructor(id: b2ContactID);
_id: b2ContactID;
_indexA: number;
_indexB: number;
_typeA: number;
_typeB: number;
indexA: number;
indexB: number;
typeA: number;
typeB: number;
}
class b2ContactID {
// Contact ids to facilitate warm starting.
constructor();
cf: b2ContactFeature;
key: number;
Copy(o: b2ContactID): b2ContactID;
Clone(): b2ContactID;
}
class b2ManifoldPoint {
// A manifold point is a contact point belonging to a contact
// manifold. It holds details related to the geometry and dynamics
// of the contact points.
// The local point usage depends on the manifold type:
// -e_circles: the local center of circleB
// -e_faceA: the local center of cirlceB or the clip point of polygonB
// -e_faceB: the clip point of polygonA
// This structure is stored across time steps, so we keep it small.
// Note: the impulses are used for internal caching and may not
// provide reliable contact forces, especially for high speed collisions.
constructor();
localPoint: b2Vec2;
normalImpulse: number;
tangentImpulse: number;
id: b2ContactID;
static MakeArray(length: number): Array<b2ManifoldPoint>;
Reset(): void;
Copy(o: b2ManifoldPoint): b2ManifoldPoint;
}
class b2Manifold {
// A manifold for two touching convex shapes.
// Box2D supports multiple types of contact:
// - clip point versus plane with radius
// - point versus point with radius (circles)
// The local point usage depends on the manifold type:
// -e_circles: the local center of circleA
// -e_faceA: the center of faceA
// -e_faceB: the center of faceB
// Similarly the local normal usage:
// -e_circles: not used
// -e_faceA: the normal on polygonA
// -e_faceB: the normal on polygonB
// We store contacts in this way so that position correction can
// account for movement, which is critical for continuous physics.
// All contact scenarios must be expressed in one of these types.
// This structure is stored across time steps, so we keep it small.
constructor();
points: Array<b2ManifoldPoint>;
localNormal: b2Vec2;
localPoint: b2Vec2;
type: b2ManifoldType;
pointCount: number;
Reset(): void;
Copy(o: b2Manifold): b2Manifold;
Clone(): b2Manifold;
}
class b2WorldManifold {
// This is used to compute the current state of a contact
// manifold.
constructor();
normal: b2Vec2;
points: Array<b2Vec2>;
separations: Array<number>;
// Evaluate the manifold with supplied transforms. This assumes
// modest motion from the original state. This does not change
// the point count, impulses, etc. The radii must come from the
// shapes that generated the manifold.
Initialize(manifold: b2Manifold, xfA: b2Transform, radiusA: number, xfB: b2Transform, radiusB: number): void;
}
class b2ClipVertex {
// Used for computing contact manifolds.
constructor();
v: b2Vec2;
id: b2ContactID;
static MakeArray(length?: number): Array<b2ClipVertex>;
Copy(other: b2ClipVertex): b2ClipVertex;
}
class b2RayCastInput {
// Ray-cast input data. The ray extends from p1 to p1 +
// maxFraction * (p2 - p1).
constructor();
p1: b2Vec2;
p2: b2Vec2;
maxFraction: number;
Copy(o: b2RayCastInput): b2RayCastInput;
}
class b2RayCastOutput {
// Ray-cast output data. The ray hits at p1 + fraction * (p2 -
// p1), where p1 and p2 come from box2d.b2RayCastInput.
constructor();
normal: b2Vec2;
fraction: number;
Copy(o: b2RayCastOutput): b2RayCastOutput;
}
class b2AABB {
// An axis aligned bounding box.
constructor();
lowerBound: b2Vec2;
upperBound: b2Vec2;
m_out_center: b2Vec2;
m_out_extent: b2Vec2;
Copy(o: b2AABB): b2AABB;
// Verify that the bounds are sorted.
IsValid(): boolean;
// Get the center of the AABB.
GetCenter(): b2Vec2;
// Get the extents of the AABB (half-widths).
GetExtents(): b2Vec2;
// Get the perimeter length
GetPerimeter(): number;
// Combine an AABB into this one.
Combine1(aabb: b2AABB): b2AABB;
// Combine two AABBs into this one.
Combine2(aabb1: b2AABB, aabb2: b2AABB): b2AABB;
static Combine(aabb1: b2AABB, aabb2: b2AABB, out: b2AABB): b2AABB;
// Does this aabb contain the provided AABB.
Contains(aabb: b2AABB): boolean;
// From Real-time Collision Detection, p179.
RayCast(output: b2RayCastOutput, input: b2RayCastInput): boolean;
TestOverlap(other: b2AABB): boolean;
}
class b2Timer {
// Timer for profiling. This has platform specific code and may
// not work on every platform.
constructor();
m_start: number;
Reset(): b2Timer;
GetMilliseconds(): number;
}
class b2Counter {
constructor();
m_count: number;
m_min_count: number;
m_max_count: number;
GetCount(): number;
GetMinCount(): number;
GetMaxCount(): number;
ResetCount(): number;
ResetMinCount(): void;
ResetMaxCount(): void;
Increment(): void;
Decrement(): void;
}
class b2TOIInput {
// Input parameters for b2TimeOfImpact
constructor();
proxyA: b2DistanceProxy;
proxyB: b2DistanceProxy;
sweepA: b2Sweep;
sweepB: b2Sweep;
tMax: number;
}
class b2TOIOutput {
// Output parameters for b2TimeOfImpact.
constructor();
state: b2TOIOutputState;
t: number;
}
class b2SeparationFunction {
constructor();
m_proxyA: b2DistanceProxy;
m_proxyB: b2DistanceProxy;
m_sweepA: b2Sweep;
m_sweepB: b2Sweep;
m_type: b2SeparationFunctionType;
m_localPoint: b2Vec2;
m_axis: b2Vec2;
// TODO_ERIN might not need to return the separation
Initialize(cache: b2SimplexCache, proxyA: b2DistanceProxy, sweepA: b2Sweep, proxyB: b2DistanceProxy, sweepB: b2Sweep, t1: number): number;
FindMinSeparation(indexA: Array<number>, indexB: Array<number>, t: number): number;
Evaluate(indexA: number, indexB: number, t: number): number;
}
class b2ContactEdge {
// A contact edge is used to connect bodies and contacts
// together in a contact graph where each body is a node and
// each contact is an edge. A contact edge belongs to a doubly
// linked list maintained in each attached body. Each contact
// has two contact nodes, one for each attached body.
constructor();
other: b2Body;
contact: b2Contact;
prev: b2ContactEdge;
next: b2ContactEdge;
}
class b2Contact {
// The class manages contact between two shapes. A contact
// exists for each overlapping AABB in the broad-phase (except
// if filtered). Therefore a contact object may exist that has
// no contact points.
constructor();
m_flags: b2ContactFlag;
// World pool and list pointers.
m_prev: b2Contact;
m_next: b2Contact;
// Nodes for connecting bodies.
m_nodeA: b2ContactEdge;
m_nodeB: b2ContactEdge;
m_fixtureA: b2Fixture;
m_fixtureB: b2Fixture;
m_indexA: number;
m_indexB: number;
m_manifold: b2Manifold;
m_toiCount: number;
m_toi: number;
m_friction: number;
m_restitution: number;
m_tangentSpeed: number;
m_oldManifold: b2Manifold;
// Get the contact manifold. Do not modify the manifold unless
// you understand the internals of Box2D.
GetManifold(): b2Manifold;
// Get the world manifold.
GetWorldManifold(worldManifold: b2WorldManifold): void;
// Is this contact touching?
IsTouching(): boolean;
// Enable/disable this contact. This can be used inside the
// pre-solve contact listener. The contact is only disabled for
// the current time step (or sub-step in continuous collisions).
SetEnabled(flag: boolean): void;
// Has this contact been disabled?
IsEnabled(): boolean;
// Get the next contact in the world's contact list.
GetNext(): b2Contact;
// Get fixture A in this contact.
GetFixtureA(): b2Fixture;
GetChildIndexA(): number;
// Get fixture B in this contact.
GetFixtureB(): b2Fixture;
GetChildIndexB(): number;
// Evaluate this contact with your own manifold and transforms.
Evaluate(manifold: b2Manifold, xfA: b2Transform, xfB: b2Transform): void;
// Flag this contact for filtering. Filtering will occur the
// next time step.
FlagForFiltering(): void;
// Override the default friction mixture. You can call this in
// box2d.b2ContactListener::PreSolve.
// This value persists until set or reset.
SetFriction(friction: number): void;
// Get the friction.
GetFriction(): number;
// Reset the friction mixture to the default value.
ResetFriction(): void;
// Override the default restitution mixture. You can call this
// in box2d.b2ContactListener::PreSolve.
// The value persists until you set or reset.
SetRestitution(restitution: number): void;
// Get the restitution.
GetRestitution(): number;
// Reset the restitution to the default value.
ResetRestitution(): void;
// Set the desired tangent speed for a conveyor belt behavior.
// In meters per second.
SetTangentSpeed(speed: number): void;
// Get the desired tangent speed. In meters per second.
GetTangentSpeed(): number;
Reset(fixtureA: b2Fixture, indexA: number, fixtureB: b2Fixture, indexB: number): void;
// Update the contact manifold and touching status.
// Note: do not assume the fixture AABBs are overlapping or are
// valid.
Update(listener: b2ContactListener): void;
ComputeTOI(sweepA: b2Sweep, sweepB: b2Sweep): number;
}
class b2PolygonAndCircleContact extends b2Contact {
constructor();
static Create(allocator: any): b2Contact;
static Destroy(contact: b2Contact, allocator: any): void;
Reset(fixtureA: b2Fixture, indexA: number, fixtureB: b2Fixture, indexB: number): void;
Evaluate(manifold: b2Manifold, xfA: b2Transform, xfB: b2Transform): void;
}
class b2EdgeAndPolygonContact extends b2Contact {
constructor();
static Create(allocator: any): b2Contact;
static Destroy(contact: b2Contact, allocator: any): void;
Reset(fixtureA: b2Fixture, indexA: number, fixtureB: b2Fixture, indexB: number): void;
Evaluate(manifold: b2Manifold, xfA: b2Transform, xfB: b2Transform): void;
}
class b2MassData {
// This holds the mass data computed for a shape.
constructor();
// The mass of the shape, usually in kilograms.
mass: number;
// The position of the shape's centroid relative to the shape's
// origin.
center: b2Vec2;
// The rotational inertia of the shape about the local origin.
I: number;
}
class b2Shape {
// A shape is used for collision detection. You can create a
// shape however you like.
// Shapes used for simulation in box2d.b2World are created
// automatically when a box2d.b2Fixture is created. Shapes may
// encapsulate a one or more child shapes.
constructor(type: b2ShapeType, radius: number);
m_type: b2ShapeType;
m_radius: number;
// Clone the concrete shape using the provided allocator.
Clone(): b2Shape;
Copy(other: b2Shape): b2Shape;
// Get the type of this shape. You can use this to down cast to
// the concrete shape.
GetType(): b2ShapeType;
// Get the number of child primitives.
GetChildCount(): number;
// Test a point for containment in this shape. This only works
// for convex shapes.
TestPoint(xf: b2Transform, p: b2Vec2): boolean;
// Cast a ray against a child shape.
RayCast(output: b2RayCastOutput, input: b2RayCastInput, transform: b2Transform, childIndex: number): boolean;
// Given a transform, compute the associated axis aligned
// bounding box for a child shape.
ComputeAABB(aabb: b2AABB, xf: b2Transform, childIndex: number): void;
// Compute the mass properties of this shape using its
// dimensions and density.
// The inertia tensor is computed about the local origin.
ComputeMass(massData: b2MassData, density: number): void;
SetupDistanceProxy(proxy: b2DistanceProxy, index: number): void;
ComputeSubmergedArea(normal: b2Vec2, offset: number, xf: b2Transform, c: b2Vec2): number;
// Dump this shape to the log file.
Dump(): void;
}
class b2PolygonShape extends b2Shape {
// A convex polygon. It is assumed that the interior of the
// polygon is to the left of each edge.
// Polygons have a maximum number of vertices equal to
// box2d.b2_maxPolygonVertices. In most cases you should not
// need many vertices for a convex polygon.
constructor();
m_centroid: b2Vec2;
m_vertices: Array<b2Vec2>;
m_normals: Array<b2Vec2>;
m_count: number;
// Implement box2d.b2Shape.
Clone(): b2Shape;
Copy(other: b2Shape): b2Shape;
// Build vertices to represent an axis-aligned box centered on
// the local origin.
SetAsBox(hx: number, hy: number): b2PolygonShape;
// Build vertices to represent an oriented box.
SetAsOrientedBox(hx: number, hy: number, center: b2Vec2, angle: number): b2PolygonShape;
// Create a convex hull from the given array of local points.
// The count must be in the range [3, b2_maxPolygonVertices].
// warning the points may be re-ordered, even if they form a
// convex polygon
// warning collinear points are handled but not removed.
// Collinear points may lead to poor stacking behavior.
Set(vertices: Array<b2Vec2>, count?: number): b2PolygonShape;
SetAsVector(vertices: Array<b2Vec2>, count?: number): b2PolygonShape;
SetAsArray(vertices: Array<b2Vec2>, count?: number): b2PolygonShape;
// Implement box2d.b2Shape.
GetChildCount(): number;
TestPoint(xf: b2Transform, p: b2Vec2): boolean;
// Implement box2d.b2Shape.
RayCast(output: b2RayCastOutput, input: b2RayCastInput, xf: b2Transform, childIndex: number): boolean;
ComputeAABB(aabb: b2AABB, xf: b2Transform, childIndex: number): void;
ComputeMass(massData: b2MassData, density: number): void;
// Validate convexity. This is a very time consuming operation.
Validate(): boolean;
SetupDistanceProxy(proxy: b2DistanceProxy, index: number): void;
ComputeSubmergedArea(normal: b2Vec2, offset: number, xf: b2Transform, c: b2Vec2): number;
// Dump this shape to the log file.
Dump(): void;
static ComputeCentroid(vs: Array<b2Vec2>, count: number, out: b2Vec2): b2Vec2;
}
class b2EPAxis {
// This structure is used to keep track of the best separating
// axis.
constructor();
type: b2EPAxisType;
index: number;
separation: number;
}
class b2TempPolygon {
// This holds polygon B expressed in frame A.
constructor();
vertices: Array<b2Vec2>;
normals: Array<b2Vec2>;
count: number;
}
class b2ReferenceFace {
// Reference face used for clipping
constructor();
i1: number;
i2: number;
v1: b2Vec2;
v2: b2Vec2;
normal: b2Vec2;
sideNormal1: b2Vec2;
sideOffset1: number;
sideNormal2: b2Vec2;
sideOffset2: number;
}
class b2EPCollider {
// This class collides and edge and a polygon, taking into
// account edge adjacency.
constructor();
m_polygonB: b2TempPolygon;
m_xf: b2Transform;
m_centroidB: b2Vec2;
m_v0: b2Vec2;
m_v1: b2Vec2;
m_v2: b2Vec2;
m_v3: b2Vec2;
m_normal0: b2Vec2;
m_normal1: b2Vec2;
m_normal2: b2Vec2;
m_normal: b2Vec2;
m_type1: b2EPColliderVertexType;
m_type2: b2EPColliderVertexType;
m_lowerLimit: b2Vec2;
m_upperLimit: b2Vec2;
m_radius: number;
m_front: boolean;
// Algorithm:
// 1. Classify v1 and v2
// 2. Classify polygon centroid as front or back
// 3. Flip normal if necessary
// 4. Initialize normal range to [-pi, pi] about face normal
// 5. Adjust normal range according to adjacent edges
// 6. Visit each separating axes, only accept axes within the range
// 7. Return if _any_ axis indicates separation
// 8. Clip
Collide(manifold: b2Manifold, edgeA: b2EdgeShape, xfA: b2Transform, polygonB: b2PolygonShape, xfB: b2Transform): void;
ComputeEdgeSeparation(out: b2EPAxis): b2EPAxis;
ComputePolygonSeparation(out: b2EPAxis): b2EPAxis;
}
class b2EdgeShape extends b2Shape {
// A line segment (edge) shape. These can be connected in chains
// or loops to other edge shapes. The connectivity information
// is used to ensure correct contact normals.
constructor();
// These are the edge vertices
m_vertex1: b2Vec2;
m_vertex2: b2Vec2;
// Optional adjacent vertices. These are used for smooth
// collision.
m_vertex0: b2Vec2;
m_vertex3: b2Vec2;
m_hasVertex0: boolean;
m_hasVertex3: boolean;
// Set this as an isolated edge.
Set(v1: b2Vec2, v2: b2Vec2): b2EdgeShape;
// Implement box2d.b2Shape.
Clone(): b2Shape;
Copy(other: b2Shape): b2Shape;
GetChildCount(): number;
TestPoint(xf: b2Transform, p: b2Vec2): boolean;
// Implement box2d.b2Shape.
// p = p1 + t * d
// v = v1 + s * e
// p1 + t * d = v1 + s * e
// s * e - t * d = p1 - v1
RayCast(output: b2RayCastOutput, input: b2RayCastInput, xf: b2Transform, childIndex: number): boolean;
ComputeAABB(aabb: b2AABB, xf: b2Transform, childIndex: number): void;
ComputeMass(massData: b2MassData, density: number): void;
SetupDistanceProxy(proxy: b2DistanceProxy, index: number): void;
ComputeSubmergedArea(normal: b2Vec2, offset: number, xf: b2Transform, c: b2Vec2): number;
// Dump this shape to the log file.
Dump(): void;
}
class b2ChainShape extends b2Shape {
// A chain shape is a free form sequence of line segments.
// The chain has two-sided collision, so you can use inside and outside collision.
// Therefore, you may use any winding order.
// Since there may be many vertices, they are allocated using b2Alloc.
// Connectivity information is used to create smooth collisions.
// WARNING: The chain will not collide properly if there are self-intersections.
constructor();
// The vertices. Owned by this class.
m_vertices: Array<b2Vec2>;
// The vertex count.
m_count: number;
m_prevVertex: b2Vec2;
m_nextVertex: b2Vec2;
m_hasPrevVertex: boolean;
m_hasNextVertex: boolean;
// Create a loop. This automatically adjusts connectivity.
CreateLoop(vertices: Array<b2Vec2>, count?: number): b2ChainShape;
// Create a chain with isolated end vertices.
CreateChain(vertices: Array<b2Vec2>, count?: number): b2ChainShape;
// Establish connectivity to a vertex that precedes the first vertex.
// Don't call this for loops.
SetPrevVertex(prevVertex: b2Vec2): b2ChainShape;
// Establish connectivity to a vertex that follows the last vertex.
// Don't call this for loops.
SetNextVertex(nextVertex: b2Vec2): b2ChainShape;
// Implement box2d.b2Shape. Vertices are cloned using b2Alloc.
Clone(): b2Shape;
Copy(other: b2Shape): b2Shape;
GetChildCount(): number;
// Get a child edge.
GetChildEdge(edge: b2EdgeShape, index: number): void;
// This always return false.
TestPoint(xf: b2Transform, p: b2Vec2): boolean;
// Implement box2d.b2Shape.
RayCast(output: b2RayCastOutput, input: b2RayCastInput, xf: b2Transform, childIndex: number): boolean;
static s_edgeShape: b2EdgeShape;
ComputeAABB(aabb: b2AABB, xf: b2Transform, childIndex: number): void;
ComputeMass(massData: b2MassData, density: number): void;
SetupDistanceProxy(proxy: b2DistanceProxy, index: number): void;
ComputeSubmergedArea(normal: b2Vec2, offset: number, xf: b2Transform, c: b2Vec2): number;
// Dump this shape to the log file.
Dump(): void;
}
class b2ChainAndPolygonContact extends b2Contact {
constructor();
static Create(allocator: any): b2Contact;
static Destroy(contact: b2Contact, allocator: any): void;
Reset(fixtureA: b2Fixture, indexA: number, fixtureB: b2Fixture, indexB: number): void;
Evaluate(manifold: b2Manifold, xfA: b2Transform, xfB: b2Transform): void;
}
class b2PolygonContact extends b2Contact {
constructor();
static Create(allocator: any): b2Contact;
static Destroy(contact: b2Contact, allocator: any): void;
Reset(fixtureA: b2Fixture, indexA: number, fixtureB: b2Fixture, indexB: number): void;
Evaluate(manifold: b2Manifold, xfA: b2Transform, xfB: b2Transform): void;
}
class b2CircleContact extends b2Contact {
constructor();
static Create(allocator: any): b2Contact;
static Destroy(contact: b2Contact, allocator: any): void;
Reset(fixtureA: b2Fixture, indexA: number, fixtureB: b2Fixture, indexB: number): void;
Evaluate(manifold: b2Manifold, xfA: b2Transform, xfB: b2Transform): void;
}
class b2ChainAndCircleContact extends b2Contact {
constructor();
static Create(allocator: any): b2Contact;
static Destroy(contact: b2Contact, allocator: any): void;
Reset(fixtureA: b2Fixture, indexA: number, fixtureB: b2Fixture, indexB: number): void;
Evaluate(manifold: b2Manifold, xfA: b2Transform, xfB: b2Transform): void;
}
class b2EdgeAndCircleContact extends b2Contact {
constructor();
static Create(allocator: any): b2Contact;
static Destroy(contact: b2Contact, allocator: any): void;
Reset(fixtureA: b2Fixture, indexA: number, fixtureB: b2Fixture, indexB: number): void;
Evaluate(manifold: b2Manifold, xfA: b2Transform, xfB: b2Transform): void;
}
class b2VelocityConstraintPoint {
constructor();
rA: b2Vec2;
rB: b2Vec2;
normalImpulse: number;
tangentImpulse: number;
normalMass: number;
tangentMass: number;
velocityBias: number;
static MakeArray(length: number): Array<b2VelocityConstraintPoint>;
}
class b2ContactVelocityConstraint {
constructor();
points: Array<b2VelocityConstraintPoint>;
normal: b2Vec2;
tangent: b2Vec2;
normalMass: b2Mat22;
K: b2Mat22;
indexA: number;
indexB: number;
invMassA: number;
invMassB: number;
invIA: number;
invIB: number;
friction: number;
restitution: number;
tangentSpeed: number;
pointCount: number;
contactIndex: number;
static MakeArray(length: number): Array<b2ContactVelocityConstraint>;
}
class b2ContactPositionConstraint {
constructor();
localPoints: Array<b2Vec2>;
localNormal: b2Vec2;
localPoint: b2Vec2;
indexA: number;
indexB: number;
invMassA: number;
invMassB: number;
localCenterA: b2Vec2;
localCenterB: b2Vec2;
invIA: number;
invIB: number;
type: b2ManifoldType;
radiusA: number;
radiusB: number;
pointCount: number;
static MakeArray(length: number): Array<b2ContactPositionConstraint>;
}
class b2ContactSolverDef {
constructor();
step: b2TimeStep;
contacts: Array<b2Contact>;
count: number;
positions: Array<b2Position>;
velocities: Array<b2Velocity>;
allocator: any;
}
class b2ContactSolver {
constructor();
m_step: b2TimeStep;
m_positions: Array<b2Position>;
m_velocities: Array<b2Velocity>;
m_allocator: any;
m_positionConstraints: Array<b2ContactPositionConstraint>;
m_velocityConstraints: Array<b2ContactVelocityConstraint>;
m_contacts: Array<b2Contact>;
m_count: number;
Initialize(def: b2ContactSolverDef): b2ContactSolver;
// Initialize position dependent portions of the velocity
// constraints.
InitializeVelocityConstraints(): void;
WarmStart(): void;
SolveVelocityConstraints(): void;
StoreImpulses(): void;
// Sequential solver.
SolvePositionConstraints(): boolean;
// Sequential position solver for position constraints.
SolveTOIPositionConstraints(toiIndexA: number, toiIndexB: number): boolean;
}
class b2PositionSolverManifold {
constructor();
normal: b2Vec2;
point: b2Vec2;
separation: number;
Initialize(pc: b2ContactPositionConstraint, xfA: b2Transform, xfB: b2Transform, index: number): void;
}
class b2DestructionListener {
// Joints and fixtures are destroyed when their associated body
// is destroyed. Implement this listener so that you may nullify
// references to these joints and shapes.
constructor();
// Called when any joint is about to be destroyed due to the
// destruction of one of its attached bodies.
SayGoodbyeJoint(joint: b2Joint): void;
// Called when any fixture is about to be destroyed due to the
// destruction of its parent body.
SayGoodbyeFixture(fixture: b2Fixture): void;
}
class b2ContactFilter {
// Implement this class to provide collision filtering. In other
// words, you can implement this class if you want finer control
// over contact creation.
constructor();
// Return true if contact calculations should be performed
// between these two shapes.
// warning for performance reasons this is only called when the
// AABBs begin to overlap.
ShouldCollide(fixtureA: b2Fixture, fixtureB: b2Fixture): boolean;
}
class b2ContactImpulse {
// Contact impulses for reporting. Impulses are used instead of
// forces because sub-step forces may approach infinity for
// rigid body collisions. These match up one-to-one with the
// contact points in b2Manifold.
constructor();
normalImpulses: Array<number>;
tangentImpulses: Array<number>;
count:number;
}
class b2ContactListener {
// Implement this class to get contact information. You can use
// these results for things like sounds and game logic. You can
// also get contact results by traversing the contact lists
// after the time step. However, you might miss some contacts
// because continuous physics leads to sub-stepping.
// Additionally you may receive multiple callbacks for the same
// contact in a single time step.
// You should strive to make your callbacks efficient because
// there may be many callbacks per time step.
// warning You cannot create/destroy Box2D entities inside these
// callbacks.
constructor();
// Called when two fixtures begin to touch.
BeginContact(contact: b2Contact): void;
// Called when two fixtures cease to touch.
EndContact(contact: b2Contact): void;
// This is called after a contact is updated. This allows you to
// inspect a contact before it goes to the solver. If you are
// careful, you can modify the contact manifold (e.g. disable
// contact).
// A copy of the old manifold is provided so that you can detect
// changes.
// Note: this is called only for awake bodies.
// Note: this is called even when the number of contact points
// is zero.
// Note: this is not called for sensors.
// Note: if you set the number of contact points to zero, you
// will not get an EndContact callback. However, you may get a
// BeginContact callback the next step.
PreSolve(contact: b2Contact, oldManifold: b2Manifold): void;
// This lets you inspect a contact after the solver is finished.
// This is useful for inspecting impulses.
// Note: the contact manifold does not include time of impact
// impulses, which can be arbitrarily large if the sub-step is
// small. Hence the impulse is provided explicitly in a separate
// data structure.
// Note: this is only called for contacts that are touching,
// solid, and awake.
PostSolve(contact: b2Contact, impulse: b2ContactImpulse): void;
static b2_defaultListener: b2ContactListener;
}
class b2QueryCallback {
// Callback class for AABB queries.
// See b2World::Query
constructor();
// Called for each fixture found in the query AABB.
ReportFixture(): boolean;
}
class b2RayCastCallback {
// Callback class for ray casts.
// See b2World::RayCast
constructor();
// Called for each fixture found in the query. You control how
// the ray cast proceeds by returning a float:
// return -1: ignore this fixture and continue
// return 0: terminate the ray cast
// return fraction: clip the ray to this point
// return 1: don't clip the ray and continue
// of intersection
ReportFixture(fixture: b2Fixture, point: b2Vec2, normal: b2Vec2, fraction: number): number;
}
class b2Island {
// This is an internal class.
constructor();
m_allocator: any;
m_listener: b2ContactListener;
m_bodies: Array<b2Body>;
m_contacts: Array<b2Contact>;
m_joints: Array<b2Joint>;
m_positions: Array<b2Position>;
m_velocities: Array<b2Velocity>;
m_bodyCount: number;
m_jointCount: number;
m_contactCount: number;
m_bodyCapacity: number;
m_contactCapacity: number;
m_jointCapacity: number;
Initialize(bodyCapacity: number, contactCapacity: number, jointCapacity: number, allocator: any, listener: b2ContactListener): void;
Clear(): void;
AddBody(body: b2Body): void;
AddContact(contact: b2Contact): void;
AddJoint(joint: b2Joint): void;
Solve(profile: b2Profile, step: b2TimeStep, gravity: b2Vec2, allowSleep: boolean): void;
SolveTOI(subStep: b2TimeStep, toiIndexA: number, toiIndexB: number): void;
Report(constraints: Array<b2ContactVelocityConstraint>): void;
}
class b2ContactRegister {
constructor();
}
class b2ContactFactory {
constructor(allocator: any);
AddType(createFcn: Function, destroyFcn: Function, type1: b2ShapeType, type2: b2ShapeType): void;
InitializeRegisters(): void;
Create(fixtureA: b2Fixture, indexA: number, fixtureB: b2Fixture, indexB: number): b2Contact;
Destroy(contact: b2Contact): void;
}
class b2GrowableStack {
// This is a growable LIFO stack with an initial capacity of N.
// If the stack size exceeds the initial capacity, the heap is
// used to increase the size of the stack.
constructor(N: number);
m_stack: Array<any>;
m_count: number;
Reset(): b2GrowableStack;
Push(element: any): void;
Pop(): any;
GetCount(): number;
}
class b2TreeNode {
// A node in the dynamic tree. The client does not interact with
// this directly.
constructor(id?: number);
m_id: number;
// Enlarged AABB
aabb: b2AABB;
userData: any;
parent: b2TreeNode;
child1: b2TreeNode;
child2: b2TreeNode;
// leaf = 0, free node = -1
height: number;
IsLeaf(): boolean;
}
class b2DynamicTree {
// A dynamic tree arranges data in a binary tree to accelerate
// queries such as volume queries and ray casts. Leafs are proxies
// with an AABB. In the tree we expand the proxy AABB by b2_fatAABBFactor
// so that the proxy AABB is bigger than the client object. This allows the client
// object to move by small amounts without triggering a tree update.
//
// Nodes are pooled and relocatable, so we use node indices rather than pointers.
constructor();
m_root: b2TreeNode;
m_freeList: b2TreeNode;
// This is used to incrementally traverse the tree for
// re-balancing.
m_path: number;
m_insertionCount: number;
// Get proxy user data.
GetUserData(proxy: b2TreeNode): any;
// Get the fat AABB for a proxy.
GetFatAABB(proxy: b2TreeNode): b2AABB;
// Query an AABB for overlapping proxies. The callback class is
// called for each proxy that overlaps the supplied AABB.
Query(callback: (treeNode: b2TreeNode) => boolean, aabb: b2AABB): void;
// Ray-cast against the proxies in the tree. This relies on the callback
// to perform a exact ray-cast in the case were the proxy contains a shape.
// The callback also performs the any collision filtering. This has performance
// roughly equal to k * log(n), where k is the number of collisions and n is the
// number of proxies in the tree.
RayCast(callback: (raycastInput: b2RayCastInput, treeNode: b2TreeNode) => number, input: b2RayCastInput): void;
AllocateNode(): b2TreeNode;
FreeNode(node: b2TreeNode): void;
// Create a proxy. Provide a tight fitting AABB and a userData
// pointer.
CreateProxy(aabb: b2AABB, userData: any): b2TreeNode;
// Destroy a proxy. This asserts if the id is invalid.
DestroyProxy(proxy: b2TreeNode): void;
// Move a proxy with a swepted AABB. If the proxy has moved
// outside of its fattened AABB, then the proxy is removed from
// the tree and re-inserted. Otherwise the function returns
// immediately.
MoveProxy(proxy: b2TreeNode, aabb: b2AABB, displacement: b2Vec2): boolean;
InsertLeaf(leaf: b2TreeNode): void;
RemoveLeaf(leaf: b2TreeNode): void;
// Perform a left or right rotation if node A is imbalanced.
// Returns the new root index.
Balance(A: b2TreeNode): b2TreeNode;
// Compute the height of the binary tree in O(N) time. Should
// not be called often.
GetHeight(): number;
// Get the ratio of the sum of the node areas to the root area.
GetAreaRatio(): number;
// Compute the height of a sub-tree.
ComputeHeightNode(node: b2TreeNode): number;
ComputeHeight(): number;
ValidateStructure(index: b2TreeNode): void;
ValidateMetrics(index: b2TreeNode): void;
// Validate this tree. For testing.
Validate(): void;
// Get the maximum balance of an node in the tree. The balance
// is the difference in height of the two children of a node.
GetMaxBalance(): number;
// Build an optimal tree. Very expensive. For testing.
RebuildBottomUp(): void;
// Shift the world origin. Useful for large worlds.
// The shift formula is: position -= newOrigin
ShiftOrigin(newOrigin: b2Vec2): void;
}
class b2Pair {
constructor();
proxyA: b2TreeNode;
proxyB: b2TreeNode;
}
class b2BroadPhase {
// The broad-phase is used for computing pairs and performing
// volume queries and ray casts. This broad-phase does not
// persist pairs. Instead, this reports potentially new pairs.
// It is up to the client to consume the new pairs and to track
// subsequent overlap.
constructor();
m_tree: b2DynamicTree;
m_proxyCount: number;
m_moveCount: number;
m_moveBuffer: Array<b2TreeNode>;
m_pairCount: number;
m_pairBuffer: Array<b2Pair>;
// Create a proxy with an initial AABB. Pairs are not reported
// until UpdatePairs is called.
CreateProxy(aabb: b2AABB, userData: any): b2TreeNode;
// Destroy a proxy. It is up to the client to remove any pairs.
DestroyProxy(proxy: b2TreeNode): void;
// Call MoveProxy as many times as you like, then when you are
// done call UpdatePairs to finalized the proxy pairs (for your
// time step).
MoveProxy(proxy: b2TreeNode, aabb: b2AABB, displacement: b2Vec2): void;
// Call to trigger a re-processing of it's pairs on the next
// call to UpdatePairs.
TouchProxy(proxy: b2TreeNode): void;
// Get the fat AABB for a proxy.
GetFatAABB(proxy: b2TreeNode): b2AABB;
// Get user data from a proxy. Returns NULL if the id is
// invalid.
GetUserData(proxy: b2TreeNode): any;
// Test overlap of fat AABBs.
TestOverlap(proxyA: b2TreeNode, proxyB: b2TreeNode): boolean;
// Get the number of proxies.
GetProxyCount(): number;
// Get the height of the embedded tree.
GetTreeHeight(): number;
// Get the balance of the embedded tree.
GetTreeBalance(): number;
// Get the quality metric of the embedded tree.
GetTreeQuality(): number;
// Shift the world origin. Useful for large worlds. The shift
// formula is: position -= newOrigin
ShiftOrigin(newOrigin: b2Vec2): void;
// Update the pairs. This results in pair callbacks. This can
// only add pairs.
UpdatePairs(contactManager: any): void;
// Query an AABB for overlapping proxies. The callback class is
// called for each proxy that overlaps the supplied AABB.
Query(callback: Function, aabb: b2AABB): void;
// Ray-cast against the proxies in the tree. This relies on the
// callback to perform a exact ray-cast in the case were the
// proxy contains a shape. The callback also performs the any
// collision filtering. This has performance roughly equal to k
// * log(n), where k is the number of collisions and n is the
// number of proxies in the tree.
RayCast(callback: Function, input: b2RayCastInput): void;
BufferMove(proxy: b2TreeNode): void;
UnBufferMove(proxy: b2TreeNode): void;
}
class b2ContactManager {
// Delegate of box2d.b2World.
constructor();
m_broadPhase: b2BroadPhase;
m_contactList: b2Contact;
m_contactCount: number;
m_contactFilter: b2ContactFilter;
m_contactListener: b2ContactListener;
m_allocator: any;
m_contactFactory: b2ContactFactory;
Destroy(c: b2Contact): void;
// This is the top level collision call for the time step. Here
// all the narrow phase collision is processed for the world
// contact list.
Collide(): void;
FindNewContacts(): void;
// Broad-phase callback.
AddPair(proxyUserDataA: b2FixtureProxy, proxyUserDataB: b2FixtureProxy): void;
}
class b2JointFactory {
static Create(def: b2JointDef, allocator: any): b2Joint;
static Destroy(joint: b2Joint, allocator: any): void;
}
class b2Color {
// Color for debug drawing. Each value has the range [0,1].
constructor(rr: number, gg: number, bb: number);
r: number;
g: number;
b: number;
SetRGB(rr: number, gg: number, bb: number): b2Color;
static MakeStyleString(): string;
static RED: b2Color;
static GREEN: b2Color;
static BLUE: b2Color;
}
class b2Draw {
// Implement and register this class with a b2World to provide
// debug drawing of physics entities in your game.
constructor();
m_drawFlags: b2DrawFlags;
// Set the drawing flags.
SetFlags(flags: b2DrawFlags): void;
// Get the drawing flags.
GetFlags(): b2DrawFlags;
// Append flags to the current flags.
AppendFlags(flags: b2DrawFlags): void;
// Clear flags from the current flags.
ClearFlags(flags: b2DrawFlags): void;
PushTransform(xf: b2Transform): void;
PopTransform(xf: b2Transform): void;
// Draw a closed polygon provided in CCW order.
DrawPolygon(vertices: Array<b2Vec2>, vertexCount: number, color: b2Color): void;
// Draw a solid closed polygon provided in CCW order.
DrawSolidPolygon(vertices: Array<b2Vec2>, vertexCount: number, color: b2Color): void;
// Draw a circle.
DrawCircle(center: b2Vec2, radius: number, color: b2Color): void;
// Draw a solid circle.
DrawSolidCircle(center: b2Vec2, radius: number, axis: b2Vec2, color: b2Color): void;
// Draw a line segment.
DrawSegment(p1: b2Vec2, p2: b2Vec2, color: b2Color): void;
// Draw a transform. Choose your own length scale.
DrawTransform(xf: b2Transform): void;
}
class b2Filter {
// This holds contact filtering data.
constructor();
// The collision category bits. Normally you would just set one
// bit.
categoryBits: number;
// The collision mask bits. This states the categories that this
// shape would accept for collision.
maskBits: number;
// Collision groups allow a certain group of objects to never
// collide (negative) or always collide (positive). Zero means
// no collision group. Non-zero group filtering always wins
// against the mask bits.
groupIndex: number;
Clone(): b2Filter;
Copy(other: b2Filter): b2Filter;
}
class b2FixtureDef {
// A fixture definition is used to create a fixture. This class
// defines an abstract fixture definition. You can reuse fixture
// definitions safely.
constructor();
// The shape, this must be set. The shape will be cloned, so you
// can create the shape on the stack.
shape: b2Shape;
// Use this to store application specific fixture data.
userData: any;
// The friction coefficient, usually in the range [0,1].
friction: number;
// The restitution (elasticity) usually in the range [0,1].
restitution: number;
// The density, usually in kg/m^2.
density: number;
// A sensor shape collects contact information but never
// generates a collision response.
isSensor: boolean;
// Contact filtering data.
filter: b2Filter;
}
class b2FixtureProxy {
// This proxy is used internally to connect fixtures to the
// broad-phase.
constructor();
aabb: b2AABB;
fixture: b2Fixture;
childIndex: number;
proxy: b2TreeNode;
static MakeArray(length: number): Array<b2FixtureProxy>;
}
class b2Fixture {
// A fixture is used to attach a shape to a body for collision
// detection. A fixture inherits its transform from its parent.
// Fixtures hold additional non-geometric data such as friction,
// collision filters, etc.
// Fixtures are created via box2d.b2Body::CreateFixture.
// warning you cannot reuse fixtures.
constructor();
m_density: number;
m_next: b2Fixture;
m_body: b2Body;
m_shape: b2Shape;
m_friction: number;
m_restitution: number;
m_proxies: Array<b2FixtureProxy>;
m_proxyCount: number;
m_filter: b2Filter;
m_isSensor: boolean;
m_userData: any;
// Get the type of the child shape. You can use this to down
// cast to the concrete shape.
GetType(): b2ShapeType;
// Get the child shape. You can modify the child shape, however
// you should not change the number of vertices because this
// will crash some collision caching mechanisms.
// Manipulating the shape may lead to non-physical behavior.
GetShape(): b2Shape;
// Is this fixture a sensor (non-solid)?
IsSensor(): boolean;
// Get the contact filtering data.
GetFilterData(): b2Filter;
// Get the user data that was assigned in the fixture
// definition. Use this to store your application specific data.
GetUserData(): any;
// Set the user data. Use this to store your application
// specific data.
SetUserData(data: any): void;
// Get the parent body of this fixture. This is NULL if the
// fixture is not attached.
GetBody(): b2Body;
// Get the next fixture in the parent body's fixture list.
GetNext(): b2Fixture;
// Set the density of this fixture. This will _not_
// automatically adjust the mass of the body. You must call
// box2d.b2Body::ResetMassData to update the body's mass.
SetDensity(density: number): void;
// Get the density of this fixture.
GetDensity(): number;
// Get the coefficient of friction.
GetFriction(): number;
// Set the coefficient of friction. This will _not_ change the
// friction of existing contacts.
SetFriction(friction: number): void;
// Get the coefficient of restitution.
GetRestitution(): number;
// Set the coefficient of restitution. This will _not_ change
// the restitution of existing contacts.
SetRestitution(restitution: number): void;
// Test a point for containment in this fixture.
TestPoint(p: b2Vec2): boolean;
// Cast a ray against this shape.
RayCast(output: b2RayCastOutput, input: b2RayCastInput, childIndex: number): boolean;
// Get the mass data for this fixture. The mass data is based on
// the density and the shape. The rotational inertia is about
// the shape's origin. This operation may be expensive.
GetMassData(massData?: b2MassData): b2MassData;
// Get the fixture's AABB. This AABB may be enlarge and/or
// stale. If you need a more accurate AABB, compute it using the
// shape and the body transform.
GetAABB(childIndex: number): b2AABB;
// We need separation create/destroy functions from the
// constructor/destructor because the destructor cannot access
// the allocator (no destructor arguments allowed by C++).
Create(body: b2Body, def: b2FixtureDef): void;
Destroy(): void;
// These support body activation/deactivation.
CreateProxies(broadPhase: b2BroadPhase, xf: b2Transform): void;
DestroyProxies(broadPhase: b2BroadPhase): void;
Synchronize(broadPhase: b2BroadPhase, transform1: b2Transform, transform2: b2Transform): void;
// Set the contact filtering data. This will not update contacts
// until the next time step when either parent body is active
// and awake.
// This automatically calls Refilter.
SetFilterData(filter: b2Filter): void;
// Call this if you want to establish collision that was
// previously disabled by box2d.b2ContactFilter::ShouldCollide.
Refilter(): void;
// Set if this fixture is a sensor.
SetSensor(sensor: boolean): void;
// Dump this fixture to the log file.
Dump(bodyIndex: number): void;
}
class b2BodyDef {
// A body definition holds all the data needed to construct a
// rigid body.
// You can safely re-use body definitions. Shapes are added to a
// body after construction.
constructor();
// The body type: static, kinematic, or dynamic.
// Note: if a dynamic body would have zero mass, the mass is set
// to one.
type: b2BodyType;
// The world position of the body. Avoid creating bodies at the
// origin since this can lead to many overlapping shapes.
position: b2Vec2;
// The world angle of the body in radians.
angle: number;
// The linear velocity of the body's origin in world
// co-ordinates.
linearVelocity: b2Vec2;
// The angular velocity of the body.
angularVelocity: number;
// Linear damping is use to reduce the linear velocity. The
// damping parameter can be larger than 1.0f but the damping
// effect becomes sensitive to the time step when the damping
// parameter is large.
linearDamping: number;
// Angular damping is use to reduce the angular velocity. The
// damping parameter can be larger than 1.0f but the damping
// effect becomes sensitive to the time step when the damping
// parameter is large.
angularDamping: number;
// Set this flag to false if this body should never fall asleep.
// Note that this increases CPU usage.
allowSleep: boolean;
// Is this body initially awake or sleeping?
awake: boolean;
// Should this body be prevented from rotating? Useful for
// characters.
fixedRotation: boolean;
// Is this a fast moving body that should be prevented from
// tunneling through other moving bodies? Note that all bodies
// are prevented from tunneling through kinematic and static
// bodies. This setting is only considered on dynamic bodies.
// warning You should use this flag sparingly since it increases
// processing time.
bullet: boolean;
// Does this body start out active?
active: boolean;
// Use this to store application specific body data.
userData: any;
// Scale the gravity applied to this body.
gravityScale: number;
}
class b2Body {
// A rigid body. These are created via
// box2d.b2World::CreateBody.
constructor(bd: b2BodyDef, world: b2World);
m_flags: b2BodyFlag;
m_islandIndex: number;
m_world: b2World;
m_xf: b2Transform;
m_out_xf: b2Transform;
m_sweep: b2Sweep;
m_out_sweep: b2Sweep;
m_jointList: b2JointEdge;
m_contactList: b2ContactEdge;
m_prev: b2Body;
m_next: b2Body;
m_linearVelocity: b2Vec2;
m_out_linearVelocity: b2Vec2;
m_angularVelocity: number;
m_linearDamping: number;
m_angularDamping: number;
m_gravityScale: number;
m_force: b2Vec2;
m_torque: number;
m_sleepTime: number;
m_type: b2BodyType;
m_mass: number;
m_invMass: number;
m_I: number;
m_invI: number;
m_userData: any;
m_fixtureList: b2Fixture;
m_fixtureCount: number;
m_controllerList: b2ControllerEdge;
m_controllerCount: number;
// Creates a fixture and attach it to this body. Use this
// function if you need to set some fixture parameters, like
// friction. Otherwise you can create the fixture directly from
// a shape.
// If the density is non-zero, this function automatically
// updates the mass of the body. Contacts are not created until
// the next time step.
// warning This function is locked during callbacks.
CreateFixture(def: b2FixtureDef): b2Fixture;
// Creates a fixture from a shape and attach it to this body.
// This is a convenience function. Use b2FixtureDef if you need
// to set parameters like friction, restitution, user data, or
// filtering.
// If the density is non-zero, this function automatically
// updates the mass of the body.
// warning This function is locked during callbacks.
CreateFixture2(shape: b2Shape, density: number): b2Fixture;
// Destroy a fixture. This removes the fixture from the
// broad-phase and destroys all contacts associated with this
// fixture. This will automatically adjust the mass of the body
// if the body is dynamic and the fixture has positive density.
// All fixtures attached to a body are implicitly destroyed when
// the body is destroyed.
// warning This function is locked during callbacks.
DestroyFixture(fixture: b2Fixture): void;
// Set the position of the body's origin and rotation.
// Manipulating a body's transform may cause non-physical
// behavior.
// Note: contacts are updated on the next call to b2World::Step.
SetTransformVecRadians(position: b2Vec2, angle: number): void;
SetTransformXYRadians(x: number, y: number, angle: number): void;
SetTransform(xf: b2Transform): void;
// Get the body transform for the body's origin.
GetTransform(out?: b2Transform): b2Transform;
// Get the world body origin position.
GetPosition(out?: b2Vec2): b2Vec2;
SetPosition(position: b2Vec2): void;
SetPositionXY(x: number, y: number): void;
// Get the angle in radians.
GetAngle(): number;
SetAngle(angle: number): void;
// Get the world position of the center of mass.
GetWorldCenter(out?: b2Vec2): b2Vec2;
// Get the local position of the center of mass.
GetLocalCenter(out?: b2Vec2): b2Vec2;
// Set the linear velocity of the center of mass.
SetLinearVelocity(v: b2Vec2): void;
// Get the linear velocity of the center of mass.
GetLinearVelocity(out?: b2Vec2): b2Vec2;
// Set the angular velocity.
SetAngularVelocity(w: number): void;
// Get the angular velocity.
GetAngularVelocity(): number;
GetDefinition(bd: b2BodyDef): b2BodyDef;
// Apply a force at a world point. If the force is not applied
// at the center of mass, it will generate a torque and affect
// the angular velocity. This wakes up the body.
ApplyForce(force: b2Vec2, point: b2Vec2, wake?: boolean): void;
// Apply a force to the center of mass. This wakes up the body.
ApplyForceToCenter(force: b2Vec2, wake?: boolean): void;
// Apply a torque. This affects the angular velocity without
// affecting the linear velocity of the center of mass. This
// wakes up the body.
ApplyTorque(torque: number, wake?: boolean): void;
// Apply an impulse at a point. This immediately modifies the
// velocity. It also modifies the angular velocity if the point
// of application is not at the center of mass. This wakes up
// the body.
ApplyLinearImpulse(impulse: b2Vec2, point: b2Vec2, wake?: boolean): void;
// Apply an angular impulse.
ApplyAngularImpulse(impulse: number, wake?: boolean): void;
// Get the total mass of the body.
GetMass(): number;
// Get the rotational inertia of the body about the local
// origin.
GetInertia(): number;
// Get the mass data of the body.
GetMassData(data: b2MassData): b2MassData;
// Set the mass properties to override the mass properties of
// the fixtures.
// Note that this changes the center of mass position.
// Note that creating or destroying fixtures can also alter the
// mass.
// This function has no effect if the body isn't dynamic.
SetMassData(massData: b2MassData): void;
// This resets the mass properties to the sum of the mass
// properties of the fixtures. This normally does not need to be
// called unless you called SetMassData to override the mass and
// you later want to reset the mass.
ResetMassData(): void;
// Get the world coordinates of a point given the local
// coordinates.
GetWorldPoint(localPoint: b2Vec2, out: b2Vec2): b2Vec2;
// Get the world coordinates of a vector given the local
// coordinates.
GetWorldVector(localVector: b2Vec2, out: b2Vec2): b2Vec2;
// Gets a local point relative to the body's origin given a
// world point.
GetLocalPoint(worldPoint: b2Vec2, out: b2Vec2): b2Vec2;
// Gets a local vector given a world vector.
GetLocalVector(worldVector: b2Vec2, out: b2Vec2): b2Vec2;
// Get the world linear velocity of a world point attached to
// this body.
GetLinearVelocityFromWorldPoint(worldPoint: b2Vec2, out: b2Vec2): b2Vec2;
// Get the world velocity of a local point.
GetLinearVelocityFromLocalPoint(localPoint: b2Vec2, out: b2Vec2): b2Vec2;
// Get the linear damping of the body.
GetLinearDamping(): number;
// Set the linear damping of the body.
SetLinearDamping(linearDamping: number): void;
// Get the angular damping of the body.
GetAngularDamping(): number;
// Set the angular damping of the body.
SetAngularDamping(angularDamping: number): void;
// Get the gravity scale of the body.
GetGravityScale(): number;
// Set the gravity scale of the body.
SetGravityScale(scale: number): void;
// Set the type of this body. This may alter the mass and
// velocity.
SetType(type: b2BodyType): void;
// Get the type of this body.
GetType(): b2BodyType;
// Should this body be treated like a bullet for continuous
// collision detection?
SetBullet(flag: boolean): void;
// Is this body treated like a bullet for continuous collision
// detection?
IsBullet(): boolean;
// You can disable sleeping on this body. If you disable
// sleeping, the body will be woken.
SetSleepingAllowed(flag: boolean): void;
// Is this body allowed to sleep
IsSleepingAllowed(): boolean;
// Set the sleep state of the body. A sleeping body has very low CPU cost.
// put it to sleep.
SetAwake(flag: boolean): void;
// Get the sleeping state of this body.
IsAwake(): boolean;
// Set the active state of the body. An inactive body is not
// simulated and cannot be collided with or woken up.
// If you pass a flag of true, all fixtures will be added to the
// broad-phase.
// If you pass a flag of false, all fixtures will be removed from
// the broad-phase and all contacts will be destroyed.
// Fixtures and joints are otherwise unaffected. You may continue
// to create/destroy fixtures and joints on inactive bodies.
// Fixtures on an inactive body are implicitly inactive and will
// not participate in collisions, ray-casts, or queries.
// Joints connected to an inactive body are implicitly inactive.
// An inactive body is still owned by a b2World object and remains
// in the body list.
SetActive(flag: boolean): void;
// Get the active state of the body.
IsActive(): boolean;
// Set this body to have fixed rotation. This causes the mass to
// be reset.
SetFixedRotation(flag: boolean): void;
// Does this body have fixed rotation?
IsFixedRotation(): boolean;
// Get the list of all fixtures attached to this body.
GetFixtureList(): b2Fixture;
// Get the list of all joints attached to this body.
GetJointList(): b2JointEdge;
// Get the list of all contacts attached to this body.
// warning this list changes during the time step and you may
// miss some collisions if you don't use b2ContactListener.
GetContactList(): b2ContactEdge;
// Get the next body in the world's body list.
GetNext(): b2Body;
// Get the user data pointer that was provided in the body
// definition.
GetUserData(): any;
// Set the user data. Use this to store your application
// specific data.
SetUserData(data: any): void;
// Get the parent world of this body.
GetWorld(): b2World;
SynchronizeFixtures(): void;
SynchronizeTransform(): void;
// This is used to prevent connected bodies from colliding.
// It may lie, depending on the collideConnected flag.
ShouldCollide(other: b2Body): boolean;
Advance(alpha: number): void;
// Dump this body to a log file
Dump(): void;
GetControllerList(): b2ControllerEdge;
GetControllerCount(): number;
}
class b2World {
// Construct a world object.
constructor(gravity: b2Vec2);
m_flags: b2WorldFlag;
m_contactManager: b2ContactManager;
m_bodyList: b2Body;
m_jointList: b2Joint;
m_bodyCount: number;
m_jointCount: number;
m_gravity: b2Vec2;
m_out_gravity: b2Vec2;
m_allowSleep: boolean;
m_destructionListener: b2DestructionListener;
m_debugDraw: b2Draw;
// This is used to compute the time step ratio to support a
// variable time step.
m_inv_dt0: number;
// These are for debugging the solver.
m_warmStarting: boolean;
m_continuousPhysics: boolean;
m_subStepping: boolean;
m_stepComplete: boolean;
m_profile: b2Profile;
m_island: b2Island;
s_stack: Array<b2Body>;
m_controllerList: b2Controller;
m_controllerCount: number;
// Enable/disable sleep.
SetAllowSleeping(flag: boolean): void;
GetAllowSleeping(): boolean;
// Enable/disable warm starting. For testing.
SetWarmStarting(flag: boolean): void;
GetWarmStarting(): boolean;
// Enable/disable continuous physics. For testing.
SetContinuousPhysics(flag: boolean): void;
GetContinuousPhysics(): boolean;
// Enable/disable single stepped continuous physics. For
// testing.
SetSubStepping(flag: boolean): void;
GetSubStepping(): boolean;
// Get the world body list. With the returned body, use
// b2Body::GetNext to get the next body in the world list. A
// NULL body indicates the end of the list.
GetBodyList(): b2Body;
// Get the world joint list. With the returned joint, use
// b2Joint::GetNext to get the next joint in the world list. A
// NULL joint indicates the end of the list.
GetJointList(): b2Joint;
// Get the world contact list. With the returned contact, use
// box2d.b2Contact::GetNext to get the next contact in the world
// list. A NULL contact indicates the end of the list.
// warning contacts are created and destroyed in the middle of a
// time step.
// Use box2d.b2ContactListener to avoid missing contacts.
GetContactList(): b2Contact;
// Get the number of bodies.
GetBodyCount(): number;
// Get the number of joints.
GetJointCount(): number;
// Get the number of contacts (each may have 0 or more contact
// points).
GetContactCount(): number;
// Change the global gravity vector.
SetGravity(gravity: b2Vec2, wake?: boolean): void;
// Get the global gravity vector.
GetGravity(out?: b2Vec2): b2Vec2;
// Is the world locked (in the middle of a time step).
IsLocked(): boolean;
// Set flag to control automatic clearing of forces after each
// time step.
SetAutoClearForces(flag: boolean): void;
// Get the flag that controls automatic clearing of forces after
// each time step.
GetAutoClearForces(): boolean;
// Get the contact manager for testing.
GetContactManager(): b2ContactManager;
// Get the current profile.
GetProfile(): b2Profile;
// Register a destruction listener. The listener is owned by you
// and must remain in scope.
SetDestructionListener(listener: b2DestructionListener): void;
// Register a contact filter to provide specific control over
// collision. Otherwise the default filter is used
// (b2_defaultFilter). The listener is owned by you and must
// remain in scope.
SetContactFilter(filter: b2ContactFilter): void;
// Register a contact event listener. The listener is owned by
// you and must remain in scope.
SetContactListener(listener: b2ContactListener): void;
// Register a routine for debug drawing. The debug draw
// functions are called inside with b2World::DrawDebugData
// method. The debug draw object is owned by you and must remain
// in scope.
SetDebugDraw(debugDraw: b2Draw): void;
// Create a rigid body given a definition. No reference to the
// definition is retained.
// warning This function is locked during callbacks.
CreateBody(def: b2BodyDef): b2Body;
// Destroy a rigid body given a definition. No reference to the
// definition is retained. This function is locked during
// callbacks.
// warning This automatically deletes all associated shapes and
// joints.
// warning This function is locked during callbacks.
DestroyBody(b: b2Body): void;
// Create a joint to constrain bodies together. No reference to
// the definition is retained. This may cause the connected
// bodies to cease colliding.
// warning This function is locked during callbacks.
CreateJoint(def: b2JointDef): b2Joint;
// Destroy a joint. This may cause the connected bodies to begin
// colliding.
// warning This function is locked during callbacks.
DestroyJoint(j: b2Joint): void;
// Find islands, integrate and solve constraints, solve position
// constraints
Solve(step: b2TimeStep): void;
// Find TOI contacts and solve them.
SolveTOI(step: b2TimeStep): void;
// Take a time step. This performs collision detection,
// integration, and constraint solution.
Step(dt: number, velocityIterations: number, positionIterations: number): void;
// Manually clear the force buffer on all bodies. By default,
// forces are cleared automatically after each call to Step. The
// default behavior is modified by calling SetAutoClearForces.
// The purpose of this function is to support sub-stepping.
// Sub-stepping is often used to maintain a fixed sized time
// step under a variable frame-rate.
// When you perform sub-stepping you will disable auto clearing
// of forces and instead call ClearForces after all sub-steps
// are complete in one pass of your game loop.
ClearForces(): void;
// Query the world for all fixtures that potentially overlap the
// provided AABB.
// boolean} callback a user implemented callback class.
QueryAABB(callback: (fixture: b2Fixture) => boolean | b2QueryCallback, aabb: b2AABB): void;
// boolean} callback
QueryShape(callback: (fixture: b2Fixture) => boolean | b2QueryCallback, shape: b2Shape, transform: b2Transform): void;
// boolean} callback
QueryPoint(callback: (fixture: b2Fixture) => boolean | b2QueryCallback, point: b2Vec2): void;
// Ray-cast the world for all fixtures in the path of the ray.
// Your callback controls whether you get the closest point, any
// point, or n-points. The ray-cast ignores shapes that contain
// the starting point.
// box2d.b2Vec2, box2d.b2Vec2, number)} callback a user
// implemented callback class.
RayCast(callback: (fixture: b2Fixture, vec1: b2Vec2, vec2: b2Vec2, points: number) => void | b2RayCastCallback, point1: b2Vec2, point2: b2Vec2): void;
RayCastOne(point1: b2Vec2, point2: b2Vec2): b2Fixture;
RayCastAll(point1: b2Vec2, point2: b2Vec2, out: Array<b2Fixture>): Array<b2Fixture>;
DrawShape(fixture: b2Fixture, color: b2Color): void;
DrawJoint(joint: b2Joint): void;
// Call this to draw shapes and other debug draw data.
DrawDebugData(): void;
SetBroadPhase(broadPhase: b2BroadPhase): void;
// Get the number of broad-phase proxies.
GetProxyCount(): number;
// Get the height of the dynamic tree.
GetTreeHeight(): number;
// Get the balance of the dynamic tree.
GetTreeBalance(): number;
// Get the quality metric of the dynamic tree. The smaller the
// better. The minimum is 1.
GetTreeQuality(): number;
// Shift the world origin. Useful for large worlds.
// The body shift formula is: position -= newOrigin
ShiftOrigin(newOrigin: b2Vec2): void;
// Dump the world into the log file.
// warning this should be called outside of a time step.
Dump(): void;
AddController(controller: b2Controller): b2Controller;
RemoveController(controller: b2Controller): void;
}
class b2AreaJointDef extends b2JointDef {
// Definition for a {@link box2d.b2AreaJoint}, which connects a
// group a bodies together so they maintain a constant area
// within them.
constructor();
world: b2World;
bodies: Array<b2Body>;
// The mass-spring-damper frequency in Hertz. A value of 0
// disables softness.
frequencyHz: number;
// The damping ratio. 0 = no damping, 1 = critical damping.
dampingRatio: number;
AddBody(body: b2Body): void;
}
class b2AreaJoint extends b2Joint {
// A distance joint constrains two points on two bodies to
// remain at a fixed distance from each other. You can view this
// as a massless, rigid rod.
constructor(def: b2AreaJointDef);
m_bodies: Array<b2Body>;
m_frequencyHz: number;
m_dampingRatio: number;
m_impulse: number;
GetAnchorA(out: b2Vec2): b2Vec2;
GetAnchorB(out: b2Vec2): b2Vec2;
// Get the reaction force given the inverse time step.
// Unit is N.
GetReactionForce(inv_dt: number, out: b2Vec2): b2Vec2;
// Get the reaction torque given the inverse time step.
// Unit is N*m. This is always zero for a distance joint.
GetReactionTorque(inv_dt: number): number;
// Set/get frequency in Hz.
SetFrequency(hz: number): void;
GetFrequency(): number;
// Set/get damping ratio.
SetDampingRatio(ratio: number): void;
GetDampingRatio(): number;
// Dump joint to dmLog
Dump(): void;
InitVelocityConstraints(data: b2SolverData): void;
SolveVelocityConstraints(data: b2SolverData): void;
SolvePositionConstraints(data: b2SolverData): boolean;
}
class b2BuoyancyController extends b2Controller {
// Calculates buoyancy forces for fluids in the form of a half
// plane.
constructor();
// The outer surface normal
normal: b2Vec2;
// The height of the fluid surface along the normal
offset: number;
// The fluid density
density: number;
// Fluid velocity, for drag calculations
velocity: b2Vec2;
// Linear drag co-efficient
linearDrag: number;
// Linear drag co-efficient
angularDrag: number;
// If false, bodies are assumed to be uniformly dense, otherwise
// use the shapes densities
useDensity: boolean;
// If true, gravity is taken from the world instead of the
useWorldGravity: boolean;
// Gravity vector, if the world's gravity is not used
gravity: b2Vec2;
Step(step: b2TimeStep): void;
Draw(debugDraw: b2Draw): void;
}
class b2TensorDampingController extends b2Controller {
// Applies top down linear damping to the controlled bodies
// The damping is calculated by multiplying velocity by a matrix
// in local co-ordinates.
constructor();
// Tensor to use in damping model
T: b2Mat22;
// Set this to a positive number to clamp the maximum amount of
// damping done.
maxTimestep: number;
Step(step: b2TimeStep): void;
// Sets damping independantly along the x and y axes
SetAxisAligned(xDamping: number, yDamping: number): void;
}
class b2DistanceJointDef extends b2JointDef {
// Distance joint definition. This requires defining an anchor
// point on both bodies and the non-zero length of the distance
// joint. The definition uses local anchor points so that the
// initial configuration can violate the constraint slightly.
// This helps when saving and loading a game.
// warning Do not use a zero or short length.
constructor();
// The local anchor point relative to bodyA's origin.
localAnchorA: b2Vec2;
// The local anchor point relative to bodyB's origin.
localAnchorB: b2Vec2;
// The natural length between the anchor points.
length: number;
// The mass-spring-damper frequency in Hertz. A value of 0
// disables softness.
frequencyHz: number;
// The damping ratio. 0 = no damping, 1 = critical damping.
dampingRatio: number;
Initialize(b1: b2Body, b2: b2Body, anchor1: b2Vec2, anchor2: b2Vec2): void;
}
class b2DistanceJoint extends b2Joint {
// A distance joint constrains two points on two bodies to
// remain at a fixed distance from each other. You can view this
// as a massless, rigid rod.
constructor(def: b2DistanceJointDef);
m_frequencyHz: number;
m_dampingRatio: number;
m_bias: number;
m_localAnchorA: b2Vec2;
m_localAnchorB: b2Vec2;
m_gamma: number;
m_impulse: number;
m_length: number;
m_indexA: number;
m_indexB: number;
m_u: b2Vec2;
m_rA: b2Vec2;
m_rB: b2Vec2;
m_localCenterA: b2Vec2;
m_localCenterB: b2Vec2;
m_invMassA: number;
m_invMassB: number;
m_invIA: number;
m_invIB: number;
m_mass: number;
m_qA: b2Rot;
m_qB: b2Rot;
m_lalcA: b2Vec2;
m_lalcB: b2Vec2;
GetAnchorA(out: b2Vec2): b2Vec2;
GetAnchorB(out: b2Vec2): b2Vec2;
// Get the reaction force given the inverse time step.
// Unit is N.
GetReactionForce(inv_dt: number, out: b2Vec2): b2Vec2;
// Get the reaction torque given the inverse time step.
// Unit is N*m. This is always zero for a distance joint.
GetReactionTorque(inv_dt: number): number;
// The local anchor point relative to bodyA's origin.
GetLocalAnchorA(out: b2Vec2): b2Vec2;
// The local anchor point relative to bodyB's origin.
GetLocalAnchorB(out: b2Vec2): b2Vec2;
SetLength(length: number): void;
GetLength(): number;
// Set/get frequency in Hz.
SetFrequency(hz: number): void;
GetFrequency(): number;
// Set/get damping ratio.
SetDampingRatio(ratio: number): void;
GetDampingRatio(): number;
// Dump joint to dmLog
Dump(): void;
InitVelocityConstraints(data: b2SolverData): void;
SolveVelocityConstraints(data: b2SolverData): void;
SolvePositionConstraints(data: b2SolverData): boolean;
}
class b2FrictionJointDef extends b2JointDef {
// Friction joint definition.
constructor();
// The local anchor point relative to bodyA's origin.
localAnchorA: b2Vec2;
// The local anchor point relative to bodyB's origin.
localAnchorB: b2Vec2;
// The maximum friction force in N.
maxForce: number;
// The maximum friction torque in N-m.
maxTorque: number;
Initialize(bA: b2Body, bB: b2Body, anchor: b2Vec2): void;
}
class b2FrictionJoint extends b2Joint {
// Friction joint. This is used for top-down friction. It
// provides 2D translational friction and angular friction.
constructor(def: b2FrictionJointDef);
m_localAnchorA: b2Vec2;
m_localAnchorB: b2Vec2;
m_linearImpulse: b2Vec2;
m_angularImpulse: number;
m_maxForce: number;
m_maxTorque: number;
m_indexA: number;
m_indexB: number;
m_rA: b2Vec2;
m_rB: b2Vec2;
m_localCenterA: b2Vec2;
m_localCenterB: b2Vec2;
m_invMassA: number;
m_invMassB: number;
m_invIA: number;
m_invIB: number;
m_linearMass: b2Mat22;
m_angularMass: number;
m_qA: b2Rot;
m_qB: b2Rot;
m_lalcA: b2Vec2;
m_lalcB: b2Vec2;
m_K: b2Mat22;
InitVelocityConstraints(data: b2SolverData): void;
SolveVelocityConstraints(data: b2SolverData): void;
SolvePositionConstraints(data: b2SolverData): boolean;
GetAnchorA(out: b2Vec2): b2Vec2;
GetAnchorB(out: b2Vec2): b2Vec2;
GetReactionForce(inv_dt: number, out: b2Vec2): b2Vec2;
GetReactionTorque(inv_dt: number): number;
// The local anchor point relative to bodyA's origin.
GetLocalAnchorA(out: b2Vec2): b2Vec2;
// The local anchor point relative to bodyB's origin.
GetLocalAnchorB(out: b2Vec2): b2Vec2;
// Set the maximum friction force in N.
SetMaxForce(force: number): void;
// Get the maximum friction force in N.
GetMaxForce(): number;
// Set the maximum friction torque in N*m.
SetMaxTorque(torque: number): void;
// Get the maximum friction torque in N*m.
GetMaxTorque(): number;
// Dump joint to dmLog
Dump(): void;
}
class b2MouseJointDef extends b2JointDef {
// Mouse joint definition. This requires a world target point,
// tuning parameters, and the time step.
constructor();
// The initial world target point. This is assumed to coincide
// with the body anchor initially.
target: b2Vec2;
// The maximum constraint force that can be exerted to move the
// candidate body. Usually you will express as some multiple of
// the weight (multiplier * mass * gravity).
maxForce: number;
// The response speed.
frequencyHz: number;
// The damping ratio. 0 = no damping, 1 = critical damping.
dampingRatio: number;
}
class b2MouseJoint extends b2Joint {
// A mouse joint is used to make a point on a body track a
// specified world point. This a soft constraint with a maximum
// force. This allows the constraint to stretch and without
// applying huge forces.
// NOTE: this joint is not documented in the manual because it
// was developed to be used in the testbed. If you want to learn
// how to use the mouse joint, look at the testbed.
constructor(def: b2MouseJointDef);
m_localAnchorB: b2Vec2;
m_targetA: b2Vec2;
m_frequencyHz: number;
m_dampingRatio: number;
m_beta: number;
m_impulse: b2Vec2;
m_maxForce: number;
m_gamma: number;
m_indexA: number;
m_indexB: number;
m_rB: b2Vec2;
m_localCenterB: b2Vec2;
m_invMassB: number;
m_invIB: number;
m_mass: b2Mat22;
m_C: b2Vec2;
m_qB: b2Rot;
m_lalcB: b2Vec2;
m_K: b2Mat22;
SetTarget(target: b2Vec2): void;
GetTarget(out: b2Vec2): b2Vec2;
SetMaxForce(maxForce: number): void;
GetMaxForce(): number;
SetFrequency(hz: number): void;
GetFrequency(): number;
SetDampingRatio(ratio: number): void;
GetDampingRatio(): number;
InitVelocityConstraints(data: b2SolverData): void;
SolveVelocityConstraints(data: b2SolverData): void;
SolvePositionConstraints(data: b2SolverData): boolean;
GetAnchorA(out: b2Vec2): b2Vec2;
GetAnchorB(out: b2Vec2): b2Vec2;
GetReactionForce(inv_dt: number, out: b2Vec2): b2Vec2;
GetReactionTorque(inv_dt: number): number;
// The mouse joint does not support dumping.
Dump(): void;
// Implement b2Joint::ShiftOrigin
ShiftOrigin(newOrigin: b2Vec2): void;
}
class b2ConstantForceController extends b2Controller {
// Applies a force every frame
constructor();
Step(step: b2TimeStep): void;
}
class b2PulleyJointDef extends b2JointDef {
// Pulley joint definition. This requires two ground anchors,
// two dynamic body anchor points, and a pulley ratio.
constructor();
// The first ground anchor in world coordinates. This point
// never moves.
groundAnchorA: b2Vec2;
// The second ground anchor in world coordinates. This point
// never moves.
groundAnchorB: b2Vec2;
// The local anchor point relative to bodyA's origin.
localAnchorA: b2Vec2;
// The local anchor point relative to bodyB's origin.
localAnchorB: b2Vec2;
// The a reference length for the segment attached to bodyA.
lengthA: number;
// The a reference length for the segment attached to bodyB.
lengthB: number;
// The pulley ratio, used to simulate a block-and-tackle.
ratio: number;
Initialize(bA: b2Body, bB: b2Body, groundA: b2Vec2, groundB: b2Vec2, anchorA: b2Vec2, anchorB: b2Vec2, r: number): void;
}
class b2PulleyJoint extends b2Joint {
// The pulley joint is connected to two bodies and two fixed ground points.
// The pulley supports a ratio such that:
// lengthA + ratio * lengthB <= constant
// Yes, the force transmitted is scaled by the ratio.
// Warning: the pulley joint can get a bit squirrelly by itself.
// They often work better when combined with prismatic joints.
// You should also cover the the anchor points with static
// shapes to prevent one side from going to zero length.
constructor(def: b2PulleyJointDef);
m_groundAnchorA: b2Vec2;
m_groundAnchorB: b2Vec2;
m_lengthA: number;
m_lengthB: number;
m_localAnchorA: b2Vec2;
m_localAnchorB: b2Vec2;
m_constant: number;
m_ratio: number;
m_impulse: number;
m_indexA: number;
m_indexB: number;
m_uA: b2Vec2;
m_uB: b2Vec2;
m_rA: b2Vec2;
m_rB: b2Vec2;
m_localCenterA: b2Vec2;
m_localCenterB: b2Vec2;
m_invMassA: number;
m_invMassB: number;
m_invIA: number;
m_invIB: number;
m_mass: number;
m_qA: b2Rot;
m_qB: b2Rot;
m_lalcA: b2Vec2;
m_lalcB: b2Vec2;
InitVelocityConstraints(data: b2SolverData): void;
SolveVelocityConstraints(data: b2SolverData): void;
SolvePositionConstraints(data: b2SolverData): boolean;
GetAnchorA(out: b2Vec2): b2Vec2;
GetAnchorB(out: b2Vec2): b2Vec2;
GetReactionForce(inv_dt: number, out: b2Vec2): b2Vec2;
GetReactionTorque(inv_dt: number): number;
GetGroundAnchorA(out: b2Vec2): b2Vec2;
GetGroundAnchorB(out: b2Vec2): b2Vec2;
// Get the current length of the segment attached to bodyA.
GetLengthA(): number;
// Get the current length of the segment attached to bodyB.
GetLengthB(): number;
// Get the pulley ratio.
GetRatio(): number;
// Get the current length of the segment attached to bodyA.
GetCurrentLengthA(): number;
// Get the current length of the segment attached to bodyB.
GetCurrentLengthB(): number;
// Dump joint to dmLog
Dump(): void;
// Implement b2Joint::ShiftOrigin
ShiftOrigin(newOrigin: b2Vec2): void;
}
class b2CircleShape extends b2Shape {
// A circle shape.
constructor(radius?: number);
m_p: b2Vec2;
// Implement box2d.b2Shape.
Clone(): b2Shape;
Copy(other: b2Shape): b2Shape;
// Implement box2d.b2Shape.
GetChildCount(): number;
// Implement box2d.b2Shape.
TestPoint(transform: b2Transform, p: b2Vec2): boolean;
// Implement box2d.b2Shape.
// Collision Detection in Interactive 3D Environments by Gino
// van den Bergen From Section 3.1.2
// x = s + a * r
// norm(x) = radius
RayCast(output: b2RayCastOutput, input: b2RayCastInput, transform: b2Transform, childIndex: number): boolean;
ComputeAABB(aabb: b2AABB, transform: b2Transform, childIndex: number): void;
ComputeMass(massData: b2MassData, density: number): void;
SetupDistanceProxy(proxy: b2DistanceProxy, index: number): void;
ComputeSubmergedArea(normal: b2Vec2, offset: number, xf: b2Transform, c: b2Vec2): number;
// Dump this shape to the log file.
Dump(): void;
}
class b2RopeDef {
constructor();
}
class b2Rope {
constructor();
GetVertexCount(): number;
GetVertices(): Array<b2Vec2>;
Initialize(def: b2RopeDef): void;
Step(h: number, iterations: number): void;
SolveC2(): void;
SetAngleRadians(angle: number): void;
SolveC3(): void;
Draw(draw: b2Draw): void;
}
class b2WheelJointDef extends b2JointDef {
// Wheel joint definition. This requires defining a line of
// motion using an axis and an anchor point. The definition uses
// local anchor points and a local axis so that the initial
// configuration can violate the constraint slightly. The joint
// translation is zero when the local anchor points coincide in
// world space. Using local anchors and a local axis helps when
// saving and loading a game.
constructor();
// The local anchor point relative to bodyA's origin.
localAnchorA: b2Vec2;
// The local anchor point relative to bodyB's origin.
localAnchorB: b2Vec2;
// The local translation axis in bodyA.
localAxisA: b2Vec2;
// Enable/disable the joint motor.
enableMotor: boolean;
// The maximum motor torque, usually in N-m.
maxMotorTorque: number;
// The desired motor speed in radians per second.
motorSpeed: number;
// Suspension frequency, zero indicates no suspension
frequencyHz: number;
// Suspension damping ratio, one indicates critical damping
dampingRatio: number;
Initialize(bA: b2Body, bB: b2Body, anchor: b2Vec2, axis: b2Vec2): void;
}
class b2WheelJoint extends b2Joint {
// A wheel joint. This joint provides two degrees of freedom:
// translation along an axis fixed in bodyA and rotation in the
// plane. You can use a joint limit to restrict the range of
// motion and a joint motor to drive the rotation or to model
// rotational friction.
// This joint is designed for vehicle suspensions.
constructor(def: b2WheelJointDef);
m_frequencyHz: number;
m_dampingRatio: number;
m_localAnchorA: b2Vec2;
m_localAnchorB: b2Vec2;
m_localXAxisA: b2Vec2;
m_localYAxisA: b2Vec2;
m_impulse: number;
m_motorImpulse: number;
m_springImpulse: number;
m_maxMotorTorque: number;
m_motorSpeed: number;
m_enableMotor: boolean;
m_indexA: number;
m_indexB: number;
m_localCenterA: b2Vec2;
m_localCenterB: b2Vec2;
m_invMassA: number;
m_invMassB: number;
m_invIA: number;
m_invIB: number;
m_ax: b2Vec2;
m_ay: b2Vec2;
m_sAx: number;
m_sBx: number;
m_sAy: number;
m_sBy: number;
m_mass: number;
m_motorMass: number;
m_springMass: number;
m_bias: number;
m_gamma: number;
m_qA: b2Rot;
m_qB: b2Rot;
m_lalcA: b2Vec2;
m_lalcB: b2Vec2;
m_rA: b2Vec2;
m_rB: b2Vec2;
// Get the motor speed, usually in radians per second.
GetMotorSpeed(): number;
GetMaxMotorTorque(): number;
SetSpringFrequencyHz(hz: number): void;
GetSpringFrequencyHz(): number;
SetSpringDampingRatio(ratio: number): void;
GetSpringDampingRatio(): number;
InitVelocityConstraints(data: b2SolverData): void;
SolveVelocityConstraints(data: b2SolverData): void;
SolvePositionConstraints(data: b2SolverData): boolean;
GetDefinition(def: b2WheelJointDef): b2WheelJointDef;
GetAnchorA(out: b2Vec2): b2Vec2;
GetAnchorB(out: b2Vec2): b2Vec2;
GetReactionForce(inv_dt: number, out: b2Vec2): b2Vec2;
GetReactionTorque(inv_dt: number): number;
// The local anchor point relative to bodyA's origin.
GetLocalAnchorA(out: b2Vec2): b2Vec2;
// The local anchor point relative to bodyB's origin.
GetLocalAnchorB(out: b2Vec2): b2Vec2;
// The local joint axis relative to bodyA.
GetLocalAxisA(out: b2Vec2): b2Vec2;
GetJointTranslation(): number;
GetJointSpeed(): number;
IsMotorEnabled(): boolean;
EnableMotor(flag: boolean): void;
// Set the motor speed, usually in radians per second.
SetMotorSpeed(speed: number): void;
// Set/Get the maximum motor force, usually in N-m.
SetMaxMotorTorque(force: number): void;
// Get the current motor torque given the inverse time step,
// usually in N-m.
GetMotorTorque(inv_dt: number): number;
// Dump to b2Log
Dump(): void;
}
class b2MotorJointDef extends b2JointDef {
// Motor joint definition.
constructor();
// Position of bodyB minus the position of bodyA, in bodyA's
// frame, in meters.
linearOffset: b2Vec2;
// The bodyB angle minus bodyA angle in radians.
angularOffset: number;
// The maximum motor force in N.
maxForce: number;
// The maximum motor torque in N-m.
maxTorque: number;
// Position correction factor in the range [0,1].
correctionFactor: number;
Initialize(bA: b2Body, bB: b2Body): void;
}
class b2MotorJoint extends b2Joint {
// A motor joint is used to control the relative motion between
// two bodies. A typical usage is to control the movement of a
// dynamic body with respect to the ground.
constructor(def: b2MotorJointDef);
m_linearOffset: b2Vec2;
m_angularOffset: number;
m_linearImpulse: b2Vec2;
m_angularImpulse: number;
m_maxForce: number;
m_maxTorque: number;
m_correctionFactor: number;
m_indexA: number;
m_indexB: number;
m_rA: b2Vec2;
m_rB: b2Vec2;
m_localCenterA: b2Vec2;
m_localCenterB: b2Vec2;
m_linearError: b2Vec2;
m_angularError: number;
m_invMassA: number;
m_invMassB: number;
m_invIA: number;
m_invIB: number;
m_linearMass: b2Mat22;
m_angularMass: number;
m_qA: b2Rot;
m_qB: b2Rot;
m_K: b2Mat22;
GetAnchorA(out: b2Vec2): b2Vec2;
GetAnchorB(out: b2Vec2): b2Vec2;
GetReactionForce(inv_dt: number, out: b2Vec2): b2Vec2;
GetReactionTorque(inv_dt: number): number;
// Set the position correction factor in the range [0,1].
SetCorrectionFactor(factor: number): void;
// Get the position correction factor in the range [0,1].
GetCorrectionFactor(): number;
// Set/get the target linear offset, in frame A, in meters.
SetLinearOffset(linearOffset: b2Vec2): void;
GetLinearOffset(out: b2Vec2): b2Vec2;
// Set/get the target angular offset, in radians.
SetAngularOffset(angularOffset: number): void;
GetAngularOffset(): number;
// Set the maximum friction force in N.
SetMaxForce(force: number): void;
// Get the maximum friction force in N.
GetMaxForce(): number;
// Set the maximum friction torque in N*m.
SetMaxTorque(torque: number): void;
// Get the maximum friction torque in N*m.
GetMaxTorque(): number;
InitVelocityConstraints(data: b2SolverData): void;
SolveVelocityConstraints(data: b2SolverData): void;
SolvePositionConstraints(data: b2SolverData): boolean;
// Dump to b2Log
Dump(): void;
}
class b2ParticleSystem {
}
}
Reference in a new issue View git blame Copy permalink