number of body types

The maximum number of vertices on a convex polygon. Changing this affects performance even if you don't use more vertices.

/ Use these to make your identifiers null. / You may also use zero initialization to get null.

The number of shape types

Prototype for user allocation function @param size the allocation size in bytes @param alignment the required alignment, guaranteed to be a power of 2

Prototype for the user assert callback. Return 0 to skip the debugger break.

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. Body definitions are temporary objects used to bundle creation parameters. Must be initialized using b2DefaultBodyDef(). @ingroup body

Body events are buffered in the Box2D world and are available as event arrays after the time step is complete. Note: this date becomes invalid if bodies are destroyed

/ Body id references a body instance. This should be treated as an opaque handle.

Body move events triggered when a body moves. Triggered when a body moves due to simulation. Not reported for bodies moved by the user. This also has a flag to indicate that the body went to sleep so the application can also sleep that actor/entity/object associated with the body. On the other hand if the flag does not indicate the body went to sleep then the application can treat the actor/entity/object associated with the body as awake. This is an efficient way for an application to update game object transforms rather than calling functions such as b2Body_GetTransform() because this data is delivered as a contiguous array and it is only populated with bodies that have moved. @note If sleeping is disabled all dynamic and kinematic bodies will trigger move events.

The body simulation type. Each body is one of these three types. The type determines how the body behaves in the simulation. @ingroup body

A solid capsule can be viewed as two semicircles connected by a rectangle.

Low level ray cast or shape-cast output data. Returns a zero fraction and normal in the case of initial overlap.

Prototype callback for ray and shape casts. Called for each shape found in the query. You control how the ray cast proceeds by returning a f32: return -1: ignore this shape 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 A cast with initial overlap will return a zero fraction and a zero normal. @param shapeId the shape hit by the ray @param point the point of initial intersection @param normal the normal vector at the point of intersection, zero for a shape cast with initial overlap @param fraction the fraction along the ray at the point of intersection, zero for a shape cast with initial overlap @param context the user context @return -1 to filter, 0 to terminate, fraction to clip the ray for closest hit, 1 to continue @see b2World_CastRay @ingroup world

Used to create a chain of line segments. This is designed to eliminate ghost collisions with some limitations. - chains are one-sided - chains have no mass and should be used on static bodies - chains have a counter-clockwise winding order (normal points right of segment direction) - chains are either a loop or open - a chain must have at least 4 points - the distance between any two points must be greater than B2_LINEAR_SLOP - a chain shape should not self intersect (this is not validated) - an open chain shape has NO COLLISION on the first and final edge - you may overlap two open chains on their first three and/or last three points to get smooth collision - a chain shape creates multiple line segment shapes on the body https://en.wikipedia.org/wiki/Polygonal_chain Must be initialized using b2DefaultChainDef(). @warning Do not use chain shapes unless you understand the limitations. This is an advanced feature. @ingroup shape

/ Chain id references a chain instances. This should be treated as an opaque handle.

A line segment with one-sided collision. Only collides on the right side. Several of these are generated for a chain shape. ghost1 -> point1 -> point2 -> ghost2

A solid circle

These are collision planes that can be fed to b2SolvePlanes. Normally this is assembled by the user from plane results in b2PlaneResult

A begin touch event is generated when two shapes begin touching.

The contact data for two shapes. By convention the manifold normal points from shape A to shape B. @see b2Shape_GetContactData() and b2Body_GetContactData()

An end touch event is generated when two shapes stop touching. You will get an end event if you do anything that destroys contacts previous to the last world step. These include things like setting the transform, destroying a body or shape, or changing a filter or body type.

Contact events are buffered in the Box2D world and are available as event arrays after the time step is complete. Note: these may become invalid if bodies and/or shapes are destroyed

A hit touch event is generated when two shapes collide with a speed faster than the hit speed threshold. This may be reported for speculative contacts that have a confirmed impulse.

Cosine and sine pair This uses a custom implementation designed for cross-platform determinism

Counters that give details of the simulation size.

Prototype for a contact filter callback. This is called when a contact pair is considered for collision. This allows you to perform custom logic to prevent collision between shapes. This is only called if one of the two shapes has custom filtering enabled. @see b2ShapeDef. Notes: - this function must be thread-safe - this is only called if one of the two shapes has enabled custom filtering - this is called only for awake dynamic bodies Return false if you want to disable the collision @warning Do not attempt to modify the world inside this callback @ingroup world

This struct holds callbacks you can implement to draw a Box2D world. @ingroup world

Input for b2ShapeDistance

Distance joint definition This requires defining an anchor point on both bodies and the non-zero distance 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. @ingroup distance_joint

Output for b2ShapeDistance

The dynamic tree structure. This should be considered private data. It is placed here for performance reasons.

These functions can be provided to Box2D to invoke a task system. These are designed to work well with enkiTS. Returns a pointer to the user's task object. May be nullptr. A nullptr indicates to Box2D that the work was executed serially within the callback and there is no need to call b2FinishTaskCallback. The itemCount is the number of Box2D work items that are to be partitioned among workers by the user's task system. This is essentially a parallel-for. The minRange parameter is a suggestion of the minimum number of items to assign per worker to reduce overhead. For example, suppose the task is small and that itemCount is 16. A minRange of 8 suggests that your task system should split the work items among just two workers, even if you have more available. In general the range [startIndex, endIndex) send to TaskCallback should obey: endIndex - startIndex >= minRange The exception of course is when itemCount < minRange. @ingroup world

The explosion definition is used to configure options for explosions. Explosions consider shape geometry when computing the impulse. @ingroup world

This is used to filter collision on shapes. It affects shape-vs-shape collision and shape-versus-query collision (such as b2World_CastRay). @ingroup shape

A filter joint is used to disable collision between two specific bodies. @ingroup filter_joint

Finishes a user task object that wraps a Box2D task. @ingroup world

Prototype for user free function @param mem the memory previously allocated through `b2AllocFcn`

Optional friction mixing callback. This intentionally provides no context objects because this is called from a worker thread. @warning This function should not attempt to modify Box2D state or user application state. @ingroup world

These colors are used for debug draw and mostly match the named SVG colors. See https://www.rapidtables.com/web/color/index.html https://johndecember.com/html/spec/colorsvg.html https://upload.wikimedia.org/wikipedia/commons/2/2b/SVG_Recognized_color_keyword_names.svg

A convex hull. Used to create convex polygons. @warning Do not modify these values directly, instead use b2ComputeHull()

/ Joint id references a joint instance. This should be treated as an opaque handle.

Joint type enumeration This is useful because all joint types use b2JointId and sometimes you want to get the type of a joint. @ingroup joint

A contact manifold describes the contact points between colliding shapes. @note Box2D uses speculative collision so some contact points may be separated.

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. Box2D uses speculative collision so some contact points may be separated. You may use the totalNormalImpulse to determine if there was an interaction during the time step.

This holds the mass data computed for a shape.

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. @ingroup motor_joint

A mouse joint is used to make a point on a body track a specified world point. This a soft constraint and allows the constraint to stretch without applying huge forces. This also applies rotation constraint heuristic to improve control. @ingroup mouse_joint

Prototype callback for overlap queries. Called for each shape found in the query. @see b2World_QueryAABB @return false to terminate the query. @ingroup world

separation = dot(normal, point) - offset

/ These are the collision planes returned from b2World_CollideMover

Used to collect collision planes for character movers. Return true to continue gathering planes.

Result returned by b2SolvePlanes

A solid 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 MAX_POLYGON_VERTICES. In most cases you should not need many vertices for a convex polygon. @warning DO NOT fill this out manually, instead use a helper function like b2MakePolygon or b2MakeBox.

Prototype for a pre-solve callback. 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. modify the normal). Notes: - this function must be thread-safe - this is only called if the shape has enabled pre-solve events - this is called only for awake dynamic bodies - this is not called for sensors - the supplied manifold has impulse values from the previous step Return false if you want to disable the contact this step @warning Do not attempt to modify the world inside this callback @ingroup world

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. @ingroup prismatic_joint

! @cond Profiling data. Times are in milliseconds.

The query filter is used to filter collisions between queries and shapes. For example, you may want a ray-cast representing a projectile to hit players and the static environment but not debris. @ingroup shape

Low level ray cast input data

Result from b2World_RayCastClosest If there is initial overlap the fraction and normal will be zero while the point is an arbitrary point in the overlap region. @ingroup world

Optional restitution mixing callback. This intentionally provides no context objects because this is called from a worker thread. @warning This function should not attempt to modify Box2D state or user application state. @ingroup world

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 @ingroup revolute_joint

A line segment with two-sided collision.

Result of computing the distance between two line segments

A begin touch event is generated when a shape starts to overlap a sensor shape.

An end touch event is generated when a shape stops overlapping a sensor shape. These include things like setting the transform, destroying a body or shape, or changing a filter. You will also get an end event if the sensor or visitor are destroyed. Therefore you should always confirm the shape id is valid using b2Shape_IsValid.

Sensor events are buffered in the Box2D world and are available as begin/end overlap event arrays after the time step is complete. Note: these may become invalid if bodies and/or shapes are destroyed

Low level shape cast input in generic form. This allows casting an arbitrary point cloud wrap with a radius. For example, a circle is a single point with a non-zero radius. A capsule is two points with a non-zero radius. A box is four points with a zero radius.

Input parameters for b2ShapeCast

Used to create a shape. This is a temporary object used to bundle shape creation parameters. You may use the same shape definition to create multiple shapes. Must be initialized using b2DefaultShapeDef(). @ingroup shape

/ Shape id references a shape instance. This should be treated as an opaque handle.

A distance proxy is used by the GJK algorithm. It encapsulates any shape. You can provide between 1 and MAX_POLYGON_VERTICES and a radius.

Shape type @ingroup shape

Simplex from the GJK algorithm

Used to warm start the GJK simplex. If you call this function multiple times with nearby transforms this might improve performance. Otherwise you can zero initialize this. The distance cache must be initialized to zero on the first call. Users should generally just zero initialize this structure for each call.

Simplex vertex for debugging the GJK algorithm

Surface materials allow chain shapes to have per segment surface properties. @ingroup shape

This describes the motion of a body/shape for TOI computation. Shapes are defined with respect to the body origin, which may not coincide with the center of mass. However, to support dynamics we must interpolate the center of mass position.

Task interface This is prototype for a Box2D task. Your task system is expected to invoke the Box2D task with these arguments. The task spans a range of the parallel-for: [startIndex, endIndex) The worker index must correctly identify each worker in the user thread pool, expected in [0, workerCount). A worker must only exist on only one thread at a time and is analogous to the thread index. The task context is the context pointer sent from Box2D when it is enqueued. The startIndex and endIndex are expected in the range [0, itemCount) where itemCount is the argument to b2EnqueueTaskCallback below. Box2D expects startIndex < endIndex and will execute a loop like this: @code{.odin} for i in startIndex ..< endIndex { DoWork() } @endcode @ingroup world

Input parameters for b2TimeOfImpact

Output parameters for b2TimeOfImpact.

Describes the TOI output

This function receives proxies found in the AABB query. @return true if the query should continue

This function receives clipped raycast input for a proxy. The function returns the new ray fraction. - return a value of 0 to terminate the ray cast - return a value less than input->maxFraction to clip the ray - return a value of input->maxFraction to continue the ray cast without clipping

This function receives clipped ray cast input for a proxy. The function returns the new ray fraction. - return a value of 0 to terminate the ray cast - return a value less than input->maxFraction to clip the ray - return a value of input->maxFraction to continue the ray cast without clipping

These are performance results returned by dynamic tree queries.

Version numbering scheme. See https://semver.org/

Weld joint definition A weld joint connect to bodies together rigidly. This constraint provides springs to mimic soft-body simulation. @note The approximate solver in Box2D cannot hold many bodies together rigidly @ingroup weld_joint

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. @ingroup wheel_joint

World definition used to create a simulation world. Must be initialized using b2DefaultWorldDef(). @ingroup world

/ World id references a world instance. This should be treated as an opaque handle.

Get the center of the AABB.

Does a fully contain b

Get the extents of the AABB (half-widths).

Do a and b overlap

Union of two AABBs

Component-wise absolute vector

@return the absolute value of a float

@return the absolute value of an integer

Vector addition

One-dimensional mass-spring-damper simulation. Returns the new velocity given the position and time step. You can then compute the new position using: position += timeStep * newVelocity This drives towards a zero position. By using implicit integration we get a stable solution that doesn't require transcendental functions.

Apply an angular impulse. The impulse is ignored if the body is not awake. This optionally wakes the body. @param bodyId The body id @param impulse the angular impulse, usually in units of kg*m*m/s @param wake also wake up the body @warning This should be used for one-shot impulses. If you need a steady force, use a force instead, which will work better with the sub-stepping solver.

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 optionally wakes up the body. The force is ignored if the body is not awake. @param bodyId The body id @param force The world force vector, usually in newtons (N) @param point The world position of the point of application @param wake Option to wake up the body

Apply a force to the center of mass. This optionally wakes up the body. The force is ignored if the body is not awake. @param bodyId The body id @param force the world force vector, usually in newtons (N). @param wake also wake up the body

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 optionally wakes the body. The impulse is ignored if the body is not awake. @param bodyId The body id @param impulse the world impulse vector, usually in N*s or kg*m/s. @param point the world position of the point of application. @param wake also wake up the body @warning This should be used for one-shot impulses. If you need a steady force, use a force instead, which will work better with the sub-stepping solver.

Apply an impulse to the center of mass. This immediately modifies the velocity. The impulse is ignored if the body is not awake. This optionally wakes the body. @param bodyId The body id @param impulse the world impulse vector, usually in N*s or kg*m/s. @param wake also wake up the body @warning This should be used for one-shot impulses. If you need a steady force, use a force instead, which will work better with the sub-stepping solver.

This update the mass properties to the sum of the mass properties of the shapes. This normally does not need to be called unless you called SetMassData to override the mass and you later want to reset the mass. You may also use this when automatic mass computation has been disabled. You should call this regardless of body type.

Apply a torque. This affects the angular velocity without affecting the linear velocity. This optionally wakes the body. The torque is ignored if the body is not awake. @param bodyId The body id @param torque about the z-axis (out of the screen), usually in N*m. @param wake also wake up the body

Get the current world AABB that contains all the attached shapes. Note that this may not encompass the body origin. If there are no shapes attached then the returned AABB is empty and centered on the body origin.

Disable a body by removing it completely from the simulation. This is expensive.

Enable a body by adding it to the simulation. This is expensive.

Enable/disable contact events on all shapes. @see b2ShapeDef::enableContactEvents @warning changing this at runtime may cause mismatched begin/end touch events

Enable/disable hit events on all shapes @see b2ShapeDef::enableHitEvents

Enable or disable sleeping for this body. If sleeping is disabled the body will wake.

Get the current angular damping.

Get the angular velocity of a body in radians per second

Get the maximum capacity required for retrieving all the touching contacts on a body

Get the touching contact data for a body

Get the current gravity scale

Get the number of joints on this body

Get the joint ids for all joints on this body, up to the provided capacity @returns the joint ids stored in the user array

Get the current linear damping.

Get the linear velocity of a body's center of mass. Usually in meters per second.

Get the center of mass position of the body in local space

Get a local point on a body given a world point

Get the linear velocity of a local point attached to a body. Usually in meters per second.

Get a local vector on a body given a world vector

Get the mass of the body, usually in kilograms

Get the mass data for a body

Get the body name. May be nil.

Get the world position of a body. This is the location of the body origin.

Get the world rotation of a body as a cosine/sine pair (complex number)

Get the rotational inertia of the body, usually in kg*m^2

Get the number of shapes on this body

Get the shape ids for all shapes on this body, up to the provided capacity. @returns the shape ids stored in the user array

Get the sleep threshold, usually in meters per second.

Get the world transform of a body.

Get the body type: static, kinematic, or dynamic

Get the user data stored in a body

Get the world that owns this body

Get the center of mass position of the body in world space

Get a world point on a body given a local point

Get the linear velocity of a world point attached to a body. Usually in meters per second.

Get a world vector on a body given a local vector

@return true if this body is awake

Is this body a bullet?

Returns true if this body is enabled

Does this body have fixed rotation?

Returns true if sleeping is enabled for this body

Body identifier validation. Can be used to detect orphaned ids. Provides validation for up to 64K allocations.

Adjust the angular damping. Normally this is set in BodyDef before creation.

Set the angular velocity of a body in radians per second

Wake a body from sleep. This wakes the entire island the body is touching. @warning Putting a body to sleep will put the entire island of bodies touching this body to sleep, which can be expensive and possibly unintuitive.

Set this body to be a bullet. A bullet does continuous collision detection against dynamic bodies (but not other bullets).

Set this body to have fixed rotation. This causes the mass to be reset in all cases.

Adjust the gravity scale. Normally this is set in BodyDef before creation. @see BodyDef::gravityScale

Adjust the linear damping. Normally this is set in BodyDef before creation.

Set the linear velocity of a body. Usually in meters per second.

Override the body's mass properties. Normally this is computed automatically using the shape geometry and density. This information is lost if a shape is added or removed or if the body type changes.

Set the body name. Up to 32 characters excluding 0 termination.

Set the sleep threshold, usually in meters per second

Set the velocity to reach the given transform after a given time step. The result will be close but maybe not exact. This is meant for kinematic bodies. The target is not applied if the velocity would be below the sleep threshold. This will automatically wake the body if asleep.

Set the world transform of a body. This acts as a teleport and is fairly expensive. @note Generally you should create a body with then intended transform. @see BodyDef::position and BodyDef::angle

Change the body type. This is an expensive operation. This automatically updates the mass properties regardless of the automatic mass setting.

Set the user data for a body

Get the chain friction

Get the chain material

Get the chain restitution

Get the number of segments on this chain

Fill a user array with chain segment shape ids up to the specified capacity. Returns the actual number of segments returned.

Get the world that owns this chain shape

Chain identifier validation. Provides validation for up to 64K allocations.

Set the chain friction @see b2ChainDef::friction

Set the chain material @see b2ChainDef::material

Set the chain restitution (bounciness) @see b2ChainDef::restitution

Component-wise clamp vector v into the range [a, b]

@return a f32 clamped between a lower and upper bound

@return an integer clamped between a lower and upper bound

Compute the contact manifold between a capsule and circle

Compute the contact manifold between a capsule and circle

Compute the contact manifold between an segment and a capsule

Compute the contact manifold between a chain segment and a circle

Compute the contact manifold between a chain segment and a rounded polygon

Compute the contact manifold between two circles

Compute the contact manifold between a polygon and capsule

Compute the contact manifold between a polygon and a circle

Compute the contact manifold between two polygons

Compute the contact manifold between an segment and a capsule

Compute the contact manifold between an segment and a circle

Compute the contact manifold between an segment and a polygon

Compute the angular velocity necessary to rotate between two rotations over a give time @param q1 initial rotation @param q2 final rotation @param inv_h inverse time step

Compute the bounding box of a transformed capsule

Compute mass properties of a capsule

Compute the bounding box of a transformed circle

Compute mass properties of a circle

Compute the convex hull of a set of points. Returns an empty hull if it fails. Some failure cases: - all points very close together - all points on a line - less than 3 points - more than MAX_POLYGON_VERTICES points This welds close points and removes collinear points. @warning Do not modify a hull once it has been computed

Compute the bounding box of a transformed polygon

Compute mass properties of a polygon

Compute the rotation between two unit vectors

Compute the bounding box of a transformed line segment

Create a rigid body given a definition. No reference to the definition is retained. So you can create the definition on the stack and pass it as a pointer. @code{.odin} body_def := b2.DefaultBodyDef() my_body_id =: b2.CreateBody(my_world_id, body_def) @endcode @warning This function is locked during callbacks.

Create a capsule shape and attach it to a body. The shape definition and geometry are fully cloned. Contacts are not created until the next time step. @return the shape id for accessing the shape

Create a chain shape @see b2ChainDef for details

Create a circle shape and attach it to a body. The shape definition and geometry are fully cloned. Contacts are not created until the next time step. @return the shape id for accessing the shape

Create a distance joint @see b2DistanceJointDef for details

Create a filter joint. @see b2FilterJointDef for details

Create a motor joint @see b2MotorJointDef for details

Create a mouse joint @see b2MouseJointDef for details

Create a polygon shape and attach it to a body. The shape definition and geometry are fully cloned. Contacts are not created until the next time step. @return the shape id for accessing the shape

Create a prismatic (slider) joint. @see b2PrismaticJointDef for details

Create a revolute joint @see b2RevoluteJointDef for details

Create a line segment shape and attach it to a body. The shape definition and geometry are fully cloned. Contacts are not created until the next time step. @return the shape id for accessing the shape

Create a weld joint @see b2WeldJointDef for details

Create a wheel joint @see b2WheelJointDef for details

Create a world for rigid body simulation. A world contains bodies, shapes, and constraints. You make create up to 128 worlds. Each world is completely independent and may be simulated in parallel. @return the world id.

Vector cross product. In 2D this yields a scalar.

Perform the cross product on a scalar and a vector. In 2D this produces a vector.

Perform the cross product on a vector and a scalar. In 2D this produces a vector.

Use this to initialize your body definition @ingroup body

Use this to initialize your chain definition @ingroup shape

Use this to initialize your drawing interface. This allows you to implement a sub-set of the drawing functions.

Use this to initialize your joint definition @ingroup distance_joint

Use this to initialize your explosion definition @ingroup world

Use this to initialize your filter @ingroup shape

Use this to initialize your joint definition @ingroup filter_joint

Use this to initialize your joint definition @ingroup motor_joint

Use this to initialize your joint definition @ingroup mouse_joint

Use this to initialize your joint definition @ingroupd prismatic_joint

Use this to initialize your query filter @ingroup shape

Use this to initialize your joint definition. @ingroup revolute_joint

Use this to initialize your shape definition @ingroup shape

Use this to initialize your surface material @ingroup shape

Use this to initialize your joint definition @ingroup weld_joint

Use this to initialize your joint definition @ingroup wheel_joint

Use this to initialize your world definition @ingroup world

Destroy a rigid body given an id. This destroys all shapes and joints attached to the body. Do not keep references to the associated shapes and joints.

Destroy a chain shape

Destroy a joint

Destroy a shape. You may defer the body mass update which can improve performance if several shapes on a body are destroyed at once. @see b2Body_ApplyMassFromShapes

Destroy a world

Get the distance between two points

Enable joint limit. The limit only works if the joint spring is enabled. Otherwise the joint is rigid and the limit has no effect.

Enable/disable the distance joint motor

Enable/disable the distance joint spring. When disabled the distance joint is rigid.

Get the current length of a distance joint

Get the rest length of a distance joint

Get the distance joint maximum length

Get the distance joint maximum motor force, usually in newtons

Get the distance joint minimum length

Get the distance joint current motor force, usually in newtons

Get the distance joint motor speed, usually in meters per second

Get the spring damping ratio

Get the spring Hertz

Is the distance joint limit enabled?

Is the distance joint motor enabled?

Is the distance joint spring enabled?

Set the rest length of a distance joint @param jointId The id for a distance joint @param length The new distance joint length

Set the minimum and maximum length parameters of a distance joint

Set the distance joint maximum motor force, usually in newtons

Set the distance joint motor speed, usually in meters per second

Set the spring damping ratio, non-dimensional

Set the spring stiffness in Hertz

Get the distance squared between points

Vector dot product

Constructing the tree initializes the node pool.

Create a proxy. Provide an AABB and a userData value.

Destroy the tree, freeing the node pool.

Destroy a proxy. This asserts if the id is invalid.

Enlarge a proxy and enlarge ancestors as necessary.

Get the AABB of a proxy

Get the ratio of the sum of the node areas to the root area.

Get the number of bytes used by this tree

Get the category bits on a proxy.

Get the height of the binary tree.

Get the number of proxies created

Get the bounding box that contains the entire tree

Get proxy user data

Move a proxy to a new AABB by removing and reinserting into the tree.

Query an AABB for overlapping proxies. The callback class is called for each proxy that overlaps the supplied AABB. @return performance data

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. Bit-wise filtering using mask bits can greatly improve performance in some scenarios. However, this filtering may be approximate, so the user should still apply filtering to results. @param tree the dynamic tree to ray cast @param input the ray cast input data. The ray extends from p1 to p1 + maxFraction * (p2 - p1) @param maskBits mask bit hint: `bool accept = (maskBits & node->categoryBits) != 0;` @param callback a callback class that is called for each proxy that is hit by the ray @param context user context that is passed to the callback @return performance data

Rebuild the tree while retaining subtrees that haven't changed. Returns the number of boxes sorted.

Modify the category bits on a proxy. This is an expensive operation.

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. @param tree the dynamic tree to ray cast @param input the ray cast input data. The ray extends from p1 to p1 + maxFraction * (p2 - p1). @param maskBits filter bits: `bool accept = (maskBits & node->categoryBits) != 0 ---` @param callback a callback class that is called for each proxy that is hit by the shape @param context user context that is passed to the callback @return performance data

Validate this tree. For testing.

Validate this tree has no enlarged AABBs. For testing.

@return the total bytes allocated by Box2D

Get the inverse of a 2-by-2 matrix

Get the current length units per meter.

Get the milliseconds passed from an initial tick value.

Get the milliseconds passed from an initial tick value. Resets the passed in value to the current tick value.

Evaluate the transform sweep at a specific time.

Get the absolute number of system ticks. The value is platform specific.

Simple djb2 hash function for determinism testing.

/ Compare two ids for equality. Doesn't work for b2WorldId.

Integration rotation from angular velocity @param q1 initial rotation @param deltaAngle the angular displacement in radians

Transpose multiply two rotations: qT * r

Creates a transform that converts a local point in frame B to a local point in frame A. v2 = A.q' * (B.q * v1 + B.p - A.p) = A.q' * B.q * v1 + A.q' * (B.p - A.p)

Inverse rotate a vector

Inverse transform a point (e.g. world space to local space)

/ Macro to determine if any id is non-null.

/ Macro to determine if any id is null.

Is this rotation normalized?

Is this a valid bounding box? Not Nan or infinity. Upper bound greater than or equal to lower bound.

Is this a valid plane? Normal is a unit vector. Not Nan or infinity.

Validate ray cast input data (NaN, etc)

Get the current angular separation error for this joint. Does not consider admissible movement. Usually in meters.

Get body A id on a joint

Get body B id on a joint

Is collision allowed between connected bodies?

Get the current constraint force for this joint. Usually in Newtons.

Get the current constraint torque for this joint. Usually in Newton * meters.

Get the joint constraint tuning. Advanced feature.

Get the current linear separation error for this joint. Does not consider admissible movement. Usually in meters.

Get the local anchor on bodyA

Get the local anchor on bodyB

Get the local axis on bodyA (prismatic and wheel)

Get the joint reference angle in radians (revolute, prismatic, and weld)

Get the joint type

Get the user data on a joint

Get the world that owns this joint

Joint identifier validation. Provides validation for up to 64K allocations.

Toggle collision between connected bodies

Set the joint constraint tuning. Advanced feature. @param jointId the joint @param hertz the stiffness in Hertz (cycles per second) @param dampingRatio the non-dimensional damping ratio (one for critical damping)

Set the local anchor on bodyA

Set the local anchor on bodyB

Set the local axis on bodyA (prismatic and wheel)

Set the joint reference angle in radians, must be in [-pi,pi]. (revolute, prismatic, and weld)

Set the user data on a joint

Wake the bodies connect to this joint

Get a left pointing perpendicular vector. Equivalent to b2CrossSV(1, v)

Get the length of this vector (the norm)

Get the length squared of this vector

Vector linear interpolation https://fgiesen.wordpress.com/2012/08/15/linear-interpolation-past-present-and-future/

Load a u32 into a world id.

Compute the bounding box of an array of circles

Make a box (rectangle) polygon, bypassing the need for a convex hull.

Make an offset box, bypassing the need for a convex hull.

Make an offset convex polygon from a convex hull. This will assert if the hull is not valid. @warning Do not manually fill in the hull data, it must come directly from b2ComputeHull

Make a proxy with a transform. This is a deep copy of the points.

Make an offset rounded box, bypassing the need for a convex hull.

Make an offset convex polygon from a convex hull. This will assert if the hull is not valid. @warning Do not manually fill in the hull data, it must come directly from b2ComputeHull

Make a convex polygon from a convex hull. This will assert if the hull is not valid. @warning Do not manually fill in the hull data, it must come directly from b2ComputeHull

Make a proxy for use in overlap, shape cast, and related functions. This is a deep copy of the points.

Make a rotation using an angle in radians

Make a rounded box, bypassing the need for a convex hull.

Make a square polygon, bypassing the need for a convex hull.

Component-wise maximum vector

@return the maximum of two floats

@return the maximum of two integers

Component-wise minimum vector

@return the minimum of two floats

@return the minimum of two integers

Get the motor joint angular offset target in radians

Get the motor joint correction factor, usually in [0, 1]

Get the motor joint linear offset target

Get the motor joint maximum force, usually in newtons

Get the motor joint maximum torque, usually in newton-meters

Set the motor joint angular offset target in radians. This angle will be unwound so the motor will drive along the shortest arc.

Set the motor joint correction factor, usually in [0, 1]

Set the motor joint linear offset target

Set the motor joint maximum force, usually in newtons

Set the motor joint maximum torque, usually in newton-meters

Get the mouse joint maximum force, usually in newtons

Get the mouse joint damping ratio, non-dimensional

Get the mouse joint spring stiffness in Hertz

Get the mouse joint target

Set the mouse joint maximum force, usually in newtons

Set the mouse joint spring damping ratio, non-dimensional

Set the mouse joint spring stiffness in Hertz

Set the mouse joint target

Component-wise multiplication

a + s * b

Multiply a 2-by-2 matrix times a 2D vector

Multiply two rotations: q * r

a - s * b

Multiply a scalar and vector

Multiply two transforms. If the result is applied to a point p local to frame B, the transform would first convert p to a point local to frame A, then into a point in the world frame. 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

Vector negation

Normalized linear interpolation https://fgiesen.wordpress.com/2012/08/15/linear-interpolation-past-present-and-future/ https://web.archive.org/web/20170825184056/http://number-none.com/product/Understanding%20Slerp,%20Then%20Not%20Using%20It/

Normalize rotation

Signed separation of a point from a plane

Test a point for overlap with a capsule in local space

Test a point for overlap with a circle in local space

Test a point for overlap with a convex polygon in local space

Enable/disable a prismatic joint limit

Enable/disable a prismatic joint motor

Enable/disable the joint spring.

Get the prismatic joint lower limit

Get the prismatic joint maximum motor force, usually in newtons

Get the prismatic joint current motor force, usually in newtons

Get the prismatic joint motor speed, usually in meters per second

Get the current joint translation speed, usually in meters per second.

Get the prismatic spring damping ratio (non-dimensional)

Get the prismatic joint stiffness in Hertz

Get the prismatic joint sprint target translation, usually in meters

Get the current joint translation, usually in meters.

Get the prismatic joint upper limit

Is the prismatic joint limit enabled?

Is the prismatic joint motor enabled?

Is the prismatic joint spring enabled or not?

Set the prismatic joint limits

Set the prismatic joint maximum motor force, usually in newtons

Set the prismatic joint motor speed, usually in meters per second

Set the prismatic joint damping ratio (non-dimensional)

Set the prismatic joint stiffness in Hertz. This should usually be less than a quarter of the simulation rate. For example, if the simulation runs at 60Hz then the joint stiffness should be 15Hz or less.

Set the prismatic joint sprint target angle, usually in meters

Ray cast versus capsule in shape local space. Initial overlap is treated as a miss.

Ray cast versus circle in shape local space. Initial overlap is treated as a miss.

Ray cast versus polygon in shape local space. Initial overlap is treated as a miss.

Ray cast versus segment in shape local space. Optionally treat the segment as one-sided with hits from the left side being treated as a miss.

relative angle between b and a (rot_b * inv(rot_a))

Enable/disable the revolute joint limit

Enable/disable a revolute joint motor

Enable/disable the revolute joint spring

Get the revolute joint current angle in radians relative to the reference angle @see b2RevoluteJointDef::referenceAngle

Get the revolute joint lower limit in radians

Get the revolute joint maximum motor torque, usually in newton-meters

Get the revolute joint motor speed in radians per second

Get the revolute joint current motor torque, usually in newton-meters

Get the revolute joint spring damping ratio, non-dimensional

Get the revolute joint spring stiffness in Hertz

Get the revolute joint spring target angle, radians

Get the revolute joint upper limit in radians

Is the revolute joint limit enabled?

Is the revolute joint motor enabled?

Is the revolute spring enabled?

Set the revolute joint limits in radians. It is expected that lower <= upper and that -0.99 * B2_PI <= lower && upper <= -0.99 * B2_PI.

Set the revolute joint maximum motor torque, usually in newton-meters

Set the revolute joint motor speed in radians per second

Set the revolute joint spring damping ratio, non-dimensional

Set the revolute joint spring stiffness in Hertz

Set the revolute joint spring target angle, radians

Get a right pointing perpendicular vector. Equivalent to b2CrossVS(v, 1)

Get the angle in radians in the range [-pi, pi]

Get the x-axis

Get the y-axis

Rotate a vector

Compute the distance between two line segments, clamping at the end points if needed.

This allows the user to override the allocation functions. These should be set during application startup.

Override the default assert callback @param assertFcn a non-null assert callback