* Capsule shape class. * @class Capsule * @constructor * @extends Shape * @param {Number} [length=1] The distance between the end points * @param

* Circle shape class. * @class Circle * @extends Shape * @constructor * @param {number} [radius=1] The radius of this circle * * @example *

* Base constraint class. * * @class Constraint * @constructor * @author schteppe * @param {Body} bodyA * @param {Body} bodyB * @param {Number}

* Non-penetration constraint equation. Tries to make the contactPointA and contactPointB vectors coincide, while keeping the applied force repulsive.

* Defines what happens when two materials meet, such as what friction coefficient to use. You can also set other things such as restitution, surface v

* Convex shape class. * @class Convex * @constructor * @extends Shape * @param {Array} vertices An array of vertices that span this shape. Vertice

* Constraint that tries to keep the distance between two bodies constant. * * @class DistanceConstraint * @constructor * @author schteppe * @para

* Base class for constraint equations. * @class Equation * @constructor * @param {Body} bodyA First body participating in the equation * @param {B

* Constrains the slipping in a contact along a tangent * * @class FrictionEquation * @constructor * @param {Body} bodyA * @param {Body} bodyB *

* Iterative Gauss-Seidel constraint equation solver. * * @class GSSolver * @constructor * @extends Solver * @param {Object} [options] * @param {

* Connects two bodies at given offset points, letting them rotate relative to each other around this point. * @class GearConstraint * @constructor

* Broadphase that uses axis-aligned bins. * @class GridBroadphase * @constructor * @extends Broadphase * @param {object} [options] * @param {numb

* Heightfield shape class. Height data is given as an array. These data points are spread out evenly with a distance "elementWidth". * @class Heightf

* An island of bodies connected with equations. * @class Island * @constructor

* Splits the system of bodies and equations into independent islands * * @class IslandManager * @constructor * @param {Object} [options] * @exten

* Holds a body and keeps track of some additional properties needed for graph traversal. * @class IslandNode * @constructor * @param {Body} body

* Container for line-related functions * @class Line

* A spring, connecting two bodies. * * The Spring explicitly adds force and angularForce to the bodies. * * @class LinearSpring * @extends Spring

* Locks the relative position between two bodies. * * @class LockConstraint * @constructor * @author schteppe * @param {Body} bodyA * @param {Bo

* Defines a physics material. * @class Material * @constructor * @param {number} id Material identifier * @author schteppe

* Naive broadphase implementation. Does N^2 tests. * * @class NaiveBroadphase * @constructor * @extends Broadphase

* Narrowphase. Creates contacts and friction given shapes and transforms. * @class Narrowphase * @constructor

* Keeps track of overlaps in the current state and the last step state. * @class OverlapKeeper * @constructor

* Overlap data container for the OverlapKeeper * @class OverlapKeeperRecord * @constructor * @param {Body} bodyA * @param {Shape} shapeA * @param

* Particle shape class. * @class Particle * @constructor * @extends Shape

* Plane shape class. The plane is facing in the Y direction. * @class Plane * @extends Shape * @constructor

* Point related functions * @class Point

* Polygon class. * @class Polygon * @constructor

* Constraint that only allows bodies to move along a line, relative to each other. See <a href="http://www.iforce2d.net/b2dtut/joints-prismatic">this

* Class: ProxyBuffer * ================== * * Only used in Firefox, since Firefox does not allow augmenting "native" * objects (like Uint8Array in

* Rectangle shape class. * @class Rectangle * @constructor * @param {Number} [width=1] Width * @param {Number} [height=1] Height * @extends Conve

* Connects two bodies at given offset points, letting them rotate relative to each other around this point. * @class RevoluteConstraint * @construct

* Locks the relative angle between two bodies. The constraint tries to keep the dot product between two vectors, local in each body, to zero. The loca

* A rotational spring, connecting two bodies rotation. This spring explicitly adds angularForce (torque) to the bodies. * * The spring can be combin

* Syncs rotational velocity of two bodies, or sets a relative velocity (motor). * * @class RotationalVelocityEquation * @constructor * @extends Eq

* Sweep and prune broadphase along one axis. * * @class SAPBroadphase * @constructor * @extends Broadphase

* Scalar functions * @class Scalar

* Base class for shapes. * @class Shape * @constructor * @param {Number} type

* Base class for constraint solvers. * @class Solver * @constructor * @extends EventEmitter

* A spring, connecting two bodies. The Spring explicitly adds force and angularForce to the bodies and does therefore not put load on the constraint s

* @class TupleDictionary * @constructor

* Misc utility functions * @class Utils * @constructor