box3d.h

// SPDX-FileCopyrightText: 2025 Erin Catto
// SPDX-License-Identifier: MIT
 
#pragma once
 
#include "base.h"
#include "collision.h"
#include "id.h"
#include "math_functions.h"
#include "types.h"
 
#include <stdbool.h>

 
#if defined( BOX3D_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 b3CreateWorld b3CreateWorldDoublePrecision
#endif

B3_API b3WorldId b3CreateWorld( const b3WorldDef* def );

B3_API void b3DestroyWorld( b3WorldId worldId );

B3_API int b3GetWorldCount( void );

B3_API int b3GetMaxWorldCount( void );

B3_API bool b3World_IsValid( b3WorldId id );

B3_API void b3World_Step( b3WorldId worldId, float timeStep, int subStepCount );

B3_API void b3World_Draw( b3WorldId worldId, b3DebugDraw* draw, uint64_t maskBits );

B3_API b3AABB b3World_GetBounds( b3WorldId worldId );

B3_API b3BodyEvents b3World_GetBodyEvents( b3WorldId worldId );

B3_API b3SensorEvents b3World_GetSensorEvents( b3WorldId worldId );

B3_API b3ContactEvents b3World_GetContactEvents( b3WorldId worldId );

B3_API b3JointEvents b3World_GetJointEvents( b3WorldId worldId );

B3_API b3TreeStats b3World_OverlapAABB( b3WorldId worldId, b3AABB aabb, b3QueryFilter filter, b3OverlapResultFcn* fcn,
                                        void* context );

B3_API b3TreeStats b3World_OverlapShape( b3WorldId worldId, b3Pos origin, const b3ShapeProxy* proxy, b3QueryFilter filter,
                                         b3OverlapResultFcn* fcn, void* context );

B3_API b3TreeStats b3World_CastRay( b3WorldId worldId, b3Pos origin, b3Vec3 translation, b3QueryFilter filter,
                                    b3CastResultFcn* fcn, void* context );

B3_API b3RayResult b3World_CastRayClosest( b3WorldId worldId, b3Pos origin, b3Vec3 translation, b3QueryFilter filter );

B3_API b3TreeStats b3World_CastShape( b3WorldId worldId, b3Pos origin, const b3ShapeProxy* proxy, b3Vec3 translation,
                                      b3QueryFilter filter, b3CastResultFcn* fcn, void* context );

B3_API float b3World_CastMover( b3WorldId worldId, b3Pos origin, const b3Capsule* mover, b3Vec3 translation, b3QueryFilter filter,
                                b3MoverFilterFcn* fcn, void* context );

B3_API void b3World_CollideMover( b3WorldId worldId, b3Pos origin, const b3Capsule* mover, b3QueryFilter filter,
                                  b3PlaneResultFcn* fcn, void* context );

B3_API void b3World_EnableSleeping( b3WorldId worldId, bool flag );

B3_API bool b3World_IsSleepingEnabled( b3WorldId worldId );

B3_API void b3World_EnableContinuous( b3WorldId worldId, bool flag );

B3_API bool b3World_IsContinuousEnabled( b3WorldId worldId );

B3_API void b3World_SetRestitutionThreshold( b3WorldId worldId, float value );

B3_API float b3World_GetRestitutionThreshold( b3WorldId worldId );

B3_API void b3World_SetHitEventThreshold( b3WorldId worldId, float value );

B3_API float b3World_GetHitEventThreshold( b3WorldId worldId );

B3_API void b3World_SetCustomFilterCallback( b3WorldId worldId, b3CustomFilterFcn* fcn, void* context );

B3_API void b3World_SetPreSolveCallback( b3WorldId worldId, b3PreSolveFcn* fcn, void* context );

B3_API void b3World_SetGravity( b3WorldId worldId, b3Vec3 gravity );

B3_API b3Vec3 b3World_GetGravity( b3WorldId worldId );

B3_API void b3World_Explode( b3WorldId worldId, const b3ExplosionDef* explosionDef );

B3_API void b3World_SetContactTuning( b3WorldId worldId, float hertz, float dampingRatio, float contactSpeed );

B3_API void b3World_SetContactRecycleDistance( b3WorldId worldId, float recycleDistance );

B3_API float b3World_GetContactRecycleDistance( b3WorldId worldId );

B3_API void b3World_SetMaximumLinearSpeed( b3WorldId worldId, float maximumLinearSpeed );

B3_API float b3World_GetMaximumLinearSpeed( b3WorldId worldId );

B3_API void b3World_EnableWarmStarting( b3WorldId worldId, bool flag );

B3_API bool b3World_IsWarmStartingEnabled( b3WorldId worldId );

B3_API int b3World_GetAwakeBodyCount( b3WorldId worldId );

B3_API b3Profile b3World_GetProfile( b3WorldId worldId );

B3_API b3Counters b3World_GetCounters( b3WorldId worldId );

B3_API b3Capacity b3World_GetMaxCapacity( b3WorldId worldId );

B3_API void b3World_SetUserData( b3WorldId worldId, void* userData );

B3_API void* b3World_GetUserData( b3WorldId worldId );

B3_API void b3World_SetFrictionCallback( b3WorldId worldId, b3FrictionCallback* callback );

B3_API void b3World_SetRestitutionCallback( b3WorldId worldId, b3RestitutionCallback* callback );

B3_API void b3World_SetWorkerCount( b3WorldId worldId, int count );

B3_API int b3World_GetWorkerCount( b3WorldId worldId );

B3_API void b3World_DumpMemoryStats( b3WorldId worldId );

B3_API void b3World_DumpShapeBounds( b3WorldId worldId, b3BodyType type );

B3_API void b3World_RebuildStaticTree( b3WorldId worldId );

B3_API void b3World_EnableSpeculative( b3WorldId worldId, bool flag );

B3_API void b3World_DumpAwake( b3WorldId worldId );

B3_API void b3World_Dump( b3WorldId worldId );


typedef struct b3Recording b3Recording;

B3_API b3Recording* b3CreateRecording( int byteCapacity );

B3_API void b3DestroyRecording( b3Recording* recording );

B3_API const uint8_t* b3Recording_GetData( const b3Recording* recording );

B3_API int b3Recording_GetSize( const b3Recording* recording );

B3_API void b3World_StartRecording( b3WorldId worldId, b3Recording* recording );

B3_API void b3World_StopRecording( b3WorldId worldId );

B3_API bool b3SaveRecordingToFile( const b3Recording* recording, const char* path );

B3_API b3Recording* b3LoadRecordingFromFile( const char* path );

B3_API bool b3ValidateReplay( const void* data, int size, int workerCount );

typedef struct b3RecPlayer b3RecPlayer;

typedef struct b3RecPlayerInfo
{
    int    frameCount;   // total recorded steps
    int    workerCount;  // worker count requested for the replay world
    float  timeStep;     // dt of the recorded steps
    int    subStepCount; // recorded sub-steps
    float  lengthScale;  // length units per meter in effect when recorded
    b3AABB bounds;       // accumulated world bounds over the recording, zero-extent if unavailable
} b3RecPlayerInfo;

B3_API b3RecPlayer* b3RecPlayer_Create( const void* data, int size, int workerCount );

B3_API void b3RecPlayer_Destroy( b3RecPlayer* player );

B3_API bool b3RecPlayer_StepFrame( b3RecPlayer* player );

B3_API void b3RecPlayer_Restart( b3RecPlayer* player );

B3_API void b3RecPlayer_SeekFrame( b3RecPlayer* player, int targetFrame );

B3_API b3WorldId b3RecPlayer_GetWorldId( const b3RecPlayer* player );

B3_API int b3RecPlayer_GetFrame( const b3RecPlayer* player );

B3_API int b3RecPlayer_GetFrameCount( const b3RecPlayer* player );

B3_API bool b3RecPlayer_IsAtEnd( const b3RecPlayer* player );

B3_API bool b3RecPlayer_HasDiverged( const b3RecPlayer* player );

B3_API b3RecPlayerInfo b3RecPlayer_GetInfo( const b3RecPlayer* player );

B3_API int b3RecPlayer_GetDivergeFrame( const b3RecPlayer* player );

B3_API void b3RecPlayer_SetWorkerCount( b3RecPlayer* player, int count );

B3_API void b3RecPlayer_SetKeyframePolicy( b3RecPlayer* player, size_t budgetBytes, int minIntervalFrames );

B3_API size_t b3RecPlayer_GetKeyframeBudget( const b3RecPlayer* player );

B3_API int b3RecPlayer_GetKeyframeMinInterval( const b3RecPlayer* player );

B3_API int b3RecPlayer_GetKeyframeInterval( const b3RecPlayer* player );

B3_API size_t b3RecPlayer_GetKeyframeBytes( const b3RecPlayer* player );

B3_API int b3RecPlayer_GetBodyCount( const b3RecPlayer* player );

B3_API b3BodyId b3RecPlayer_GetBodyId( const b3RecPlayer* player, int index );

B3_API void b3RecPlayer_SetDebugShapeCallbacks( b3RecPlayer* player, b3CreateDebugShapeCallback* createDebugShape,
                                                b3DestroyDebugShapeCallback* destroyDebugShape, void* context );

B3_API void b3RecPlayer_DrawFrameQueries( b3RecPlayer* player, b3DebugDraw* draw, int queryIndex, int selectedIndex );

typedef enum b3RecQueryType
{
    b3_recQueryOverlapAABB,
    b3_recQueryOverlapShape,
    b3_recQueryCastRay,
    b3_recQueryCastShape,
    b3_recQueryCastRayClosest,
    b3_recQueryCastMover,
    b3_recQueryCollideMover,
} b3RecQueryType;

typedef struct b3RecQueryInfo
{
    b3RecQueryType type;
    b3QueryFilter  filter;
    b3AABB         aabb;        // world-space bounds of the query, swept for casts
    b3Pos          origin;      // query origin (zero for overlap AABB)
    b3Vec3         translation; // ray and cast translation
    int            hitCount;    // number of recorded results
    uint64_t       key;         // identity key, the hash of (id, name), 0 if untagged
    uint64_t       id;          // query id, 0 if none
    const char*    name;        // query label, NULL if none
} b3RecQueryInfo;

typedef struct b3RecQueryHit
{
    b3ShapeId shape;
    b3Pos     point;
    b3Vec3    normal;
    float     fraction;
} b3RecQueryHit;

B3_API int b3RecPlayer_GetFrameQueryCount( const b3RecPlayer* player );

B3_API b3RecQueryInfo b3RecPlayer_GetFrameQuery( const b3RecPlayer* player, int index );

B3_API b3RecQueryHit b3RecPlayer_GetFrameQueryHit( const b3RecPlayer* player, int queryIndex, int hitIndex );
 // recording
 // world


B3_API b3BodyId b3CreateBody( b3WorldId worldId, const b3BodyDef* def );

B3_API void b3DestroyBody( b3BodyId bodyId );

B3_API bool b3Body_IsValid( b3BodyId id );

B3_API b3BodyType b3Body_GetType( b3BodyId bodyId );

B3_API void b3Body_SetType( b3BodyId bodyId, b3BodyType type );

B3_API void b3Body_SetName( b3BodyId bodyId, const char* name );

B3_API const char* b3Body_GetName( b3BodyId bodyId );

B3_API void b3Body_SetUserData( b3BodyId bodyId, void* userData );

B3_API void* b3Body_GetUserData( b3BodyId bodyId );

B3_API b3Pos b3Body_GetPosition( b3BodyId bodyId );

B3_API b3Quat b3Body_GetRotation( b3BodyId bodyId );

B3_API b3WorldTransform b3Body_GetTransform( b3BodyId bodyId );

B3_API void b3Body_SetTransform( b3BodyId bodyId, b3Pos position, b3Quat rotation );

B3_API b3Vec3 b3Body_GetLocalPoint( b3BodyId bodyId, b3Pos worldPoint );

B3_API b3Pos b3Body_GetWorldPoint( b3BodyId bodyId, b3Vec3 localPoint );

B3_API b3Vec3 b3Body_GetLocalVector( b3BodyId bodyId, b3Vec3 worldVector );

B3_API b3Vec3 b3Body_GetWorldVector( b3BodyId bodyId, b3Vec3 localVector );

B3_API b3Vec3 b3Body_GetLinearVelocity( b3BodyId bodyId );

B3_API b3Vec3 b3Body_GetAngularVelocity( b3BodyId bodyId );

B3_API void b3Body_SetLinearVelocity( b3BodyId bodyId, b3Vec3 linearVelocity );

B3_API void b3Body_SetAngularVelocity( b3BodyId bodyId, b3Vec3 angularVelocity );

B3_API void b3Body_SetTargetTransform( b3BodyId bodyId, b3WorldTransform target, float timeStep, bool wake );

B3_API b3Vec3 b3Body_GetLocalPointVelocity( b3BodyId bodyId, b3Vec3 localPoint );

B3_API b3Vec3 b3Body_GetWorldPointVelocity( b3BodyId bodyId, b3Pos worldPoint );

B3_API void b3Body_ApplyForce( b3BodyId bodyId, b3Vec3 force, b3Pos point, bool wake );

B3_API void b3Body_ApplyForceToCenter( b3BodyId bodyId, b3Vec3 force, bool wake );

B3_API void b3Body_ApplyTorque( b3BodyId bodyId, b3Vec3 torque, bool wake );

B3_API void b3Body_ApplyLinearImpulse( b3BodyId bodyId, b3Vec3 impulse, b3Pos point, bool wake );

B3_API void b3Body_ApplyLinearImpulseToCenter( b3BodyId bodyId, b3Vec3 impulse, bool wake );

B3_API void b3Body_ApplyAngularImpulse( b3BodyId bodyId, b3Vec3 impulse, bool wake );

B3_API float b3Body_GetMass( b3BodyId bodyId );

B3_API b3Matrix3 b3Body_GetLocalRotationalInertia( b3BodyId bodyId );

B3_API float b3Body_GetInverseMass( b3BodyId bodyId );

B3_API b3Matrix3 b3Body_GetWorldInverseRotationalInertia( b3BodyId bodyId );

B3_API b3Vec3 b3Body_GetLocalCenterOfMass( b3BodyId bodyId );

B3_API b3Pos b3Body_GetWorldCenterOfMass( b3BodyId bodyId );

B3_API void b3Body_SetMassData( b3BodyId bodyId, b3MassData massData );

B3_API b3MassData b3Body_GetMassData( b3BodyId bodyId );

B3_API void b3Body_ApplyMassFromShapes( b3BodyId bodyId );

B3_API void b3Body_SetLinearDamping( b3BodyId bodyId, float linearDamping );

B3_API float b3Body_GetLinearDamping( b3BodyId bodyId );

B3_API void b3Body_SetAngularDamping( b3BodyId bodyId, float angularDamping );

B3_API float b3Body_GetAngularDamping( b3BodyId bodyId );

B3_API void b3Body_SetGravityScale( b3BodyId bodyId, float gravityScale );

B3_API float b3Body_GetGravityScale( b3BodyId bodyId );

B3_API bool b3Body_IsAwake( b3BodyId bodyId );

B3_API void b3Body_SetAwake( b3BodyId bodyId, bool awake );

B3_API void b3Body_EnableSleep( b3BodyId bodyId, bool enableSleep );

B3_API bool b3Body_IsSleepEnabled( b3BodyId bodyId );

B3_API void b3Body_SetSleepThreshold( b3BodyId bodyId, float sleepThreshold );

B3_API float b3Body_GetSleepThreshold( b3BodyId bodyId );

B3_API bool b3Body_IsEnabled( b3BodyId bodyId );

B3_API void b3Body_Disable( b3BodyId bodyId );

B3_API void b3Body_Enable( b3BodyId bodyId );

B3_API void b3Body_SetMotionLocks( b3BodyId bodyId, b3MotionLocks locks );

B3_API b3MotionLocks b3Body_GetMotionLocks( b3BodyId bodyId );

B3_API void b3Body_SetBullet( b3BodyId bodyId, bool flag );

B3_API bool b3Body_IsBullet( b3BodyId bodyId );

B3_API void b3Body_EnableContactRecycling( b3BodyId bodyId, bool flag );

B3_API bool b3Body_IsContactRecyclingEnabled( b3BodyId bodyId );

B3_API void b3Body_EnableHitEvents( b3BodyId bodyId, bool enableHitEvents );

B3_API b3WorldId b3Body_GetWorld( b3BodyId bodyId );

B3_API int b3Body_GetShapeCount( b3BodyId bodyId );

B3_API int b3Body_GetShapes( b3BodyId bodyId, b3ShapeId* shapeArray, int capacity );

B3_API int b3Body_GetJointCount( b3BodyId bodyId );

B3_API int b3Body_GetJoints( b3BodyId bodyId, b3JointId* jointArray, int capacity );

B3_API int b3Body_GetContactCapacity( b3BodyId bodyId );

B3_API int b3Body_GetContactData( b3BodyId bodyId, b3ContactData* contactData, int capacity );

B3_API b3AABB b3Body_ComputeAABB( b3BodyId bodyId );

B3_API float b3Body_GetClosestPoint( b3BodyId bodyId, b3Vec3* result, b3Vec3 target );

B3_API b3BodyCastResult b3Body_CastRay( b3BodyId bodyId, b3Pos origin, b3Vec3 translation, b3QueryFilter filter,
                                        float maxFraction, b3WorldTransform bodyTransform );

B3_API b3BodyCastResult b3Body_CastShape( b3BodyId bodyId, b3Pos origin, const b3ShapeProxy* proxy, b3Vec3 translation,
                                          b3QueryFilter filter, float maxFraction, bool canEncroach,
                                          b3WorldTransform bodyTransform );

B3_API bool b3Body_OverlapShape( b3BodyId bodyId, b3Pos origin, const b3ShapeProxy* proxy, b3QueryFilter filter,
                                 b3WorldTransform bodyTransform );

B3_API int b3Body_CollideMover( b3BodyId bodyId, b3BodyPlaneResult* bodyPlanes, int planeCapacity, b3Pos origin, const b3Capsule* mover,
                                b3QueryFilter filter, b3WorldTransform bodyTransform );
 // body


B3_API b3ShapeId b3CreateSphereShape( b3BodyId bodyId, const b3ShapeDef* def, const b3Sphere* sphere );

B3_API b3ShapeId b3CreateCapsuleShape( b3BodyId bodyId, const b3ShapeDef* def, const b3Capsule* capsule );

B3_API b3ShapeId b3CreateHullShape( b3BodyId bodyId, const b3ShapeDef* def, const b3HullData* hull );

B3_API b3ShapeId b3CreateTransformedHullShape( b3BodyId bodyId, const b3ShapeDef* def, const b3HullData* hull,
                                               b3Transform transform, b3Vec3 scale );

B3_API b3ShapeId b3CreateMeshShape( b3BodyId bodyId, const b3ShapeDef* def, const b3MeshData* mesh, b3Vec3 scale );

B3_API b3ShapeId b3CreateHeightFieldShape( b3BodyId bodyId, const b3ShapeDef* def, const b3HeightFieldData* heightField );

B3_API b3ShapeId b3CreateCompoundShape( b3BodyId bodyId, b3ShapeDef* def, const b3CompoundData* compound );

B3_API void b3DestroyShape( b3ShapeId shapeId, bool updateBodyMass );

B3_API bool b3Shape_IsValid( b3ShapeId id );

B3_API b3ShapeType b3Shape_GetType( b3ShapeId shapeId );

B3_API b3BodyId b3Shape_GetBody( b3ShapeId shapeId );

B3_API b3WorldId b3Shape_GetWorld( b3ShapeId shapeId );

B3_API bool b3Shape_IsSensor( b3ShapeId shapeId );

B3_API void b3Shape_SetUserData( b3ShapeId shapeId, void* userData );

B3_API void* b3Shape_GetUserData( b3ShapeId shapeId );

B3_API void b3Shape_SetDensity( b3ShapeId shapeId, float density, bool updateBodyMass );

B3_API float b3Shape_GetDensity( b3ShapeId shapeId );

B3_API void b3Shape_SetFriction( b3ShapeId shapeId, float friction );

B3_API float b3Shape_GetFriction( b3ShapeId shapeId );

B3_API void b3Shape_SetRestitution( b3ShapeId shapeId, float restitution );

B3_API float b3Shape_GetRestitution( b3ShapeId shapeId );

B3_API void b3Shape_SetSurfaceMaterial( b3ShapeId shapeId, b3SurfaceMaterial surfaceMaterial );

B3_API b3SurfaceMaterial b3Shape_GetSurfaceMaterial( b3ShapeId shapeId );

B3_API int b3Shape_GetMeshMaterialCount( b3ShapeId shapeId );

B3_API void b3Shape_SetMeshMaterial( b3ShapeId shapeId, b3SurfaceMaterial surfaceMaterial, int index );

B3_API b3SurfaceMaterial b3Shape_GetMeshSurfaceMaterial( b3ShapeId shapeId, int index );

B3_API b3Filter b3Shape_GetFilter( b3ShapeId shapeId );

B3_API void b3Shape_SetFilter( b3ShapeId shapeId, b3Filter filter, bool invokeContacts );

B3_API void b3Shape_EnableSensorEvents( b3ShapeId shapeId, bool flag );

B3_API bool b3Shape_AreSensorEventsEnabled( b3ShapeId shapeId );

B3_API void b3Shape_EnableContactEvents( b3ShapeId shapeId, bool flag );

B3_API bool b3Shape_AreContactEventsEnabled( b3ShapeId shapeId );

B3_API void b3Shape_EnablePreSolveEvents( b3ShapeId shapeId, bool flag );

B3_API bool b3Shape_ArePreSolveEventsEnabled( b3ShapeId shapeId );

B3_API void b3Shape_EnableHitEvents( b3ShapeId shapeId, bool flag );

B3_API bool b3Shape_AreHitEventsEnabled( b3ShapeId shapeId );

B3_API b3WorldCastOutput b3Shape_RayCast( b3ShapeId shapeId, b3Pos origin, b3Vec3 translation );

B3_API b3Sphere b3Shape_GetSphere( b3ShapeId shapeId );

B3_API b3Capsule b3Shape_GetCapsule( b3ShapeId shapeId );

B3_API const b3HullData* b3Shape_GetHull( b3ShapeId shapeId );

B3_API b3Mesh b3Shape_GetMesh( b3ShapeId shapeId );

B3_API const b3HeightFieldData* b3Shape_GetHeightField( b3ShapeId shapeId );

B3_API void b3Shape_SetSphere( b3ShapeId shapeId, const b3Sphere* sphere );

B3_API void b3Shape_SetCapsule( b3ShapeId shapeId, const b3Capsule* capsule );

B3_API void b3Shape_SetHull( b3ShapeId shapeId, const b3HullData* hull );

B3_API void b3Shape_SetMesh( b3ShapeId shapeId, const b3MeshData* meshData, b3Vec3 scale );

B3_API int b3Shape_GetContactCapacity( b3ShapeId shapeId );

B3_API int b3Shape_GetContactData( b3ShapeId shapeId, b3ContactData* contactData, int capacity );

B3_API int b3Shape_GetSensorCapacity( b3ShapeId shapeId );

B3_API int b3Shape_GetSensorData( b3ShapeId shapeId, b3ShapeId* visitorIds, int capacity );

B3_API b3AABB b3Shape_GetAABB( b3ShapeId shapeId );

B3_API b3MassData b3Shape_ComputeMassData( b3ShapeId shapeId );

B3_API b3Vec3 b3Shape_GetClosestPoint( b3ShapeId shapeId, b3Vec3 target );

B3_API void b3Shape_ApplyWind( b3ShapeId shapeId, b3Vec3 wind, float drag, float lift, float maxSpeed, bool wake );
 // shape


B3_API void b3DestroyJoint( b3JointId jointId, bool wakeAttached );

B3_API bool b3Joint_IsValid( b3JointId id );

B3_API b3JointType b3Joint_GetType( b3JointId jointId );

B3_API b3BodyId b3Joint_GetBodyA( b3JointId jointId );

B3_API b3BodyId b3Joint_GetBodyB( b3JointId jointId );

B3_API b3WorldId b3Joint_GetWorld( b3JointId jointId );

B3_API void b3Joint_SetLocalFrameA( b3JointId jointId, b3Transform localFrame );

B3_API b3Transform b3Joint_GetLocalFrameA( b3JointId jointId );

B3_API void b3Joint_SetLocalFrameB( b3JointId jointId, b3Transform localFrame );

B3_API b3Transform b3Joint_GetLocalFrameB( b3JointId jointId );

B3_API void b3Joint_SetCollideConnected( b3JointId jointId, bool shouldCollide );

B3_API bool b3Joint_GetCollideConnected( b3JointId jointId );

B3_API void b3Joint_SetUserData( b3JointId jointId, void* userData );

B3_API void* b3Joint_GetUserData( b3JointId jointId );

B3_API void b3Joint_WakeBodies( b3JointId jointId );

B3_API b3Vec3 b3Joint_GetConstraintForce( b3JointId jointId );

B3_API b3Vec3 b3Joint_GetConstraintTorque( b3JointId jointId );

B3_API float b3Joint_GetLinearSeparation( b3JointId jointId );

B3_API float b3Joint_GetAngularSeparation( b3JointId jointId );

B3_API void b3Joint_SetConstraintTuning( b3JointId jointId, float hertz, float dampingRatio );

B3_API void b3Joint_GetConstraintTuning( b3JointId jointId, float* hertz, float* dampingRatio );

B3_API void b3Joint_SetForceThreshold( b3JointId jointId, float threshold );

B3_API float b3Joint_GetForceThreshold( b3JointId jointId );

B3_API void b3Joint_SetTorqueThreshold( b3JointId jointId, float threshold );

B3_API float b3Joint_GetTorqueThreshold( b3JointId jointId );


B3_API b3JointId b3CreateParallelJoint( b3WorldId worldId, const b3ParallelJointDef* def );

B3_API void b3ParallelJoint_SetSpringHertz( b3JointId jointId, float hertz );

B3_API void b3ParallelJoint_SetSpringDampingRatio( b3JointId jointId, float dampingRatio );

B3_API float b3ParallelJoint_GetSpringHertz( b3JointId jointId );

B3_API float b3ParallelJoint_GetSpringDampingRatio( b3JointId jointId );

B3_API void b3ParallelJoint_SetMaxTorque( b3JointId jointId, float force );

B3_API float b3ParallelJoint_GetMaxTorque( b3JointId jointId );
 // parallel_joint


B3_API b3JointId b3CreateDistanceJoint( b3WorldId worldId, const b3DistanceJointDef* def );

B3_API void b3DistanceJoint_SetLength( b3JointId jointId, float length );

B3_API float b3DistanceJoint_GetLength( b3JointId jointId );

B3_API void b3DistanceJoint_EnableSpring( b3JointId jointId, bool enableSpring );

B3_API bool b3DistanceJoint_IsSpringEnabled( b3JointId jointId );

B3_API void b3DistanceJoint_SetSpringForceRange( b3JointId jointId, float lowerForce, float upperForce );

B3_API void b3DistanceJoint_GetSpringForceRange( b3JointId jointId, float* lowerForce, float* upperForce );

B3_API void b3DistanceJoint_SetSpringHertz( b3JointId jointId, float hertz );

B3_API void b3DistanceJoint_SetSpringDampingRatio( b3JointId jointId, float dampingRatio );

B3_API float b3DistanceJoint_GetSpringHertz( b3JointId jointId );

B3_API float b3DistanceJoint_GetSpringDampingRatio( b3JointId jointId );

B3_API void b3DistanceJoint_EnableLimit( b3JointId jointId, bool enableLimit );

B3_API bool b3DistanceJoint_IsLimitEnabled( b3JointId jointId );

B3_API void b3DistanceJoint_SetLengthRange( b3JointId jointId, float minLength, float maxLength );

B3_API float b3DistanceJoint_GetMinLength( b3JointId jointId );

B3_API float b3DistanceJoint_GetMaxLength( b3JointId jointId );

B3_API float b3DistanceJoint_GetCurrentLength( b3JointId jointId );

B3_API void b3DistanceJoint_EnableMotor( b3JointId jointId, bool enableMotor );

B3_API bool b3DistanceJoint_IsMotorEnabled( b3JointId jointId );

B3_API void b3DistanceJoint_SetMotorSpeed( b3JointId jointId, float motorSpeed );

B3_API float b3DistanceJoint_GetMotorSpeed( b3JointId jointId );

B3_API void b3DistanceJoint_SetMaxMotorForce( b3JointId jointId, float force );

B3_API float b3DistanceJoint_GetMaxMotorForce( b3JointId jointId );

B3_API float b3DistanceJoint_GetMotorForce( b3JointId jointId );
 // distance_joint


B3_API b3JointId b3CreateMotorJoint( b3WorldId worldId, const b3MotorJointDef* def );

B3_API void b3MotorJoint_SetLinearVelocity( b3JointId jointId, b3Vec3 velocity );

B3_API b3Vec3 b3MotorJoint_GetLinearVelocity( b3JointId jointId );

B3_API void b3MotorJoint_SetAngularVelocity( b3JointId jointId, b3Vec3 velocity );

B3_API b3Vec3 b3MotorJoint_GetAngularVelocity( b3JointId jointId );

B3_API void b3MotorJoint_SetMaxVelocityForce( b3JointId jointId, float maxForce );

B3_API float b3MotorJoint_GetMaxVelocityForce( b3JointId jointId );

B3_API void b3MotorJoint_SetMaxVelocityTorque( b3JointId jointId, float maxTorque );

B3_API float b3MotorJoint_GetMaxVelocityTorque( b3JointId jointId );

B3_API void b3MotorJoint_SetLinearHertz( b3JointId jointId, float hertz );

B3_API float b3MotorJoint_GetLinearHertz( b3JointId jointId );

B3_API void b3MotorJoint_SetLinearDampingRatio( b3JointId jointId, float damping );

B3_API float b3MotorJoint_GetLinearDampingRatio( b3JointId jointId );

B3_API void b3MotorJoint_SetAngularHertz( b3JointId jointId, float hertz );

B3_API float b3MotorJoint_GetAngularHertz( b3JointId jointId );

B3_API void b3MotorJoint_SetAngularDampingRatio( b3JointId jointId, float damping );

B3_API float b3MotorJoint_GetAngularDampingRatio( b3JointId jointId );

B3_API void b3MotorJoint_SetMaxSpringForce( b3JointId jointId, float maxForce );

B3_API float b3MotorJoint_GetMaxSpringForce( b3JointId jointId );

B3_API void b3MotorJoint_SetMaxSpringTorque( b3JointId jointId, float maxTorque );

B3_API float b3MotorJoint_GetMaxSpringTorque( b3JointId jointId );
 // motor_joint


B3_API b3JointId b3CreateFilterJoint( b3WorldId worldId, const b3FilterJointDef* def );
 // filter_joint


B3_API b3JointId b3CreatePrismaticJoint( b3WorldId worldId, const b3PrismaticJointDef* def );

B3_API void b3PrismaticJoint_EnableSpring( b3JointId jointId, bool enableSpring );

B3_API bool b3PrismaticJoint_IsSpringEnabled( b3JointId jointId );

B3_API void b3PrismaticJoint_SetSpringHertz( b3JointId jointId, float hertz );

B3_API float b3PrismaticJoint_GetSpringHertz( b3JointId jointId );

B3_API void b3PrismaticJoint_SetSpringDampingRatio( b3JointId jointId, float dampingRatio );

B3_API float b3PrismaticJoint_GetSpringDampingRatio( b3JointId jointId );

B3_API void b3PrismaticJoint_SetTargetTranslation( b3JointId jointId, float targetTranslation );

B3_API float b3PrismaticJoint_GetTargetTranslation( b3JointId jointId );

B3_API void b3PrismaticJoint_EnableLimit( b3JointId jointId, bool enableLimit );

B3_API bool b3PrismaticJoint_IsLimitEnabled( b3JointId jointId );

B3_API float b3PrismaticJoint_GetLowerLimit( b3JointId jointId );

B3_API float b3PrismaticJoint_GetUpperLimit( b3JointId jointId );

B3_API void b3PrismaticJoint_SetLimits( b3JointId jointId, float lower, float upper );

B3_API void b3PrismaticJoint_EnableMotor( b3JointId jointId, bool enableMotor );

B3_API bool b3PrismaticJoint_IsMotorEnabled( b3JointId jointId );

B3_API void b3PrismaticJoint_SetMotorSpeed( b3JointId jointId, float motorSpeed );

B3_API float b3PrismaticJoint_GetMotorSpeed( b3JointId jointId );

B3_API void b3PrismaticJoint_SetMaxMotorForce( b3JointId jointId, float force );

B3_API float b3PrismaticJoint_GetMaxMotorForce( b3JointId jointId );

B3_API float b3PrismaticJoint_GetMotorForce( b3JointId jointId );

B3_API float b3PrismaticJoint_GetTranslation( b3JointId jointId );

B3_API float b3PrismaticJoint_GetSpeed( b3JointId jointId );
 // prismatic_joint


B3_API b3JointId b3CreateRevoluteJoint( b3WorldId worldId, const b3RevoluteJointDef* def );

B3_API void b3RevoluteJoint_EnableSpring( b3JointId jointId, bool enableSpring );

B3_API bool b3RevoluteJoint_IsSpringEnabled( b3JointId jointId );

B3_API void b3RevoluteJoint_SetSpringHertz( b3JointId jointId, float hertz );

B3_API float b3RevoluteJoint_GetSpringHertz( b3JointId jointId );

B3_API void b3RevoluteJoint_SetSpringDampingRatio( b3JointId jointId, float dampingRatio );

B3_API float b3RevoluteJoint_GetSpringDampingRatio( b3JointId jointId );

B3_API void b3RevoluteJoint_SetTargetAngle( b3JointId jointId, float targetRadians );

B3_API float b3RevoluteJoint_GetTargetAngle( b3JointId jointId );

B3_API float b3RevoluteJoint_GetAngle( b3JointId jointId );

B3_API void b3RevoluteJoint_EnableLimit( b3JointId jointId, bool enableLimit );

B3_API bool b3RevoluteJoint_IsLimitEnabled( b3JointId jointId );

B3_API float b3RevoluteJoint_GetLowerLimit( b3JointId jointId );

B3_API float b3RevoluteJoint_GetUpperLimit( b3JointId jointId );

B3_API void b3RevoluteJoint_SetLimits( b3JointId jointId, float lowerLimitRadians, float upperLimitRadians );

B3_API void b3RevoluteJoint_EnableMotor( b3JointId jointId, bool enableMotor );

B3_API bool b3RevoluteJoint_IsMotorEnabled( b3JointId jointId );

B3_API void b3RevoluteJoint_SetMotorSpeed( b3JointId jointId, float motorSpeed );

B3_API float b3RevoluteJoint_GetMotorSpeed( b3JointId jointId );

B3_API float b3RevoluteJoint_GetMotorTorque( b3JointId jointId );

B3_API void b3RevoluteJoint_SetMaxMotorTorque( b3JointId jointId, float torque );

B3_API float b3RevoluteJoint_GetMaxMotorTorque( b3JointId jointId );
 // revolute_joint


B3_API b3JointId b3CreateSphericalJoint( b3WorldId worldId, const b3SphericalJointDef* def );

B3_API void b3SphericalJoint_EnableConeLimit( b3JointId jointId, bool enableLimit );

B3_API bool b3SphericalJoint_IsConeLimitEnabled( b3JointId jointId );

B3_API float b3SphericalJoint_GetConeLimit( b3JointId jointId );

B3_API void b3SphericalJoint_SetConeLimit( b3JointId jointId, float angleRadians );

B3_API float b3SphericalJoint_GetConeAngle( b3JointId jointId );

B3_API void b3SphericalJoint_EnableTwistLimit( b3JointId jointId, bool enableLimit );

B3_API bool b3SphericalJoint_IsTwistLimitEnabled( b3JointId jointId );

B3_API float b3SphericalJoint_GetLowerTwistLimit( b3JointId jointId );

B3_API float b3SphericalJoint_GetUpperTwistLimit( b3JointId jointId );

B3_API void b3SphericalJoint_SetTwistLimits( b3JointId jointId, float lowerLimitRadians, float upperLimitRadians );

B3_API float b3SphericalJoint_GetTwistAngle( b3JointId jointId );

B3_API void b3SphericalJoint_EnableSpring( b3JointId jointId, bool enableSpring );

B3_API bool b3SphericalJoint_IsSpringEnabled( b3JointId jointId );

B3_API void b3SphericalJoint_SetSpringHertz( b3JointId jointId, float hertz );

B3_API float b3SphericalJoint_GetSpringHertz( b3JointId jointId );

B3_API void b3SphericalJoint_SetSpringDampingRatio( b3JointId jointId, float dampingRatio );

B3_API float b3SphericalJoint_GetSpringDampingRatio( b3JointId jointId );

B3_API void b3SphericalJoint_SetTargetRotation( b3JointId jointId, b3Quat targetRotation );

B3_API b3Quat b3SphericalJoint_GetTargetRotation( b3JointId jointId );

B3_API void b3SphericalJoint_EnableMotor( b3JointId jointId, bool enableMotor );

B3_API bool b3SphericalJoint_IsMotorEnabled( b3JointId jointId );

B3_API void b3SphericalJoint_SetMotorVelocity( b3JointId jointId, b3Vec3 motorVelocity );

B3_API b3Vec3 b3SphericalJoint_GetMotorVelocity( b3JointId jointId );

B3_API b3Vec3 b3SphericalJoint_GetMotorTorque( b3JointId jointId );

B3_API void b3SphericalJoint_SetMaxMotorTorque( b3JointId jointId, float torque );

B3_API float b3SphericalJoint_GetMaxMotorTorque( b3JointId jointId );
 // spherical_joint


B3_API b3JointId b3CreateWeldJoint( b3WorldId worldId, const b3WeldJointDef* def );

B3_API void b3WeldJoint_SetLinearHertz( b3JointId jointId, float hertz );

B3_API float b3WeldJoint_GetLinearHertz( b3JointId jointId );

B3_API void b3WeldJoint_SetLinearDampingRatio( b3JointId jointId, float dampingRatio );

B3_API float b3WeldJoint_GetLinearDampingRatio( b3JointId jointId );

B3_API void b3WeldJoint_SetAngularHertz( b3JointId jointId, float hertz );

B3_API float b3WeldJoint_GetAngularHertz( b3JointId jointId );

B3_API void b3WeldJoint_SetAngularDampingRatio( b3JointId jointId, float dampingRatio );

B3_API float b3WeldJoint_GetAngularDampingRatio( b3JointId jointId );
 // weld_joint


B3_API b3JointId b3CreateWheelJoint( b3WorldId worldId, const b3WheelJointDef* def );

B3_API void b3WheelJoint_EnableSuspension( b3JointId jointId, bool flag );

B3_API bool b3WheelJoint_IsSuspensionEnabled( b3JointId jointId );

B3_API void b3WheelJoint_SetSuspensionHertz( b3JointId jointId, float hertz );

B3_API float b3WheelJoint_GetSuspensionHertz( b3JointId jointId );

B3_API void b3WheelJoint_SetSuspensionDampingRatio( b3JointId jointId, float dampingRatio );

B3_API float b3WheelJoint_GetSuspensionDampingRatio( b3JointId jointId );

B3_API void b3WheelJoint_EnableSuspensionLimit( b3JointId jointId, bool flag );

B3_API bool b3WheelJoint_IsSuspensionLimitEnabled( b3JointId jointId );

B3_API float b3WheelJoint_GetLowerSuspensionLimit( b3JointId jointId );

B3_API float b3WheelJoint_GetUpperSuspensionLimit( b3JointId jointId );

B3_API void b3WheelJoint_SetSuspensionLimits( b3JointId jointId, float lower, float upper );

B3_API void b3WheelJoint_EnableSpinMotor( b3JointId jointId, bool flag );

B3_API bool b3WheelJoint_IsSpinMotorEnabled( b3JointId jointId );

B3_API void b3WheelJoint_SetSpinMotorSpeed( b3JointId jointId, float speed );

B3_API float b3WheelJoint_GetSpinMotorSpeed( b3JointId jointId );

B3_API void b3WheelJoint_SetMaxSpinTorque( b3JointId jointId, float torque );

B3_API float b3WheelJoint_GetMaxSpinTorque( b3JointId jointId );

B3_API float b3WheelJoint_GetSpinSpeed( b3JointId jointId );

B3_API float b3WheelJoint_GetSpinTorque( b3JointId jointId );

B3_API void b3WheelJoint_EnableSteering( b3JointId jointId, bool flag );

B3_API bool b3WheelJoint_IsSteeringEnabled( b3JointId jointId );

B3_API void b3WheelJoint_SetSteeringHertz( b3JointId jointId, float hertz );

B3_API float b3WheelJoint_GetSteeringHertz( b3JointId jointId );

B3_API void b3WheelJoint_SetSteeringDampingRatio( b3JointId jointId, float dampingRatio );

B3_API float b3WheelJoint_GetSteeringDampingRatio( b3JointId jointId );

B3_API void b3WheelJoint_SetMaxSteeringTorque( b3JointId jointId, float torque );

B3_API float b3WheelJoint_GetMaxSteeringTorque( b3JointId jointId );

B3_API void b3WheelJoint_EnableSteeringLimit( b3JointId jointId, bool flag );

B3_API bool b3WheelJoint_IsSteeringLimitEnabled( b3JointId jointId );

B3_API float b3WheelJoint_GetLowerSteeringLimit( b3JointId jointId );

B3_API float b3WheelJoint_GetUpperSteeringLimit( b3JointId jointId );

B3_API void b3WheelJoint_SetSteeringLimits( b3JointId jointId, float lowerRadians, float upperRadians );

B3_API void b3WheelJoint_SetTargetSteeringAngle( b3JointId jointId, float radians );

B3_API float b3WheelJoint_GetTargetSteeringAngle( b3JointId jointId );

B3_API float b3WheelJoint_GetSteeringAngle( b3JointId jointId );

B3_API float b3WheelJoint_GetSteeringTorque( b3JointId jointId );
 // wheel_joint
 // joint


B3_API bool b3Contact_IsValid( b3ContactId id );

B3_API b3ContactData b3Contact_GetData( b3ContactId contactId );
 // contact