types.h

// SPDX-FileCopyrightText: 2025 Erin Catto
// SPDX-License-Identifier: MIT
 
#pragma once
 
#include "base.h"
#include "constants.h"
#include "id.h"
#include "math_functions.h"
 
#include <stdint.h>
 
#define B3_DEFAULT_CATEGORY_BITS UINT64_MAX
#define B3_DEFAULT_MASK_BITS UINT64_MAX

typedef void b3TaskCallback( void* taskContext );

typedef void* b3EnqueueTaskCallback( b3TaskCallback* task, void* taskContext, void* userContext, const char* taskName );

typedef void b3FinishTaskCallback( void* userTask, void* userContext );
 
typedef struct b3DebugShape b3DebugShape;

typedef void* b3CreateDebugShapeCallback( const b3DebugShape* debugShape, void* userContext );
typedef void b3DestroyDebugShapeCallback( void* userShape, void* userContext );

typedef float b3FrictionCallback( float frictionA, uint64_t userMaterialIdA, float frictionB, uint64_t userMaterialIdB );

typedef float b3RestitutionCallback( float restitutionA, uint64_t userMaterialIdA, float restitutionB, uint64_t userMaterialIdB );

typedef bool b3CustomFilterFcn( b3ShapeId shapeIdA, b3ShapeId shapeIdB, void* context );

typedef bool b3PreSolveFcn( b3ShapeId shapeIdA, b3ShapeId shapeIdB, b3Pos point, b3Vec3 normal, void* context );

typedef bool b3OverlapResultFcn( b3ShapeId shapeId, void* context );

typedef float b3CastResultFcn( b3ShapeId shapeId, b3Pos point, b3Vec3 normal, float fraction, uint64_t userMaterialId,
                               int triangleIndex, int childIndex, void* context );

typedef struct b3Capacity
{
    int staticShapeCount;

    int dynamicShapeCount;

    int staticBodyCount;

    int dynamicBodyCount;

    int contactCount;
} b3Capacity;

typedef struct b3WorldDef
{
    b3Vec3 gravity;

    float restitutionThreshold;

    float hitEventThreshold;

    float contactHertz;

    float contactDampingRatio;

    float contactSpeed;

    float maximumLinearSpeed;

    b3FrictionCallback* frictionCallback;

    b3RestitutionCallback* restitutionCallback;

    bool enableSleep;

    bool enableContinuous;

    uint32_t workerCount;

    b3EnqueueTaskCallback* enqueueTask;

    b3FinishTaskCallback* finishTask;

    void* userTaskContext;

    void* userData;

    b3CreateDebugShapeCallback* createDebugShape;

    b3DestroyDebugShapeCallback* destroyDebugShape;

    void* userDebugShapeContext;

    b3Capacity capacity;

    int internalValue;
} b3WorldDef;

B3_API b3WorldDef b3DefaultWorldDef( void );

typedef enum b3BodyType
{
    b3_staticBody = 0,

    b3_kinematicBody = 1,

    b3_dynamicBody = 2,

    b3_bodyTypeCount,
} b3BodyType;

typedef struct b3MotionLocks
{
    bool linearX;

    bool linearY;

    bool linearZ;

    bool angularX;

    bool angularY;

    bool angularZ;
} b3MotionLocks;

typedef struct b3BodyDef
{
    b3BodyType type;

    b3Pos position;

    b3Quat rotation;

    b3Vec3 linearVelocity;

    b3Vec3 angularVelocity;

    float linearDamping;

    float angularDamping;

    float gravityScale;

    float sleepThreshold;

    const char* name;

    void* userData;

    b3MotionLocks motionLocks;

    bool enableSleep;

    bool isAwake;

    bool isBullet;

    bool isEnabled;

    bool allowFastRotation;

    bool enableContactRecycling;

    int internalValue;
} b3BodyDef;

B3_API b3BodyDef b3DefaultBodyDef( void );

typedef struct b3Filter
{
    uint64_t categoryBits;

    uint64_t maskBits;

    int groupIndex;
} b3Filter;

B3_API b3Filter b3DefaultFilter( void );

typedef struct b3SurfaceMaterial
{
    float friction;

    float restitution;

    float rollingResistance;

    b3Vec3 tangentVelocity;

    uint64_t userMaterialId;

    uint32_t customColor;
} b3SurfaceMaterial;

B3_API b3SurfaceMaterial b3DefaultSurfaceMaterial( void );

typedef enum b3ShapeType
{
    b3_capsuleShape,

    b3_compoundShape,

    b3_heightShape,

    b3_hullShape,

    b3_meshShape,

    b3_sphereShape,

    b3_shapeTypeCount
} b3ShapeType;

typedef struct b3ShapeDef
{
    void* userData;

    b3SurfaceMaterial* materials;

    int materialCount;

    b3SurfaceMaterial baseMaterial;

    float density;

    float explosionScale;

    b3Filter filter;

    bool enableCustomFiltering;

    bool isSensor;

    bool enableSensorEvents;

    bool enableContactEvents;

    bool enableHitEvents;

    bool enablePreSolveEvents;

    bool invokeContactCreation;

    bool updateBodyMass;

    int internalValue;
 
} b3ShapeDef;

B3_API b3ShapeDef b3DefaultShapeDef( void );

typedef struct b3Profile
{
    float step;
    float pairs;
    float collide;
    float solve;
    float solverSetup;
    float constraints;
    float prepareConstraints;
    float integrateVelocities;
    float warmStart;
    float solveImpulses;
    float integratePositions;
    float relaxImpulses;
    float applyRestitution;
    float storeImpulses;
    float splitIslands;
    float transforms;
    float sensorHits;
    float jointEvents;
    float hitEvents;
    float refit;
    float bullets;
    float sleepIslands;
    float sensors;
} b3Profile;

typedef struct b3Counters
{
    int bodyCount;
    int shapeCount;
    int contactCount;
    int jointCount;
    int islandCount;
    int stackUsed;
    int arenaCapacity;
    int staticTreeHeight;
    int treeHeight;
    int satCallCount;
    int satCacheHitCount;
    int byteCount;
    int taskCount;
    int colorCounts[24];
    int manifoldCounts[B3_CONTACT_MANIFOLD_COUNT_BUCKETS];

    int awakeContactCount;

    int recycledContactCount;

    int distanceIterations;
    int pushBackIterations;
    int rootIterations;
} b3Counters;

typedef enum b3JointType
{
    b3_parallelJoint,
    b3_distanceJoint,
    b3_filterJoint,
    b3_motorJoint,
    b3_prismaticJoint,
    b3_revoluteJoint,
    b3_sphericalJoint,
    b3_weldJoint,
    b3_wheelJoint,
} b3JointType;

typedef struct b3JointDef
{
    void* userData;

    b3BodyId bodyIdA;

    b3BodyId bodyIdB;

    b3Transform localFrameA;

    b3Transform localFrameB;

    float forceThreshold;

    float torqueThreshold;

    float constraintHertz;

    float constraintDampingRatio;

    float drawScale;

    bool collideConnected;

    int internalValue;
} b3JointDef;

typedef struct b3DistanceJointDef
{
    b3JointDef base;

    float length;

    bool enableSpring;

    float lowerSpringForce;

    float upperSpringForce;

    float hertz;

    float dampingRatio;

    bool enableLimit;

    float minLength;

    float maxLength;

    bool enableMotor;

    float maxMotorForce;

    float motorSpeed;
} b3DistanceJointDef;

B3_API b3DistanceJointDef b3DefaultDistanceJointDef( void );

typedef struct b3MotorJointDef
{
    b3JointDef base;

    b3Vec3 linearVelocity;

    float maxVelocityForce;

    b3Vec3 angularVelocity;

    float maxVelocityTorque;

    float linearHertz;

    float linearDampingRatio;

    float maxSpringForce;

    float angularHertz;

    float angularDampingRatio;

    float maxSpringTorque;
} b3MotorJointDef;

B3_API b3MotorJointDef b3DefaultMotorJointDef( void );

typedef struct b3FilterJointDef
{
    b3JointDef base;
} b3FilterJointDef;

B3_API b3FilterJointDef b3DefaultFilterJointDef( void );

typedef struct b3ParallelJointDef
{
    b3JointDef base;

    float hertz;

    float dampingRatio;

    float maxTorque;
 
} b3ParallelJointDef;

B3_API b3ParallelJointDef b3DefaultParallelJointDef( void );

typedef struct b3PrismaticJointDef
{
    b3JointDef base;

    bool enableSpring;

    float hertz;

    float dampingRatio;

    float targetTranslation;

    bool enableLimit;

    float lowerTranslation;

    float upperTranslation;

    bool enableMotor;

    float maxMotorForce;

    float motorSpeed;
} b3PrismaticJointDef;

B3_API b3PrismaticJointDef b3DefaultPrismaticJointDef( void );

typedef struct b3RevoluteJointDef
{
    b3JointDef base;

    float targetAngle;

    bool enableSpring;

    float hertz;

    float dampingRatio;

    bool enableLimit;

    float lowerAngle;

    float upperAngle;

    bool enableMotor;

    float maxMotorTorque;

    float motorSpeed;
} b3RevoluteJointDef;

B3_API b3RevoluteJointDef b3DefaultRevoluteJointDef( void );

typedef struct b3SphericalJointDef
{
    b3JointDef base;

    bool enableSpring;

    float hertz;

    float dampingRatio;

    b3Quat targetRotation;

    bool enableConeLimit;

    float coneAngle;

    bool enableTwistLimit;

    float lowerTwistAngle;

    float upperTwistAngle;

    bool enableMotor;

    float maxMotorTorque;

    b3Vec3 motorVelocity;
} b3SphericalJointDef;

B3_API b3SphericalJointDef b3DefaultSphericalJointDef( void );

typedef struct b3WeldJointDef
{
    b3JointDef base;

    float linearHertz;

    float angularHertz;

    float linearDampingRatio;

    float angularDampingRatio;
} b3WeldJointDef;

B3_API b3WeldJointDef b3DefaultWeldJointDef( void );

typedef struct b3WheelJointDef
{
    b3JointDef base;

    bool enableSuspensionSpring;

    float suspensionHertz;

    float suspensionDampingRatio;

    bool enableSuspensionLimit;

    float lowerSuspensionLimit;

    float upperSuspensionLimit;

    bool enableSpinMotor;

    float maxSpinTorque;

    float spinSpeed;

    bool enableSteering;

    float steeringHertz;

    float steeringDampingRatio;

    float targetSteeringAngle;

    float maxSteeringTorque;

    bool enableSteeringLimit;

    float lowerSteeringLimit;

    float upperSteeringLimit;
} b3WheelJointDef;

B3_API b3WheelJointDef b3DefaultWheelJointDef( void );

typedef struct b3ExplosionDef
{
    uint64_t maskBits;

    b3Pos position;

    float radius;

    float falloff;

    float impulsePerArea;
} b3ExplosionDef;

B3_API b3ExplosionDef b3DefaultExplosionDef( void );


typedef struct b3SensorBeginTouchEvent
{
    b3ShapeId sensorShapeId;

    b3ShapeId visitorShapeId;
} b3SensorBeginTouchEvent;

typedef struct b3SensorEndTouchEvent
{
    b3ShapeId sensorShapeId;

    b3ShapeId visitorShapeId;
} b3SensorEndTouchEvent;

typedef struct b3SensorEvents
{
    b3SensorBeginTouchEvent* beginEvents;

    b3SensorEndTouchEvent* endEvents;

    int beginCount;

    int endCount;
} b3SensorEvents;

typedef struct b3ContactBeginTouchEvent
{
    b3ShapeId shapeIdA;

    b3ShapeId shapeIdB;

    b3ContactId contactId;
} b3ContactBeginTouchEvent;

typedef struct b3ContactEndTouchEvent
{
    b3ShapeId shapeIdA;

    b3ShapeId shapeIdB;

    b3ContactId contactId;
} b3ContactEndTouchEvent;

typedef struct b3ContactHitEvent
{
    b3ShapeId shapeIdA;

    b3ShapeId shapeIdB;

    b3ContactId contactId;

    b3Pos point;

    b3Vec3 normal;

    float approachSpeed;

    uint64_t userMaterialIdA;

    uint64_t userMaterialIdB;
 
} b3ContactHitEvent;

typedef struct b3ContactEvents
{
    b3ContactBeginTouchEvent* beginEvents;

    b3ContactEndTouchEvent* endEvents;

    b3ContactHitEvent* hitEvents;

    int beginCount;

    int endCount;

    int hitCount;
} b3ContactEvents;

typedef struct b3BodyMoveEvent
{
    void* userData;

    b3WorldTransform transform;

    b3BodyId bodyId;

    bool fellAsleep;
} b3BodyMoveEvent;

typedef struct b3BodyEvents
{
    b3BodyMoveEvent* moveEvents;

    int moveCount;
} b3BodyEvents;

typedef struct b3JointEvent
{
    b3JointId jointId;

    void* userData;
} b3JointEvent;

typedef struct b3JointEvents
{
    b3JointEvent* jointEvents;

    int count;
} b3JointEvents;

typedef struct b3ContactData
{
    b3ContactId contactId;

    b3ShapeId shapeIdA;

    b3ShapeId shapeIdB;

    const struct b3Manifold* manifolds;

    int manifoldCount;
} b3ContactData;
 // event


typedef struct b3QueryFilter
{
    uint64_t categoryBits;

    uint64_t maskBits;

    uint64_t id;

    const char* name;
} b3QueryFilter;

B3_API b3QueryFilter b3DefaultQueryFilter( void );

typedef struct b3RayCastInput
{
    b3Vec3 origin;

    b3Vec3 translation;

    float maxFraction;
} b3RayCastInput;

typedef struct b3RayResult
{
    b3ShapeId shapeId;

    b3Pos point;

    b3Vec3 normal;

    uint64_t userMaterialId;

    float fraction;

    int triangleIndex;

    int childIndex;

    int nodeVisits;

    int leafVisits;

    bool hit;
} b3RayResult;

typedef struct b3ShapeProxy
{
    const b3Vec3* points;

    int count;

    float radius;
} b3ShapeProxy;

typedef struct b3ShapeCastInput
{
    b3ShapeProxy proxy;

    b3Vec3 translation;

    float maxFraction;

    bool canEncroach;
} b3ShapeCastInput;

typedef struct b3BoxCastInput
{
    b3AABB box;

    b3Vec3 translation;

    float maxFraction;
} b3BoxCastInput;

typedef struct b3CastOutput
{
    b3Vec3 normal;

    b3Vec3 point;

    float fraction;

    int iterations;

    int triangleIndex;

    int childIndex;

    int materialIndex;

    bool hit;
} b3CastOutput;
 
#if defined( BOX3D_DOUBLE_PRECISION )

typedef struct b3WorldCastOutput
{
    b3Vec3 normal;

    b3Pos point;

    float fraction;

    int iterations;

    int triangleIndex;

    int childIndex;

    int materialIndex;

    bool hit;
} b3WorldCastOutput;
 
#else

typedef b3CastOutput b3WorldCastOutput;
 
#endif

typedef struct b3BodyCastResult
{
    b3ShapeId shapeId;

    b3Pos point;

    b3Vec3 normal;

    float fraction;

    int triangleIndex;

    uint64_t userMaterialId;

    int iterations;

    bool hit;
} b3BodyCastResult;

typedef struct b3SimplexCache
{
    float metric;
 
    // todo use an index of 0xFF as a sentinel and remove the count
    uint16_t count;

    uint8_t indexA[4];

    uint8_t indexB[4];
 
} b3SimplexCache;
 
static const b3SimplexCache b3_emptyDistanceCache = B3_ZERO_INIT;

typedef struct b3ShapeCastPairInput
{
    b3ShapeProxy proxyA;   
    b3ShapeProxy proxyB;   
    b3Transform transform; 
    b3Vec3 translationB;   
    float maxFraction;     
    bool canEncroach;      
} b3ShapeCastPairInput;

typedef struct b3DistanceInput
{
    b3ShapeProxy proxyA;

    b3ShapeProxy proxyB;

    b3Transform transform;

    bool useRadii;
} b3DistanceInput;

typedef struct b3DistanceOutput
{
    b3Vec3 pointA;    
    b3Vec3 pointB;    
    b3Vec3 normal;    
    float distance;   
    int iterations;   
    int simplexCount; 
} b3DistanceOutput;

typedef struct b3SimplexVertex
{
    b3Vec3 wA;  
    b3Vec3 wB;  
    b3Vec3 w;   
    float a;    
    int indexA; 
    int indexB; 
} b3SimplexVertex;

typedef struct b3Simplex
{
    b3SimplexVertex vertices[4]; 
    int count;                   
} b3Simplex;

typedef struct b3Sweep
{
    b3Vec3 localCenter; 
    b3Vec3 c1;          
    b3Vec3 c2;          
    b3Quat q1;          
    b3Quat q2;          
} b3Sweep;

typedef struct b3TOIInput
{
    b3ShapeProxy proxyA; 
    b3ShapeProxy proxyB; 
    b3Sweep sweepA;      
    b3Sweep sweepB;      
    float maxFraction;   
} b3TOIInput;

typedef enum b3TOIState
{
    b3_toiStateUnknown,
    b3_toiStateFailed,
    b3_toiStateOverlapped,
    b3_toiStateHit,
    b3_toiStateSeparated
} b3TOIState;

typedef struct b3TOIOutput
{
    b3TOIState state;

    b3Vec3 point;

    b3Vec3 normal;

    float fraction;

    float distance;

    int distanceIterations;

    int pushBackIterations;

    int rootIterations;

    bool usedFallback;
} b3TOIOutput;
 // query


typedef enum b3TreeNodeFlags
{
    b3_allocatedNode = 0x0001,
    b3_enlargedNode = 0x0002,
    b3_leafNode = 0x0004,
} b3TreeNodeFlags;

typedef struct b3TreeNodeChildren
{
    int child1; 
    int child2; 
} b3TreeNodeChildren;

typedef struct b3TreeNode
{
    b3AABB aabb; // 24

    uint64_t categoryBits; // 8
 
    union
    {
        b3TreeNodeChildren children;

        uint64_t userData;
    }; // 8
 
    union
    {
        int parent;

        int next;
    }; // 4

    uint16_t height; // 2

    uint16_t flags; // 2
} b3TreeNode;

#define B3_DYNAMIC_TREE_VERSION 0x93EDAF889FD30B4Aull

typedef struct b3DynamicTree
{
    uint64_t version;

    b3TreeNode* nodes;

    int root;

    int nodeCount;

    int nodeCapacity;

    int proxyCount;

    int freeList;

    int* leafIndices;

    b3AABB* leafBoxes;

    b3Vec3* leafCenters;

    int* binIndices;

    int rebuildCapacity;
} b3DynamicTree;

typedef struct b3TreeStats
{
    int nodeVisits;

    int leafVisits;
} b3TreeStats;

typedef bool b3TreeQueryCallbackFcn( int proxyId, uint64_t userData, void* context );

typedef float b3TreeQueryClosestCallbackFcn( float distanceSqrMin, int proxyId, uint64_t userData, void* context );

typedef float b3TreeBoxCastCallbackFcn( const b3BoxCastInput* input, int proxyId, uint64_t userData, void* context );

typedef float b3TreeRayCastCallbackFcn( const b3RayCastInput* input, int proxyId, uint64_t userData, void* context );
 // tree


typedef struct b3PlaneResult
{
    b3Plane plane;

    b3Vec3 point;
 
} b3PlaneResult;

typedef struct b3CollisionPlane
{
    b3Plane plane;

    float pushLimit;

    float push;

    bool clipVelocity;
} b3CollisionPlane;

typedef struct b3PlaneSolverResult
{
    b3Vec3 delta;

    int iterationCount;
} b3PlaneSolverResult;

typedef struct b3BodyPlaneResult
{
    b3ShapeId shapeId;

    b3PlaneResult result;
} b3BodyPlaneResult;

typedef bool b3PlaneResultFcn( b3ShapeId shapeId, const b3PlaneResult* plane, int planeCount, void* context );

typedef bool b3MoverFilterFcn( b3ShapeId shapeId, void* context );
 // mover


typedef struct b3MassData
{
    float mass;

    b3Vec3 center;

    b3Matrix3 inertia;
} b3MassData;


typedef struct b3Sphere
{
    b3Vec3 center;

    float radius;
} b3Sphere;
 // sphere


typedef struct b3Capsule
{
    b3Vec3 center1;

    b3Vec3 center2;

    float radius;
} b3Capsule;
 // capsule


typedef struct b3HullVertex
{
    uint8_t edge;
} b3HullVertex;

typedef struct b3HullHalfEdge
{
    uint8_t next;

    uint8_t twin;

    uint8_t origin;

    uint8_t face;
} b3HullHalfEdge;

typedef struct b3HullFace
{
    uint8_t edge;
} b3HullFace;

#define B3_HULL_VERSION 0x9D4716CE3793900Eull

typedef struct b3HullData
{
    uint64_t version;

    int byteCount;

    uint32_t hash;

    b3AABB aabb;

    float surfaceArea;

    float volume;

    float innerRadius;

    b3Vec3 center;

    b3Matrix3 centralInertia;

    int vertexCount;

    int vertexOffset;

    int pointOffset;

    int edgeCount;

    int edgeOffset;

    int faceCount;

    int faceOffset;

    int planeOffset;

    int padding;
} b3HullData;

typedef struct b3BoxHull
{
    b3HullData base;
    b3HullVertex boxVertices[8]; 
    b3Vec3 boxPoints[8];         
    b3HullHalfEdge boxEdges[24]; 
    b3HullFace boxFaces[6];      
    uint8_t padding[2];          
    b3Plane boxPlanes[6];        
} b3BoxHull;
 // hull


typedef struct b3MeshDef
{
    b3Vec3* vertices;

    int32_t* indices;

    uint8_t* materialIndices;

    float weldTolerance;

    int vertexCount;

    int triangleCount;

    bool weldVertices;

    bool useMedianSplit;

    bool identifyEdges;
} b3MeshDef;

#define B3_MESH_VERSION 0xABD11AB62A6E886Dull

typedef enum b3MeshEdgeFlags
{
    b3_concaveEdge1 = 0x01,
    b3_concaveEdge2 = 0x02,
    b3_concaveEdge3 = 0x04,
 
    b3_inverseConcaveEdge1 = 0x10,
    b3_inverseConcaveEdge2 = 0x20,
    b3_inverseConcaveEdge3 = 0x40,
 
    b3_allConcaveEdges = b3_concaveEdge1 | b3_concaveEdge2 | b3_concaveEdge3,
 
    b3_flatEdge1 = b3_concaveEdge1 | b3_inverseConcaveEdge1,
    b3_flatEdge2 = b3_concaveEdge2 | b3_inverseConcaveEdge2,
    b3_flatEdge3 = b3_concaveEdge3 | b3_inverseConcaveEdge3,
 
    b3_allFlatEdges = b3_flatEdge1 | b3_flatEdge2 | b3_flatEdge3,
 
} b3MeshEdgeFlags;

typedef struct b3MeshTriangle
{
    int32_t index1; 
    int32_t index2; 
    int32_t index3; 
} b3MeshTriangle;

typedef struct b3MeshNode
{
    b3Vec3 lowerBound;

    union
    {
        struct
        {
            uint32_t axis : 2;
            uint32_t childOffset : 30;
        } asNode;

        struct
        {
            uint32_t type : 2;

            uint32_t triangleCount : 30;
        } asLeaf;
    } data;

    b3Vec3 upperBound;

    uint32_t triangleOffset;
} b3MeshNode;

typedef struct b3MeshData
{
    uint64_t version;

    int byteCount;

    uint32_t hash;

    b3AABB bounds;

    float surfaceArea;

    int treeHeight;

    int degenerateCount;

    int nodeOffset;

    int nodeCount;

    int vertexOffset;

    int vertexCount;

    int triangleOffset;

    int triangleCount;

    int materialOffset;

    int materialCount;

    int flagsOffset;
} b3MeshData;

typedef struct b3Mesh
{
    const b3MeshData* data;

    b3Vec3 scale;
} b3Mesh;
 // mesh


typedef struct b3HeightFieldDef
{
    float* heights;

    uint8_t* materialIndices;

    b3Vec3 scale;

    int countX;

    int countZ;

    float globalMinimumHeight;

    float globalMaximumHeight;

    bool clockwiseWinding;
} b3HeightFieldDef;

#define B3_HEIGHT_FIELD_HOLE 0xFF

#define B3_HEIGHT_FIELD_VERSION 0x8B18CBD138A6BC84ull

typedef struct b3HeightFieldData
{
    uint64_t version;

    int byteCount;

    uint32_t hash;

    b3AABB aabb;

    float minHeight;

    float maxHeight;

    float heightScale;

    b3Vec3 scale;

    int columnCount;

    int rowCount;

    int heightsOffset;

    int materialOffset;

    int flagsOffset;

    bool clockwise;

    uint8_t padding[3];
} b3HeightFieldData;
 // height_field


typedef struct b3CompoundCapsuleDef
{
    b3Capsule capsule;

    b3SurfaceMaterial material;
} b3CompoundCapsuleDef;

typedef struct b3CompoundHullDef
{
    const b3HullData* hull;

    b3Transform transform;

    b3SurfaceMaterial material;
} b3CompoundHullDef;

typedef struct b3CompoundMeshDef
{
    const b3MeshData* meshData;

    b3Transform transform;

    b3Vec3 scale;

    const b3SurfaceMaterial* materials;

    int materialCount;
} b3CompoundMeshDef;

typedef struct b3CompoundSphereDef
{
    b3Sphere sphere;

    b3SurfaceMaterial material;
} b3CompoundSphereDef;

typedef struct b3CompoundDef
{
    b3CompoundCapsuleDef* capsules;

    int capsuleCount;

    b3CompoundHullDef* hulls;

    int hullCount;

    b3CompoundMeshDef* meshes;

    int meshCount;

    b3CompoundSphereDef* spheres;

    int sphereCount;
} b3CompoundDef;

#define B3_COMPOUND_VERSION ( 0x830778DB07086EB4ull ^ B3_DYNAMIC_TREE_VERSION ^ B3_MESH_VERSION ^ B3_HULL_VERSION )

#define B3_MAX_COMPOUND_MESH_MATERIALS 4

typedef struct b3CompoundData
{
    uint64_t version;

    int byteCount;

    int nodeOffset;

    b3DynamicTree tree;

    int materialOffset;

    int materialCount;

    int capsuleOffset;

    int capsuleCount;

    int hullOffset;

    int hullCount;

    int sharedHullCount;

    int meshOffset;

    int meshCount;

    int sharedMeshCount;

    int sphereOffset;

    int sphereCount;
} b3CompoundData;

typedef struct b3CompoundCapsule
{
    b3Capsule capsule;

    int materialIndex;
} b3CompoundCapsule;

typedef struct b3CompoundHull
{
    const b3HullData* hull;

    b3Transform transform;

    int materialIndex;
} b3CompoundHull;

typedef struct b3CompoundMesh
{
    const b3MeshData* meshData;

    b3Transform transform;

    b3Vec3 scale;

    int materialIndices[B3_MAX_COMPOUND_MESH_MATERIALS];
} b3CompoundMesh;

typedef struct b3CompoundSphere
{
    b3Sphere sphere;

    int materialIndex;
} b3CompoundSphere;

typedef struct b3ChildShape
{
    union
    {
        b3Capsule capsule;  
        const b3HullData* hull; 
        b3Mesh mesh;        
        b3Sphere sphere;    
    };

    b3Transform transform;

    int materialIndices[B3_MAX_COMPOUND_MESH_MATERIALS];

    b3ShapeType type;
} b3ChildShape;

typedef bool b3CompoundQueryFcn( const b3CompoundData* compound, int childIndex, void* context );
 // compound
 // geometry


typedef struct b3ManifoldPoint
{
    b3Vec3 anchorA;

    b3Vec3 anchorB;

    float separation;

    float baseSeparation;

    float normalImpulse;

    float totalNormalImpulse;

    float normalVelocity;

    uint32_t featureId;

    int triangleIndex;

    bool persisted;
} b3ManifoldPoint;

typedef struct b3Manifold
{
    b3ManifoldPoint points[B3_MAX_MANIFOLD_POINTS];

    b3Vec3 normal;

    float twistImpulse;

    b3Vec3 frictionImpulse;

    b3Vec3 rollingImpulse;

    int pointCount;
 
} b3Manifold;

typedef enum
{
    b3_invalidAxis = 0,
    b3_backsideAxis,
    b3_faceAxisA,
    b3_faceAxisB,
    b3_edgePairAxis,
    b3_closestPointsAxis,

    b3_manualFaceAxisA,
    b3_manualFaceAxisB,
    b3_manualEdgePairAxis,
} b3SeparatingFeature;

typedef enum
{
    b3_featureNone = 0,
    b3_featureTriangleFace,
    b3_featureHullFace,
    b3_featureEdge1,
    b3_featureEdge2,
    b3_featureEdge3,
    b3_featureVertex1,
    b3_featureVertex2,
    b3_featureVertex3
} b3TriangleFeature;

typedef struct
{
    float separation;

    uint8_t type;

    uint8_t indexA;

    uint8_t indexB;

    uint8_t hit;
} b3SATCache;

typedef struct b3FeaturePair
{
    uint8_t owner1;
    uint8_t index1;
    uint8_t owner2;
    uint8_t index2;
} b3FeaturePair;

typedef struct b3LocalManifoldPoint
{
    b3Vec3 point;

    float separation;

    b3FeaturePair pair;

    int triangleIndex;
} b3LocalManifoldPoint;

typedef struct b3LocalManifold
{
    b3Vec3 normal;

    b3Vec3 triangleNormal;

    b3LocalManifoldPoint* points;

    int pointCount;

    int triangleIndex;
 
    int i1; 
    int i2; 
    int i3; 

    float squaredDistance;

    b3TriangleFeature feature;

    int triangleFlags;
} b3LocalManifold;
 // collision


typedef enum b3HexColor
{
    b3_colorAliceBlue = 0xF0F8FF,
    b3_colorAntiqueWhite = 0xFAEBD7,
    b3_colorAqua = 0x00FFFF,
    b3_colorAquamarine = 0x7FFFD4,
    b3_colorAzure = 0xF0FFFF,
    b3_colorBeige = 0xF5F5DC,
    b3_colorBisque = 0xFFE4C4,
    b3_colorBlack = 0x000000,
    b3_colorBlanchedAlmond = 0xFFEBCD,
    b3_colorBlue = 0x0000FF,
    b3_colorBlueViolet = 0x8A2BE2,
    b3_colorBrown = 0xA52A2A,
    b3_colorBurlywood = 0xDEB887,
    b3_colorCadetBlue = 0x5F9EA0,
    b3_colorChartreuse = 0x7FFF00,
    b3_colorChocolate = 0xD2691E,
    b3_colorCoral = 0xFF7F50,
    b3_colorCornflowerBlue = 0x6495ED,
    b3_colorCornsilk = 0xFFF8DC,
    b3_colorCrimson = 0xDC143C,
    b3_colorCyan = 0x00FFFF,
    b3_colorDarkBlue = 0x00008B,
    b3_colorDarkCyan = 0x008B8B,
    b3_colorDarkGoldenRod = 0xB8860B,
    b3_colorDarkGray = 0xA9A9A9,
    b3_colorDarkGreen = 0x006400,
    b3_colorDarkKhaki = 0xBDB76B,
    b3_colorDarkMagenta = 0x8B008B,
    b3_colorDarkOliveGreen = 0x556B2F,
    b3_colorDarkOrange = 0xFF8C00,
    b3_colorDarkOrchid = 0x9932CC,
    b3_colorDarkRed = 0x8B0000,
    b3_colorDarkSalmon = 0xE9967A,
    b3_colorDarkSeaGreen = 0x8FBC8F,
    b3_colorDarkSlateBlue = 0x483D8B,
    b3_colorDarkSlateGray = 0x2F4F4F,
    b3_colorDarkTurquoise = 0x00CED1,
    b3_colorDarkViolet = 0x9400D3,
    b3_colorDeepPink = 0xFF1493,
    b3_colorDeepSkyBlue = 0x00BFFF,
    b3_colorDimGray = 0x696969,
    b3_colorDodgerBlue = 0x1E90FF,
    b3_colorFireBrick = 0xB22222,
    b3_colorFloralWhite = 0xFFFAF0,
    b3_colorForestGreen = 0x228B22,
    b3_colorFuchsia = 0xFF00FF,
    b3_colorGainsboro = 0xDCDCDC,
    b3_colorGhostWhite = 0xF8F8FF,
    b3_colorGold = 0xFFD700,
    b3_colorGoldenRod = 0xDAA520,
    b3_colorGray = 0x808080,
    b3_colorGreen = 0x008000,
    b3_colorGreenYellow = 0xADFF2F,
    b3_colorHoneyDew = 0xF0FFF0,
    b3_colorHotPink = 0xFF69B4,
    b3_colorIndianRed = 0xCD5C5C,
    b3_colorIndigo = 0x4B0082,
    b3_colorIvory = 0xFFFFF0,
    b3_colorKhaki = 0xF0E68C,
    b3_colorLavender = 0xE6E6FA,
    b3_colorLavenderBlush = 0xFFF0F5,
    b3_colorLawnGreen = 0x7CFC00,
    b3_colorLemonChiffon = 0xFFFACD,
    b3_colorLightBlue = 0xADD8E6,
    b3_colorLightCoral = 0xF08080,
    b3_colorLightCyan = 0xE0FFFF,
    b3_colorLightGoldenRodYellow = 0xFAFAD2,
    b3_colorLightGray = 0xD3D3D3,
    b3_colorLightGreen = 0x90EE90,
    b3_colorLightPink = 0xFFB6C1,
    b3_colorLightSalmon = 0xFFA07A,
    b3_colorLightSeaGreen = 0x20B2AA,
    b3_colorLightSkyBlue = 0x87CEFA,
    b3_colorLightSlateGray = 0x778899,
    b3_colorLightSteelBlue = 0xB0C4DE,
    b3_colorLightYellow = 0xFFFFE0,
    b3_colorLime = 0x00FF00,
    b3_colorLimeGreen = 0x32CD32,
    b3_colorLinen = 0xFAF0E6,
    b3_colorMagenta = 0xFF00FF,
    b3_colorMaroon = 0x800000,
    b3_colorMediumAquaMarine = 0x66CDAA,
    b3_colorMediumBlue = 0x0000CD,
    b3_colorMediumOrchid = 0xBA55D3,
    b3_colorMediumPurple = 0x9370DB,
    b3_colorMediumSeaGreen = 0x3CB371,
    b3_colorMediumSlateBlue = 0x7B68EE,
    b3_colorMediumSpringGreen = 0x00FA9A,
    b3_colorMediumTurquoise = 0x48D1CC,
    b3_colorMediumVioletRed = 0xC71585,
    b3_colorMidnightBlue = 0x191970,
    b3_colorMintCream = 0xF5FFFA,
    b3_colorMistyRose = 0xFFE4E1,
    b3_colorMoccasin = 0xFFE4B5,
    b3_colorNavajoWhite = 0xFFDEAD,
    b3_colorNavy = 0x000080,
    b3_colorOldLace = 0xFDF5E6,
    b3_colorOlive = 0x808000,
    b3_colorOliveDrab = 0x6B8E23,
    b3_colorOrange = 0xFFA500,
    b3_colorOrangeRed = 0xFF4500,
    b3_colorOrchid = 0xDA70D6,
    b3_colorPaleGoldenRod = 0xEEE8AA,
    b3_colorPaleGreen = 0x98FB98,
    b3_colorPaleTurquoise = 0xAFEEEE,
    b3_colorPaleVioletRed = 0xDB7093,
    b3_colorPapayaWhip = 0xFFEFD5,
    b3_colorPeachPuff = 0xFFDAB9,
    b3_colorPeru = 0xCD853F,
    b3_colorPink = 0xFFC0CB,
    b3_colorPlum = 0xDDA0DD,
    b3_colorPowderBlue = 0xB0E0E6,
    b3_colorPurple = 0x800080,
    b3_colorRebeccaPurple = 0x663399,
    b3_colorRed = 0xFF0000,
    b3_colorRosyBrown = 0xBC8F8F,
    b3_colorRoyalBlue = 0x4169E1,
    b3_colorSaddleBrown = 0x8B4513,
    b3_colorSalmon = 0xFA8072,
    b3_colorSandyBrown = 0xF4A460,
    b3_colorSeaGreen = 0x2E8B57,
    b3_colorSeaShell = 0xFFF5EE,
    b3_colorSienna = 0xA0522D,
    b3_colorSilver = 0xC0C0C0,
    b3_colorSkyBlue = 0x87CEEB,
    b3_colorSlateBlue = 0x6A5ACD,
    b3_colorSlateGray = 0x708090,
    b3_colorSnow = 0xFFFAFA,
    b3_colorSpringGreen = 0x00FF7F,
    b3_colorSteelBlue = 0x4682B4,
    b3_colorTan = 0xD2B48C,
    b3_colorTeal = 0x008080,
    b3_colorThistle = 0xD8BFD8,
    b3_colorTomato = 0xFF6347,
    b3_colorTurquoise = 0x40E0D0,
    b3_colorViolet = 0xEE82EE,
    b3_colorWheat = 0xF5DEB3,
    b3_colorWhite = 0xFFFFFF,
    b3_colorWhiteSmoke = 0xF5F5F5,
    b3_colorYellow = 0xFFFF00,
    b3_colorYellowGreen = 0x9ACD32,
 
    b3_colorBox2DRed = 0xDC3132,
    b3_colorBox2DBlue = 0x30AEBF,
    b3_colorBox2DGreen = 0x8CC924,
    b3_colorBox2DYellow = 0xFFEE8C
} b3HexColor;

typedef enum b3DebugMaterial
{
    b3_debugMaterialDefault = 0,
    b3_debugMaterialMatte,
    b3_debugMaterialSoft,
    b3_debugMaterialDead,
    b3_debugMaterialGlossy,
    b3_debugMaterialMetallic
} b3DebugMaterial;

B3_INLINE uint32_t b3MakeDebugColor( b3HexColor rgb, b3DebugMaterial material )
{
    return ( (uint32_t)rgb & 0x00FFFFFFu ) | ( (uint32_t)material << 24 );
}

B3_API b3HexColor b3GetGraphColor( int index );

typedef struct b3DebugShape
{
    b3ShapeId shapeId;

    b3ShapeType type;

    union
    {
        const b3Capsule* capsule;         
        const b3CompoundData* compound;       
        const b3HeightFieldData* heightField; 
        const b3HullData* hull;           
        const b3Mesh* mesh;               
        const b3Sphere* sphere;           
    };
} b3DebugShape;

typedef struct b3DebugDraw
{
    bool ( *DrawShapeFcn )( void* userShape, b3WorldTransform transform, b3HexColor color, void* context );

    void ( *DrawSegmentFcn )( b3Pos p1, b3Pos p2, b3HexColor color, void* context );

    void ( *DrawTransformFcn )( b3WorldTransform transform, void* context );

    void ( *DrawPointFcn )( b3Pos p, float size, b3HexColor color, void* context );

    void ( *DrawSphereFcn )( b3Pos p, float radius, b3HexColor color, float alpha, void* context );

    void ( *DrawCapsuleFcn )( b3Pos p1, b3Pos p2, float radius, b3HexColor color, float alpha, void* context );

    void ( *DrawBoundsFcn )( b3AABB aabb, b3HexColor color, void* context );

    void ( *DrawBoxFcn )( b3Vec3 extents, b3WorldTransform transform, b3HexColor color, void* context );

    void ( *DrawStringFcn )( b3Pos p, const char* s, b3HexColor color, void* context );

    b3AABB drawingBounds;

    float forceScale;

    float jointScale;

    bool drawShapes;

    bool drawJoints;

    bool drawJointExtras;

    bool drawBounds;

    bool drawMass;

    bool drawBodyNames;

    bool drawContacts;

    int drawAnchorA;

    bool drawGraphColors;

    bool drawContactFeatures;

    bool drawContactNormals;

    bool drawContactForces;

    bool drawFrictionForces;

    bool drawIslands;

    void* context;
} b3DebugDraw;

B3_API b3DebugDraw b3DefaultDebugDraw( void );
 // debug_draw