box2d.h

// SPDX-FileCopyrightText: 2026 Erin Catto
// SPDX-License-Identifier: MIT
 
#pragma once
 
#include "base.h"
#include "collision.h"
#include "constants.h"
#include "id.h"
#include "types.h"
 
#include <stdbool.h>
 
#if defined( BOX2D_DOUBLE_PRECISION )
// Force a link error if the application and library disagree on precision. A float app linking
// a double precision library, or the reverse, gets one unresolved external on the first call
// every program makes. CMake consumers inherit the define and cannot mismatch.
#define b2CreateWorld b2CreateWorldDoublePrecision
#endif


B2_API b2WorldId b2CreateWorld( const b2WorldDef* def );

B2_API void b2DestroyWorld( b2WorldId worldId );

B2_API bool b2World_IsValid( b2WorldId id );

B2_API void b2World_Step( b2WorldId worldId, float timeStep, int subStepCount );

B2_API void b2World_Draw( b2WorldId worldId, b2DebugDraw* draw );

B2_API b2AABB b2World_GetBounds( b2WorldId worldId );

B2_API b2BodyEvents b2World_GetBodyEvents( b2WorldId worldId );

B2_API b2SensorEvents b2World_GetSensorEvents( b2WorldId worldId );

B2_API b2ContactEvents b2World_GetContactEvents( b2WorldId worldId );

B2_API b2JointEvents b2World_GetJointEvents( b2WorldId worldId );

B2_API b2TreeStats b2World_OverlapAABB( b2WorldId worldId, b2Pos origin, b2AABB aabb,
                                        b2QueryFilter filter, b2OverlapResultCallbackFcn* fcn,
                                        void* context );

B2_API b2TreeStats b2World_OverlapShape( b2WorldId worldId, b2Pos origin, const b2ShapeProxy* proxy,
                                         b2QueryFilter filter, b2OverlapResultCallbackFcn* fcn,
                                         void* context );

B2_API b2TreeStats b2World_CastRay( b2WorldId worldId, b2Pos origin, b2Vec2 translation,
                                    b2QueryFilter filter, b2CastResultCallbackFcn* fcn,
                                    void* context );

B2_API b2RayResult b2World_CastRayClosest( b2WorldId worldId, b2Pos origin, b2Vec2 translation,
                                           b2QueryFilter filter );

B2_API b2TreeStats b2World_CastShape( b2WorldId worldId, b2Pos origin, const b2ShapeProxy* proxy,
                                      b2Vec2 translation, b2QueryFilter filter,
                                      b2CastResultCallbackFcn* fcn, void* context );

B2_API float b2World_CastMover( b2WorldId worldId, b2Pos origin, const b2Capsule* mover,
                                b2Vec2 translation, b2QueryFilter filter );

B2_API void b2World_CollideMover( b2WorldId worldId, b2Pos origin, const b2Capsule* mover,
                                  b2QueryFilter filter, b2PlaneResultCallbackFcn* fcn,
                                  void* context );

B2_API void b2World_EnableSleeping( b2WorldId worldId, bool flag );

B2_API bool b2World_IsSleepingEnabled( b2WorldId worldId );

B2_API void b2World_EnableContinuous( b2WorldId worldId, bool flag );

B2_API bool b2World_IsContinuousEnabled( b2WorldId worldId );

B2_API void b2World_SetRestitutionThreshold( b2WorldId worldId, float value );

B2_API float b2World_GetRestitutionThreshold( b2WorldId worldId );

B2_API void b2World_SetRestitutionIterations( b2WorldId worldId, int iterations );

B2_API int b2World_GetRestitutionIterations( b2WorldId worldId );

B2_API void b2World_EnableRestitutionPropagation( b2WorldId worldId, bool flag );

B2_API bool b2World_IsRestitutionPropagationEnabled( b2WorldId worldId );

B2_API void b2World_SetHitEventThreshold( b2WorldId worldId, float value );

B2_API float b2World_GetHitEventThreshold( b2WorldId worldId );

B2_API void b2World_SetCustomFilterCallback( b2WorldId worldId, b2CustomFilterCallbackFcn* fcn,
                                             void* context );

B2_API void b2World_SetPreSolveCallback( b2WorldId worldId, b2PreSolveCallbackFcn* preSolveFcn,
                                         b2PreContinuousCallbackFcn* preContinuousFcn,
                                         void* context );

B2_API void b2World_SetGravity( b2WorldId worldId, b2Vec2 gravity );

B2_API b2Vec2 b2World_GetGravity( b2WorldId worldId );

B2_API void b2World_Explode( b2WorldId worldId, const b2ExplosionDef* explosionDef );

B2_API void b2World_SetContactTuning( b2WorldId worldId, float hertz, float dampingRatio,
                                      float pushSpeed );

B2_API void b2World_GetContactTuning( b2WorldId worldId, float* hertz, float* dampingRatio,
                                      float* pushSpeed );

B2_API void b2World_SetContactRecycleDistance( b2WorldId worldId, float recycleDistance );

B2_API float b2World_GetContactRecycleDistance( b2WorldId worldId );

B2_API void b2World_SetMaxLinearSpeed( b2WorldId worldId, float maximumLinearSpeed );

B2_API float b2World_GetMaxLinearSpeed( b2WorldId worldId );

B2_API void b2World_EnableWarmStarting( b2WorldId worldId, bool flag );

B2_API bool b2World_IsWarmStartingEnabled( b2WorldId worldId );

B2_API void b2World_EnableSSE2Fallback( b2WorldId worldId, bool flag );

B2_API int b2World_GetAwakeBodyCount( b2WorldId worldId );

B2_API b2Profile b2World_GetProfile( b2WorldId worldId );

B2_API b2Counters b2World_GetCounters( b2WorldId worldId );

B2_API b2Capacity b2World_GetMaxCapacity( b2WorldId worldId );

B2_API void b2World_SetUserData( b2WorldId worldId, void* userData );

B2_API void* b2World_GetUserData( b2WorldId worldId );

B2_API void b2World_SetFrictionCallback( b2WorldId worldId, b2FrictionCallbackFcn* callback );

B2_API void b2World_SetRestitutionCallback( b2WorldId worldId, b2RestitutionCallbackFcn* callback );

B2_API void b2World_SetWorkerCount( b2WorldId worldId, int count );

B2_API int b2World_GetWorkerCount( b2WorldId worldId );

B2_API void b2World_DumpMemoryStats( b2WorldId worldId );

B2_API void b2World_RebuildStaticTree( b2WorldId worldId );

B2_API uint64_t b2World_GetStateHash( b2WorldId worldId );



typedef struct b2Recording b2Recording;

B2_API b2Recording* b2CreateRecording( int byteCapacity );

B2_API void b2DestroyRecording( b2Recording* recording );

B2_API const uint8_t* b2Recording_GetData( const b2Recording* recording );

B2_API int b2Recording_GetSize( const b2Recording* recording );

B2_API void b2World_StartRecording( b2WorldId worldId, b2Recording* recording );

B2_API void b2World_StopRecording( b2WorldId worldId );

B2_API bool b2Recording_SaveToFile( const b2Recording* recording, const char* path );

B2_API b2Recording* b2CreateRecordingFromFile( const char* path );



B2_API int b2World_GetSnapshot( b2WorldId worldId, uint8_t* image, int capacity );

B2_API bool b2World_RestoreFromSnapshot( b2WorldId worldId, const uint8_t* image, int size );

B2_API b2WorldId b2CreateWorldFromSnapshot( const uint8_t* image, int size, int workerCount );



B2_API b2BodyId b2CreateBody( b2WorldId worldId, const b2BodyDef* def );

B2_API void b2DestroyBody( b2BodyId bodyId );

B2_API bool b2Body_IsValid( b2BodyId id );

B2_API b2BodyType b2Body_GetType( b2BodyId bodyId );

B2_API void b2Body_SetType( b2BodyId bodyId, b2BodyType type );

B2_API void b2Body_SetName( b2BodyId bodyId, const char* name );

B2_API const char* b2Body_GetName( b2BodyId bodyId );

B2_API void b2Body_SetUserData( b2BodyId bodyId, void* userData );

B2_API void* b2Body_GetUserData( b2BodyId bodyId );

B2_API b2Pos b2Body_GetPosition( b2BodyId bodyId );

B2_API b2Rot b2Body_GetRotation( b2BodyId bodyId );

B2_API b2WorldTransform b2Body_GetTransform( b2BodyId bodyId );

B2_API void b2Body_SetTransform( b2BodyId bodyId, b2Pos position, b2Rot rotation );

B2_API b2Vec2 b2Body_GetLocalPoint( b2BodyId bodyId, b2Pos worldPoint );

B2_API b2Pos b2Body_GetWorldPoint( b2BodyId bodyId, b2Vec2 localPoint );

B2_API b2Vec2 b2Body_GetLocalVector( b2BodyId bodyId, b2Vec2 worldVector );

B2_API b2Vec2 b2Body_GetWorldVector( b2BodyId bodyId, b2Vec2 localVector );

B2_API b2Vec2 b2Body_GetLinearVelocity( b2BodyId bodyId );

B2_API float b2Body_GetAngularVelocity( b2BodyId bodyId );

B2_API void b2Body_SetLinearVelocity( b2BodyId bodyId, b2Vec2 linearVelocity );

B2_API void b2Body_SetAngularVelocity( b2BodyId bodyId, float angularVelocity );

B2_API void b2Body_SetTargetTransform( b2BodyId bodyId, b2WorldTransform target, float timeStep,
                                       bool wake );

B2_API b2Vec2 b2Body_GetLocalPointVelocity( b2BodyId bodyId, b2Vec2 localPoint );

B2_API b2Vec2 b2Body_GetWorldPointVelocity( b2BodyId bodyId, b2Pos worldPoint );

B2_API void b2Body_ApplyForce( b2BodyId bodyId, b2Vec2 force, b2Pos point, bool wake );

B2_API void b2Body_ApplyForceToCenter( b2BodyId bodyId, b2Vec2 force, bool wake );

B2_API void b2Body_ApplyTorque( b2BodyId bodyId, float torque, bool wake );

B2_API void b2Body_ClearForces( b2BodyId bodyId );

B2_API void b2Body_ApplyLinearImpulse( b2BodyId bodyId, b2Vec2 impulse, b2Pos point, bool wake );

B2_API void b2Body_ApplyLinearImpulseToCenter( b2BodyId bodyId, b2Vec2 impulse, bool wake );

B2_API void b2Body_ApplyAngularImpulse( b2BodyId bodyId, float impulse, bool wake );

B2_API float b2Body_GetMass( b2BodyId bodyId );

B2_API float b2Body_GetRotationalInertia( b2BodyId bodyId );

B2_API b2Vec2 b2Body_GetLocalCenter( b2BodyId bodyId );

B2_API b2Pos b2Body_GetWorldCenter( b2BodyId bodyId );

B2_API void b2Body_SetMassData( b2BodyId bodyId, b2MassData massData );

B2_API b2MassData b2Body_GetMassData( b2BodyId bodyId );

B2_API void b2Body_UpdateMassFromShapes( b2BodyId bodyId );

B2_API void b2Body_SetLinearDamping( b2BodyId bodyId, float linearDamping );

B2_API float b2Body_GetLinearDamping( b2BodyId bodyId );

B2_API void b2Body_SetAngularDamping( b2BodyId bodyId, float angularDamping );

B2_API float b2Body_GetAngularDamping( b2BodyId bodyId );

B2_API void b2Body_SetGravityScale( b2BodyId bodyId, float gravityScale );

B2_API float b2Body_GetGravityScale( b2BodyId bodyId );

B2_API bool b2Body_IsAwake( b2BodyId bodyId );

B2_API void b2Body_SetAwake( b2BodyId bodyId, bool awake );

B2_API void b2Body_WakeTouching( b2BodyId bodyId );

B2_API void b2Body_EnableSleeping( b2BodyId bodyId, bool enableSleep );

B2_API bool b2Body_IsSleepingEnabled( b2BodyId bodyId );

B2_API void b2Body_SetSleepThreshold( b2BodyId bodyId, float sleepThreshold );

B2_API float b2Body_GetSleepThreshold( b2BodyId bodyId );

B2_API void b2Body_SetSafetyFactor( b2BodyId bodyId, float safetyFactor );

B2_API float b2Body_GetSafetyFactor( b2BodyId bodyId );

B2_API bool b2Body_IsEnabled( b2BodyId bodyId );

B2_API void b2Body_Disable( b2BodyId bodyId );

B2_API void b2Body_Enable( b2BodyId bodyId );

B2_API void b2Body_SetMotionLocks( b2BodyId bodyId, b2MotionLocks locks );

B2_API b2MotionLocks b2Body_GetMotionLocks( b2BodyId bodyId );

B2_API void b2Body_SetBullet( b2BodyId bodyId, bool flag );

B2_API bool b2Body_IsBullet( b2BodyId bodyId );

B2_API void b2Body_EnableContactRecycling( b2BodyId bodyId, bool flag );

B2_API bool b2Body_IsContactRecyclingEnabled( b2BodyId bodyId );

B2_API void b2Body_EnableContactEvents( b2BodyId bodyId, bool flag );

B2_API void b2Body_EnableHitEvents( b2BodyId bodyId, bool flag );

B2_API b2WorldId b2Body_GetWorld( b2BodyId bodyId );

B2_API int b2Body_GetShapeCount( b2BodyId bodyId );

B2_API int b2Body_GetShapes( b2BodyId bodyId, b2ShapeId* shapeArray, int capacity );

B2_API int b2Body_GetJointCount( b2BodyId bodyId );

B2_API int b2Body_GetJoints( b2BodyId bodyId, b2JointId* jointArray, int capacity );

B2_API int b2Body_GetContactCapacity( b2BodyId bodyId );

B2_API int b2Body_GetContactData( b2BodyId bodyId, b2ContactData* contactData, int capacity );

B2_API b2AABB b2Body_ComputeBounds( b2BodyId bodyId );

B2_API float b2Body_GetMinExtent( b2BodyId bodyId );

B2_API float b2Body_GetMaxExtent( b2BodyId bodyId );

B2_API float b2Body_GetMaxExtentFromOrigin( b2BodyId bodyId );



B2_API b2ShapeId b2CreateCircleShape( b2BodyId bodyId, const b2ShapeDef* def,
                                      const b2Circle* circle );

B2_API b2ShapeId b2CreateSegmentShape( b2BodyId bodyId, const b2ShapeDef* def,
                                       const b2Segment* segment );

B2_API b2ShapeId b2CreateChainSegmentShape( b2BodyId bodyId, const b2ShapeDef* def,
                                            const b2ChainSegment* chainSegment );

B2_API b2ShapeId b2CreateCapsuleShape( b2BodyId bodyId, const b2ShapeDef* def,
                                       const b2Capsule* capsule );

B2_API b2ShapeId b2CreatePolygonShape( b2BodyId bodyId, const b2ShapeDef* def,
                                       const b2Polygon* polygon );

B2_API void b2DestroyShape( b2ShapeId shapeId, bool updateBodyMass );

B2_API bool b2Shape_IsValid( b2ShapeId id );

B2_API b2ShapeType b2Shape_GetType( b2ShapeId shapeId );

B2_API b2BodyId b2Shape_GetBody( b2ShapeId shapeId );

B2_API b2WorldId b2Shape_GetWorld( b2ShapeId shapeId );

B2_API bool b2Shape_IsSensor( b2ShapeId shapeId );

B2_API void b2Shape_SetUserData( b2ShapeId shapeId, void* userData );

B2_API void* b2Shape_GetUserData( b2ShapeId shapeId );

B2_API void b2Shape_SetDensity( b2ShapeId shapeId, float density, bool updateBodyMass );

B2_API float b2Shape_GetDensity( b2ShapeId shapeId );

B2_API void b2Shape_SetFriction( b2ShapeId shapeId, float friction );

B2_API float b2Shape_GetFriction( b2ShapeId shapeId );

B2_API void b2Shape_SetRestitution( b2ShapeId shapeId, float restitution );

B2_API float b2Shape_GetRestitution( b2ShapeId shapeId );

B2_API void b2Shape_SetUserMaterial( b2ShapeId shapeId, uint64_t material );

B2_API uint64_t b2Shape_GetUserMaterial( b2ShapeId shapeId );

B2_API void b2Shape_SetSurfaceMaterial( b2ShapeId shapeId,
                                        const b2SurfaceMaterial* surfaceMaterial );

B2_API b2SurfaceMaterial b2Shape_GetSurfaceMaterial( b2ShapeId shapeId );

B2_API b2Filter b2Shape_GetFilter( b2ShapeId shapeId );

B2_API void b2Shape_SetFilter( b2ShapeId shapeId, b2Filter filter );

B2_API void b2Shape_EnableSensorEvents( b2ShapeId shapeId, bool flag );

B2_API bool b2Shape_AreSensorEventsEnabled( b2ShapeId shapeId );

B2_API void b2Shape_EnableContactEvents( b2ShapeId shapeId, bool flag );

B2_API bool b2Shape_AreContactEventsEnabled( b2ShapeId shapeId );

B2_API void b2Shape_EnablePreSolveEvents( b2ShapeId shapeId, bool flag );

B2_API bool b2Shape_ArePreSolveEventsEnabled( b2ShapeId shapeId );

B2_API void b2Shape_EnableHitEvents( b2ShapeId shapeId, bool flag );

B2_API bool b2Shape_AreHitEventsEnabled( b2ShapeId shapeId );

B2_API bool b2Shape_TestPoint( b2ShapeId shapeId, b2Pos point );

B2_API b2WorldCastOutput b2Shape_CastRay( b2ShapeId shapeId, b2Pos origin, b2Vec2 translation );

B2_API b2Circle b2Shape_GetCircle( b2ShapeId shapeId );

B2_API b2Segment b2Shape_GetSegment( b2ShapeId shapeId );

B2_API b2ChainSegment b2Shape_GetChainSegment( b2ShapeId shapeId );

B2_API b2Capsule b2Shape_GetCapsule( b2ShapeId shapeId );

B2_API b2Polygon b2Shape_GetPolygon( b2ShapeId shapeId );

B2_API void b2Shape_SetCircle( b2ShapeId shapeId, const b2Circle* circle );

B2_API void b2Shape_SetCapsule( b2ShapeId shapeId, const b2Capsule* capsule );

B2_API void b2Shape_SetSegment( b2ShapeId shapeId, const b2Segment* segment );

B2_API void b2Shape_SetPolygon( b2ShapeId shapeId, const b2Polygon* polygon );

B2_API void b2Shape_SetChainSegment( b2ShapeId shapeId, const b2ChainSegment* chainSegment );

B2_API b2ChainId b2Shape_GetParentChain( b2ShapeId shapeId );

B2_API int b2Shape_GetContactCapacity( b2ShapeId shapeId );

B2_API int b2Shape_GetContactData( b2ShapeId shapeId, b2ContactData* contactData, int capacity );

B2_API int b2Shape_GetSensorCapacity( b2ShapeId shapeId );

B2_API int b2Shape_GetSensorData( b2ShapeId shapeId, b2ShapeId* visitorIds, int capacity );

B2_API b2AABB b2Shape_GetBounds( b2ShapeId shapeId );

B2_API b2MassData b2Shape_ComputeMassData( b2ShapeId shapeId );

B2_API b2Pos b2Shape_GetClosestPoint( b2ShapeId shapeId, b2Pos target );

B2_API void b2Shape_ApplyWind( b2ShapeId shapeId, b2Vec2 wind, float drag, float lift, bool wake );



B2_API b2ChainId b2CreateChain( b2BodyId bodyId, const b2ChainDef* def );

B2_API void b2DestroyChain( b2ChainId chainId );

B2_API b2WorldId b2Chain_GetWorld( b2ChainId chainId );

B2_API int b2Chain_GetSegmentCount( b2ChainId chainId );

B2_API int b2Chain_GetSegments( b2ChainId chainId, b2ShapeId* segmentArray, int capacity );

B2_API void b2Chain_SetAllSurfaceMaterials( b2ChainId chainId, const b2SurfaceMaterial* material );

B2_API void b2Chain_SetSurfaceMaterial( b2ChainId chainId, const b2SurfaceMaterial* material,
                                        int segmentIndex );

B2_API b2SurfaceMaterial b2Chain_GetSurfaceMaterial( b2ChainId chainId, int segmentIndex );

B2_API bool b2Chain_IsValid( b2ChainId id );



B2_API void b2DestroyJoint( b2JointId jointId );

B2_API bool b2Joint_IsValid( b2JointId id );

B2_API b2JointType b2Joint_GetType( b2JointId jointId );

B2_API b2BodyId b2Joint_GetBodyA( b2JointId jointId );

B2_API b2BodyId b2Joint_GetBodyB( b2JointId jointId );

B2_API b2WorldId b2Joint_GetWorld( b2JointId jointId );

B2_API void b2Joint_SetLocalFrameA( b2JointId jointId, b2Transform localFrame );

B2_API b2Transform b2Joint_GetLocalFrameA( b2JointId jointId );

B2_API void b2Joint_SetLocalFrameB( b2JointId jointId, b2Transform localFrame );

B2_API b2Transform b2Joint_GetLocalFrameB( b2JointId jointId );

B2_API void b2Joint_SetCollideConnected( b2JointId jointId, bool shouldCollide );

B2_API bool b2Joint_GetCollideConnected( b2JointId jointId );

B2_API void b2Joint_SetUserData( b2JointId jointId, void* userData );

B2_API void* b2Joint_GetUserData( b2JointId jointId );

B2_API void b2Joint_WakeBodies( b2JointId jointId );

B2_API b2Vec2 b2Joint_GetConstraintForce( b2JointId jointId );

B2_API float b2Joint_GetConstraintTorque( b2JointId jointId );

B2_API float b2Joint_GetLinearSeparation( b2JointId jointId );

B2_API float b2Joint_GetAngularSeparation( b2JointId jointId );

B2_API void b2Joint_SetConstraintTuning( b2JointId jointId, float hertz, float dampingRatio );

B2_API void b2Joint_GetConstraintTuning( b2JointId jointId, float* hertz, float* dampingRatio );

B2_API void b2Joint_SetForceThreshold( b2JointId jointId, float threshold );

B2_API float b2Joint_GetForceThreshold( b2JointId jointId );

B2_API void b2Joint_SetTorqueThreshold( b2JointId jointId, float threshold );

B2_API float b2Joint_GetTorqueThreshold( b2JointId jointId );


B2_API b2JointId b2CreateDistanceJoint( b2WorldId worldId, const b2DistanceJointDef* def );

B2_API void b2DistanceJoint_SetRestLength( b2JointId jointId, float length );

B2_API float b2DistanceJoint_GetRestLength( b2JointId jointId );

B2_API void b2DistanceJoint_EnableSpring( b2JointId jointId, bool enableSpring );

B2_API bool b2DistanceJoint_IsSpringEnabled( b2JointId jointId );

B2_API void b2DistanceJoint_SetSpringForceRange( b2JointId jointId, float lowerForce,
                                                 float upperForce );

B2_API void b2DistanceJoint_GetSpringForceRange( b2JointId jointId, float* lowerForce,
                                                 float* upperForce );

B2_API void b2DistanceJoint_SetSpringHertz( b2JointId jointId, float hertz );

B2_API void b2DistanceJoint_SetSpringDampingRatio( b2JointId jointId, float dampingRatio );

B2_API float b2DistanceJoint_GetSpringHertz( b2JointId jointId );

B2_API float b2DistanceJoint_GetSpringDampingRatio( b2JointId jointId );

B2_API float b2DistanceJoint_GetSpringForce( b2JointId jointId );

B2_API void b2DistanceJoint_EnableLimit( b2JointId jointId, bool enableLimit );

B2_API bool b2DistanceJoint_IsLimitEnabled( b2JointId jointId );

B2_API void b2DistanceJoint_SetLimits( b2JointId jointId, float minLength, float maxLength );

B2_API float b2DistanceJoint_GetLowerLimit( b2JointId jointId );

B2_API float b2DistanceJoint_GetUpperLimit( b2JointId jointId );

B2_API float b2DistanceJoint_GetCurrentLength( b2JointId jointId );

B2_API void b2DistanceJoint_EnableMotor( b2JointId jointId, bool enableMotor );

B2_API bool b2DistanceJoint_IsMotorEnabled( b2JointId jointId );

B2_API void b2DistanceJoint_SetTargetMotorSpeed( b2JointId jointId, float motorSpeed );

B2_API float b2DistanceJoint_GetTargetMotorSpeed( b2JointId jointId );

B2_API void b2DistanceJoint_SetMaxMotorForce( b2JointId jointId, float force );

B2_API float b2DistanceJoint_GetMaxMotorForce( b2JointId jointId );

B2_API float b2DistanceJoint_GetCurrentMotorForce( b2JointId jointId );



B2_API b2JointId b2CreateFilterJoint( b2WorldId worldId, const b2FilterJointDef* def );



B2_API b2JointId b2CreateMotorJoint( b2WorldId worldId, const b2MotorJointDef* def );

B2_API void b2MotorJoint_SetLinearVelocity( b2JointId jointId, b2Vec2 velocity );

B2_API b2Vec2 b2MotorJoint_GetLinearVelocity( b2JointId jointId );

B2_API void b2MotorJoint_SetAngularVelocity( b2JointId jointId, float velocity );

B2_API float b2MotorJoint_GetAngularVelocity( b2JointId jointId );

B2_API void b2MotorJoint_SetMaxVelocityForce( b2JointId jointId, float maxForce );

B2_API float b2MotorJoint_GetMaxVelocityForce( b2JointId jointId );

B2_API void b2MotorJoint_SetMaxVelocityTorque( b2JointId jointId, float maxTorque );

B2_API float b2MotorJoint_GetMaxVelocityTorque( b2JointId jointId );

B2_API void b2MotorJoint_SetLinearHertz( b2JointId jointId, float hertz );

B2_API float b2MotorJoint_GetLinearHertz( b2JointId jointId );

B2_API void b2MotorJoint_SetLinearDampingRatio( b2JointId jointId, float damping );

B2_API float b2MotorJoint_GetLinearDampingRatio( b2JointId jointId );

B2_API void b2MotorJoint_SetAngularHertz( b2JointId jointId, float hertz );

B2_API float b2MotorJoint_GetAngularHertz( b2JointId jointId );

B2_API void b2MotorJoint_SetAngularDampingRatio( b2JointId jointId, float damping );

B2_API float b2MotorJoint_GetAngularDampingRatio( b2JointId jointId );

B2_API void b2MotorJoint_SetMaxSpringForce( b2JointId jointId, float maxForce );

B2_API float b2MotorJoint_GetMaxSpringForce( b2JointId jointId );

B2_API void b2MotorJoint_SetMaxSpringTorque( b2JointId jointId, float maxTorque );

B2_API float b2MotorJoint_GetMaxSpringTorque( b2JointId jointId );



B2_API b2JointId b2CreateMoverJoint( b2WorldId worldId, const b2MoverJointDef* def );

B2_API void b2MoverJoint_SetLinearVelocity( b2JointId jointId, b2Vec2 velocity );

B2_API b2Vec2 b2MoverJoint_GetLinearVelocity( b2JointId jointId );

B2_API void b2MoverJoint_SetMaxVelocityForce( b2JointId jointId, b2Vec2 maxForce );

B2_API b2Vec2 b2MoverJoint_GetMaxVelocityForce( b2JointId jointId );



B2_API b2JointId b2CreatePogoJoint( b2WorldId worldId, const b2PogoJointDef* def );

B2_API void b2PogoJoint_SetRestLength( b2JointId jointId, float length );

B2_API float b2PogoJoint_GetRestLength( b2JointId jointId );

B2_API void b2PogoJoint_SetSpringHertz( b2JointId jointId, float hertz );

B2_API float b2PogoJoint_GetSpringHertz( b2JointId jointId );

B2_API void b2PogoJoint_SetSpringDampingRatio( b2JointId jointId, float dampingRatio );

B2_API float b2PogoJoint_GetSpringDampingRatio( b2JointId jointId );

B2_API float b2PogoJoint_GetCurrentLength( b2JointId jointId );

B2_API float b2PogoJoint_GetCurrentSpeed( b2JointId jointId );

B2_API float b2PogoJoint_GetImpulse( b2JointId jointId );



B2_API b2JointId b2CreatePrismaticJoint( b2WorldId worldId, const b2PrismaticJointDef* def );

B2_API void b2PrismaticJoint_EnableSpring( b2JointId jointId, bool enableSpring );

B2_API bool b2PrismaticJoint_IsSpringEnabled( b2JointId jointId );

B2_API void b2PrismaticJoint_SetSpringHertz( b2JointId jointId, float hertz );

B2_API float b2PrismaticJoint_GetSpringHertz( b2JointId jointId );

B2_API void b2PrismaticJoint_SetSpringDampingRatio( b2JointId jointId, float dampingRatio );

B2_API float b2PrismaticJoint_GetSpringDampingRatio( b2JointId jointId );

B2_API void b2PrismaticJoint_SetTargetTranslation( b2JointId jointId, float translation );

B2_API float b2PrismaticJoint_GetTargetTranslation( b2JointId jointId );

B2_API void b2PrismaticJoint_EnableLimit( b2JointId jointId, bool enableLimit );

B2_API bool b2PrismaticJoint_IsLimitEnabled( b2JointId jointId );

B2_API float b2PrismaticJoint_GetLowerLimit( b2JointId jointId );

B2_API float b2PrismaticJoint_GetUpperLimit( b2JointId jointId );

B2_API void b2PrismaticJoint_SetLimits( b2JointId jointId, float lower, float upper );

B2_API void b2PrismaticJoint_EnableMotor( b2JointId jointId, bool enableMotor );

B2_API bool b2PrismaticJoint_IsMotorEnabled( b2JointId jointId );

B2_API void b2PrismaticJoint_SetTargetMotorSpeed( b2JointId jointId, float motorSpeed );

B2_API float b2PrismaticJoint_GetTargetMotorSpeed( b2JointId jointId );

B2_API void b2PrismaticJoint_SetMaxMotorForce( b2JointId jointId, float force );

B2_API float b2PrismaticJoint_GetMaxMotorForce( b2JointId jointId );

B2_API float b2PrismaticJoint_GetCurrentTranslation( b2JointId jointId );

B2_API float b2PrismaticJoint_GetCurrentSpeed( b2JointId jointId );

B2_API float b2PrismaticJoint_GetCurrentMotorForce( b2JointId jointId );



B2_API b2JointId b2CreateRevoluteJoint( b2WorldId worldId, const b2RevoluteJointDef* def );

B2_API void b2RevoluteJoint_EnableSpring( b2JointId jointId, bool enableSpring );

B2_API bool b2RevoluteJoint_IsSpringEnabled( b2JointId jointId );

B2_API void b2RevoluteJoint_SetSpringHertz( b2JointId jointId, float hertz );

B2_API float b2RevoluteJoint_GetSpringHertz( b2JointId jointId );

B2_API void b2RevoluteJoint_SetSpringDampingRatio( b2JointId jointId, float dampingRatio );

B2_API float b2RevoluteJoint_GetSpringDampingRatio( b2JointId jointId );

B2_API void b2RevoluteJoint_SetTargetAngle( b2JointId jointId, float angle );

B2_API float b2RevoluteJoint_GetTargetAngle( b2JointId jointId );

B2_API void b2RevoluteJoint_EnableLimit( b2JointId jointId, bool enableLimit );

B2_API bool b2RevoluteJoint_IsLimitEnabled( b2JointId jointId );

B2_API float b2RevoluteJoint_GetLowerLimit( b2JointId jointId );

B2_API float b2RevoluteJoint_GetUpperLimit( b2JointId jointId );

B2_API void b2RevoluteJoint_SetLimits( b2JointId jointId, float lower, float upper );

B2_API void b2RevoluteJoint_EnableMotor( b2JointId jointId, bool enableMotor );

B2_API bool b2RevoluteJoint_IsMotorEnabled( b2JointId jointId );

B2_API void b2RevoluteJoint_SetTargetMotorSpeed( b2JointId jointId, float motorSpeed );

B2_API float b2RevoluteJoint_GetTargetMotorSpeed( b2JointId jointId );

B2_API void b2RevoluteJoint_SetMaxMotorTorque( b2JointId jointId, float torque );

B2_API float b2RevoluteJoint_GetMaxMotorTorque( b2JointId jointId );

B2_API float b2RevoluteJoint_GetCurrentAngle( b2JointId jointId );

B2_API float b2RevoluteJoint_GetCurrentSpeed( b2JointId jointId );

B2_API float b2RevoluteJoint_GetCurrentMotorTorque( b2JointId jointId );



B2_API b2JointId b2CreateWeldJoint( b2WorldId worldId, const b2WeldJointDef* def );

B2_API void b2WeldJoint_SetLinearHertz( b2JointId jointId, float hertz );

B2_API float b2WeldJoint_GetLinearHertz( b2JointId jointId );

B2_API void b2WeldJoint_SetLinearDampingRatio( b2JointId jointId, float dampingRatio );

B2_API float b2WeldJoint_GetLinearDampingRatio( b2JointId jointId );

B2_API void b2WeldJoint_SetAngularHertz( b2JointId jointId, float hertz );

B2_API float b2WeldJoint_GetAngularHertz( b2JointId jointId );

B2_API void b2WeldJoint_SetAngularDampingRatio( b2JointId jointId, float dampingRatio );

B2_API float b2WeldJoint_GetAngularDampingRatio( b2JointId jointId );



B2_API b2JointId b2CreateWheelJoint( b2WorldId worldId, const b2WheelJointDef* def );

B2_API void b2WheelJoint_EnableSpring( b2JointId jointId, bool enableSpring );

B2_API bool b2WheelJoint_IsSpringEnabled( b2JointId jointId );

B2_API void b2WheelJoint_SetSpringHertz( b2JointId jointId, float hertz );

B2_API float b2WheelJoint_GetSpringHertz( b2JointId jointId );

B2_API void b2WheelJoint_SetSpringDampingRatio( b2JointId jointId, float dampingRatio );

B2_API float b2WheelJoint_GetSpringDampingRatio( b2JointId jointId );

B2_API void b2WheelJoint_EnableLimit( b2JointId jointId, bool enableLimit );

B2_API bool b2WheelJoint_IsLimitEnabled( b2JointId jointId );

B2_API float b2WheelJoint_GetLowerLimit( b2JointId jointId );

B2_API float b2WheelJoint_GetUpperLimit( b2JointId jointId );

B2_API void b2WheelJoint_SetLimits( b2JointId jointId, float lower, float upper );

B2_API void b2WheelJoint_EnableMotor( b2JointId jointId, bool enableMotor );

B2_API bool b2WheelJoint_IsMotorEnabled( b2JointId jointId );

B2_API void b2WheelJoint_SetTargetMotorSpeed( b2JointId jointId, float motorSpeed );

B2_API float b2WheelJoint_GetTargetMotorSpeed( b2JointId jointId );

B2_API void b2WheelJoint_SetMaxMotorTorque( b2JointId jointId, float torque );

B2_API float b2WheelJoint_GetMaxMotorTorque( b2JointId jointId );

B2_API float b2WheelJoint_GetCurrentMotorTorque( b2JointId jointId );




B2_API bool b2Contact_IsValid( b2ContactId id );

B2_API b2ContactData b2Contact_GetData( b2ContactId contactId );



B2_API bool b2ValidateRecording( const void* data, int size, int workerCount );

B2_API b2Replay* b2CreateReplay( const void* data, int size, int workerCount );

B2_API void b2DestroyReplay( b2Replay* player );

B2_API bool b2Replay_StepFrame( b2Replay* player );

B2_API b2WorldId b2Replay_GetWorldId( const b2Replay* player );

B2_API void b2Replay_Restart( b2Replay* player );

B2_API void b2Replay_SeekFrame( b2Replay* player, int targetFrame );

B2_API int b2Replay_GetFrame( const b2Replay* player );

B2_API b2ReplayInfo b2Replay_GetInfo( const b2Replay* player );

B2_API bool b2Replay_IsAtEnd( const b2Replay* player );

B2_API bool b2Replay_HasDiverged( const b2Replay* player );

B2_API int b2Replay_GetDivergeFrame( const b2Replay* player );

B2_API void b2Replay_SetKeyframePolicy( b2Replay* player, size_t budgetBytes,
                                        int minIntervalFrames );

B2_API size_t b2Replay_GetKeyframeBudget( const b2Replay* player );

B2_API int b2Replay_GetKeyframeMinInterval( const b2Replay* player );

B2_API int b2Replay_GetKeyframeInterval( const b2Replay* player );

B2_API size_t b2Replay_GetKeyframeBytes( const b2Replay* player );

B2_API void b2Replay_DrawFrameQueries( b2Replay* player, b2DebugDraw* draw, int queryIndex );

B2_API int b2Replay_GetFrameQueryCount( const b2Replay* player );

B2_API b2ReplayQueryInfo b2Replay_GetFrameQuery( const b2Replay* player, int index );

B2_API b2ReplayQueryHit b2Replay_GetFrameQueryHit( const b2Replay* player, int queryIndex,
                                                   int hitIndex );

B2_API int b2Replay_GetBodyCount( const b2Replay* player );

B2_API b2BodyId b2Replay_GetBodyId( const b2Replay* player, int index );