collision.h

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


B3_API b3DynamicTree b3DynamicTree_Create( int proxyCapacity );

B3_API void b3DynamicTree_Destroy( b3DynamicTree* tree );

B3_API int b3DynamicTree_CreateProxy( b3DynamicTree* tree, b3AABB aabb, uint64_t categoryBits, uint64_t userData );

B3_API void b3DynamicTree_DestroyProxy( b3DynamicTree* tree, int proxyId );

B3_API void b3DynamicTree_MoveProxy( b3DynamicTree* tree, int proxyId, b3AABB aabb );

B3_API void b3DynamicTree_EnlargeProxy( b3DynamicTree* tree, int proxyId, b3AABB aabb );

B3_API void b3DynamicTree_SetCategoryBits( b3DynamicTree* tree, int proxyId, uint64_t categoryBits );

B3_API uint64_t b3DynamicTree_GetCategoryBits( b3DynamicTree* tree, int proxyId );

B3_API b3TreeStats b3DynamicTree_Query( const b3DynamicTree* tree, b3AABB aabb, uint64_t maskBits, bool requireAllBits,
                                        b3TreeQueryCallbackFcn* callback, void* context );

B3_API b3TreeStats b3DynamicTree_QueryClosest( const b3DynamicTree* tree, b3Vec3 point, uint64_t maskBits, bool requireAllBits,
                                               b3TreeQueryClosestCallbackFcn* callback, void* context, float* minDistanceSqr );

B3_API b3TreeStats b3DynamicTree_RayCast( const b3DynamicTree* tree, const b3RayCastInput* input, uint64_t maskBits,
                                          bool requireAllBits, b3TreeRayCastCallbackFcn* callback, void* context );

B3_API b3TreeStats b3DynamicTree_BoxCast( const b3DynamicTree* tree, const b3BoxCastInput* input, uint64_t maskBits,
                                          bool requireAllBits, b3TreeBoxCastCallbackFcn* callback, void* context );

B3_API int b3DynamicTree_GetHeight( const b3DynamicTree* tree );

B3_API float b3DynamicTree_GetAreaRatio( const b3DynamicTree* tree );

B3_API b3AABB b3DynamicTree_GetRootBounds( const b3DynamicTree* tree );

B3_API int b3DynamicTree_GetProxyCount( const b3DynamicTree* tree );

B3_API int b3DynamicTree_Rebuild( b3DynamicTree* tree, bool fullBuild );

B3_API int b3DynamicTree_GetByteCount( const b3DynamicTree* tree );

B3_API void b3DynamicTree_Validate( const b3DynamicTree* tree );

B3_API void b3DynamicTree_ValidateNoEnlarged( const b3DynamicTree* tree );

B3_API void b3DynamicTree_Save( const b3DynamicTree* tree, const char* fileName );

B3_API b3DynamicTree b3DynamicTree_Load( const char* fileName, float scale );

B3_INLINE uint64_t b3DynamicTree_GetUserData( const b3DynamicTree* tree, int proxyId )
{
    return tree->nodes[proxyId].userData;
}

B3_INLINE b3AABB b3DynamicTree_GetAABB( const b3DynamicTree* tree, int proxyId )
{
    return tree->nodes[proxyId].aabb;
}
 // tree


B3_INLINE const b3HullVertex* b3GetHullVertices( const b3HullData* hull )
{
    if ( hull->vertexOffset == 0 )
    {
        return NULL;
    }
 
    return (const b3HullVertex*)( (intptr_t)hull + hull->vertexOffset );
}

B3_INLINE const b3Vec3* b3GetHullPoints( const b3HullData* hull )
{
    if ( hull->pointOffset == 0 )
    {
        return NULL;
    }
 
    return (const b3Vec3*)( (intptr_t)hull + hull->pointOffset );
}

B3_INLINE const b3HullHalfEdge* b3GetHullEdges( const b3HullData* hull )
{
    if ( hull->edgeOffset == 0 )
    {
        return NULL;
    }
 
    return (const b3HullHalfEdge*)( (intptr_t)hull + hull->edgeOffset );
}

B3_INLINE const b3HullFace* b3GetHullFaces( const b3HullData* hull )
{
    if ( hull->faceOffset == 0 )
    {
        return NULL;
    }
 
    return (const b3HullFace*)( (intptr_t)hull + hull->faceOffset );
}

B3_INLINE const b3Plane* b3GetHullPlanes( const b3HullData* hull )
{
    if ( hull->planeOffset == 0 )
    {
        return NULL;
    }
 
    return (const b3Plane*)( (intptr_t)hull + hull->planeOffset );
}

B3_API b3HullData* b3CreateCylinder( float height, float radius, float yOffset, int sides );

B3_API b3HullData* b3CreateCone( float height, float radius1, float radius2, int slices );

B3_API b3HullData* b3CreateRock( float radius );

B3_API b3HullData* b3CreateHull( const b3Vec3* points, int pointCount, int maxVertexCount );

B3_API b3HullData* b3CloneHull( const b3HullData* hull );

B3_API b3HullData* b3CloneAndTransformHull( const b3HullData* original, b3Transform transform, b3Vec3 scale );

B3_API void b3DestroyHull( b3HullData* hull );

B3_API b3BoxHull b3MakeCubeHull( float halfWidth );

B3_API b3BoxHull b3MakeBoxHull( float hx, float hy, float hz );

B3_API b3BoxHull b3MakeOffsetBoxHull( float hx, float hy, float hz, b3Vec3 offset );

B3_API b3BoxHull b3MakeTransformedBoxHull( float hx, float hy, float hz, b3Transform transform );

B3_API b3BoxHull b3MakeScaledBoxHull( b3Vec3 halfWidths, b3Transform transform, b3Vec3 postScale );

B3_API void b3ScaleBox( b3Vec3* halfWidths, b3Transform* transform, b3Vec3 postScale, float minHalfWidth );
 // hull


B3_INLINE const b3MeshNode* b3GetMeshNodes( const b3MeshData* mesh )
{
    if ( mesh->nodeOffset == 0 )
    {
        return NULL;
    }
 
    return (const b3MeshNode*)( (intptr_t)mesh + mesh->nodeOffset );
}

B3_INLINE const b3Vec3* b3GetMeshVertices( const b3MeshData* mesh )
{
    if ( mesh->vertexOffset == 0 )
    {
        return NULL;
    }
 
    return (const b3Vec3*)( (intptr_t)mesh + mesh->vertexOffset );
}

B3_INLINE const b3MeshTriangle* b3GetMeshTriangles( const b3MeshData* mesh )
{
    if ( mesh->triangleOffset == 0 )
    {
        return NULL;
    }
 
    return (const b3MeshTriangle*)( (intptr_t)mesh + mesh->triangleOffset );
}

B3_INLINE const uint8_t* b3GetMeshMaterialIndices( const b3MeshData* mesh )
{
    if ( mesh->materialOffset == 0 )
    {
        return NULL;
    }
 
    return (const uint8_t*)( (intptr_t)mesh + mesh->materialOffset );
}

B3_INLINE const uint8_t* b3GetMeshFlags( const b3MeshData* mesh )
{
    if ( mesh->flagsOffset == 0 )
    {
        return NULL;
    }
 
    return (const uint8_t*)( (intptr_t)mesh + mesh->flagsOffset );
}

B3_API b3MeshData* b3CreateGridMesh( int xCount, int zCount, float cellWidth, int materialCount, bool identifyEdges );

B3_API b3MeshData* b3CreateWaveMesh( int xCount, int zCount, float cellWidth, float amplitude, float rowFrequency,
                                     float columnFrequency );

B3_API b3MeshData* b3CreateTorusMesh( int radialResolution, int tubularResolution, float radius, float thickness );

B3_API b3MeshData* b3CreateBoxMesh( b3Vec3 center, b3Vec3 extent, bool identifyEdges );

B3_API b3MeshData* b3CreateHollowBoxMesh( b3Vec3 center, b3Vec3 extent );

B3_API b3MeshData* b3CreatePlatformMesh( b3Vec3 center, float height, float topWidth, float bottomWidth );

B3_API b3MeshData* b3CreateMesh( const b3MeshDef* def, int* degenerateTriangleIndices, int degenerateCapacity );

B3_API void b3DestroyMesh( b3MeshData* mesh );

B3_API int b3GetHeight( const b3MeshData* mesh );
 // mesh


B3_INLINE const uint16_t* b3GetHeightFieldCompressedHeights( const b3HeightFieldData* hf )
{
    if ( hf->heightsOffset == 0 )
    {
        return NULL;
    }
 
    return (const uint16_t*)( (intptr_t)hf + hf->heightsOffset );
}

B3_INLINE const uint8_t* b3GetHeightFieldMaterialIndices( const b3HeightFieldData* hf )
{
    if ( hf->materialOffset == 0 )
    {
        return NULL;
    }
 
    return (const uint8_t*)( (intptr_t)hf + hf->materialOffset );
}

B3_INLINE const uint8_t* b3GetHeightFieldFlags( const b3HeightFieldData* hf )
{
    if ( hf->flagsOffset == 0 )
    {
        return NULL;
    }
 
    return (const uint8_t*)( (intptr_t)hf + hf->flagsOffset );
}

B3_API b3HeightFieldData* b3CreateHeightField( const b3HeightFieldDef* data );

B3_API b3HeightFieldData* b3CreateGrid( int rowCount, int columnCount, b3Vec3 scale, bool makeHoles );

B3_API b3HeightFieldData* b3CreateWave( int rowCount, int columnCount, b3Vec3 scale, float rowFrequency, float columnFrequency,
                                        bool makeHoles );

B3_API void b3DestroyHeightField( b3HeightFieldData* heightField );

B3_API void b3DumpHeightData( const b3HeightFieldDef* data, const char* fileName );

B3_API b3HeightFieldData* b3LoadHeightField( const char* fileName );
 // height_field


B3_API b3ChildShape b3GetCompoundChild( const b3CompoundData* compound, int childIndex );

B3_API void b3QueryCompound( const b3CompoundData* compound, b3AABB aabb, b3CompoundQueryFcn* fcn, void* context );

B3_API b3CompoundCapsule b3GetCompoundCapsule( const b3CompoundData* compound, int index );

B3_API b3CompoundHull b3GetCompoundHull( const b3CompoundData* compound, int index );

B3_API b3CompoundMesh b3GetCompoundMesh( const b3CompoundData* compound, int index );

B3_API b3CompoundSphere b3GetCompoundSphere( const b3CompoundData* compound, int index );

B3_API const b3SurfaceMaterial* b3GetCompoundMaterials( const b3CompoundData* compound );

B3_API b3CompoundData* b3CreateCompound( const b3CompoundDef* def );

B3_API void b3DestroyCompound( b3CompoundData* compound );

B3_API uint8_t* b3ConvertCompoundToBytes( b3CompoundData* compound );

B3_API b3CompoundData* b3ConvertBytesToCompound( uint8_t* bytes, int byteCount );
 // compound


B3_API b3MassData b3ComputeSphereMass( const b3Sphere* shape, float density );

B3_API b3MassData b3ComputeCapsuleMass( const b3Capsule* shape, float density );

B3_API b3MassData b3ComputeHullMass( const b3HullData* shape, float density );

B3_API b3AABB b3ComputeSphereAABB( const b3Sphere* shape, b3Transform transform );

B3_API b3AABB b3ComputeCapsuleAABB( const b3Capsule* shape, b3Transform transform );

B3_API b3AABB b3ComputeHullAABB( const b3HullData* shape, b3Transform transform );

B3_API b3AABB b3ComputeMeshAABB( const b3MeshData* shape, b3Transform transform, b3Vec3 scale );

B3_API b3AABB b3ComputeHeightFieldAABB( const b3HeightFieldData* shape, b3Transform transform );

B3_API b3AABB b3ComputeCompoundAABB( const b3CompoundData* shape, b3Transform transform );
 // geometry


B3_API bool b3IsValidRay( const b3RayCastInput* input );

B3_API bool b3OverlapCapsule( const b3Capsule* shape, b3Transform shapeTransform, const b3ShapeProxy* proxy );

B3_API bool b3OverlapCompound( const b3CompoundData* shape, b3Transform shapeTransform, const b3ShapeProxy* proxy );

B3_API bool b3OverlapHeightField( const b3HeightFieldData* shape, b3Transform shapeTransform, const b3ShapeProxy* proxy );

B3_API bool b3OverlapHull( const b3HullData* shape, b3Transform shapeTransform, const b3ShapeProxy* proxy );

B3_API bool b3OverlapMesh( const b3Mesh* shape, b3Transform shapeTransform, const b3ShapeProxy* proxy );

B3_API bool b3OverlapSphere( const b3Sphere* shape, b3Transform shapeTransform, const b3ShapeProxy* proxy );

B3_API b3CastOutput b3RayCastSphere( const b3Sphere* shape, const b3RayCastInput* input );

B3_API b3CastOutput b3RayCastHollowSphere( const b3Sphere* shape, const b3RayCastInput* input );

B3_API b3CastOutput b3RayCastCapsule( const b3Capsule* shape, const b3RayCastInput* input );

B3_API b3CastOutput b3RayCastCompound( const b3CompoundData* shape, const b3RayCastInput* input );

B3_API b3CastOutput b3RayCastHull( const b3HullData* shape, const b3RayCastInput* input );

B3_API b3CastOutput b3RayCastMesh( const b3Mesh* shape, const b3RayCastInput* input );

B3_API b3CastOutput b3RayCastHeightField( const b3HeightFieldData* shape, const b3RayCastInput* input );

B3_API b3CastOutput b3ShapeCastSphere( const b3Sphere* shape, const b3ShapeCastInput* input );

B3_API b3CastOutput b3ShapeCastCapsule( const b3Capsule* shape, const b3ShapeCastInput* input );

B3_API b3CastOutput b3ShapeCastCompound( const b3CompoundData* shape, const b3ShapeCastInput* input );

B3_API b3CastOutput b3ShapeCastHull( const b3HullData* shape, const b3ShapeCastInput* input );

B3_API b3CastOutput b3ShapeCastMesh( const b3Mesh* shape, const b3ShapeCastInput* input );

B3_API b3CastOutput b3ShapeCastHeightField( const b3HeightFieldData* shape, const b3ShapeCastInput* input );

typedef bool b3MeshQueryFcn( b3Vec3 a, b3Vec3 b, b3Vec3 c, int triangleIndex, void* context );

B3_API void b3QueryMesh( const b3Mesh* mesh, const b3AABB bounds, b3MeshQueryFcn* fcn, void* context );

B3_API void b3QueryHeightField( const b3HeightFieldData* heightField, b3AABB bounds, b3MeshQueryFcn* fcn, void* context );

B3_API b3DistanceOutput b3ShapeDistance( const b3DistanceInput* input, b3SimplexCache* cache, b3Simplex* simplexes,
                                         int simplexCapacity );

B3_API b3CastOutput b3ShapeCast( const b3ShapeCastPairInput* input );

B3_API b3Transform b3GetSweepTransform( const b3Sweep* sweep, float time );

B3_API b3TOIOutput b3TimeOfImpact( const b3TOIInput* input );
 // query


B3_API void b3CollideSpheres( b3LocalManifold* manifold, int capacity, const b3Sphere* sphereA, const b3Sphere* sphereB,
                              b3Transform transformBtoA );

B3_API void b3CollideCapsuleAndSphere( b3LocalManifold* manifold, int capacity, const b3Capsule* capsuleA,
                                       const b3Sphere* sphereB, b3Transform transformBtoA );

B3_API void b3CollideHullAndSphere( b3LocalManifold* manifold, int capacity, const b3HullData* hullA, const b3Sphere* sphereB,
                                    b3Transform transformBtoA, b3SimplexCache* cache );

B3_API void b3CollideCapsules( b3LocalManifold* manifold, int capacity, const b3Capsule* capsuleA, const b3Capsule* capsuleB,
                               b3Transform transformBtoA );

B3_API void b3CollideHullAndCapsule( b3LocalManifold* manifold, int capacity, const b3HullData* hullA, const b3Capsule* capsuleB,
                                     b3Transform transformBtoA, b3SimplexCache* cache );

B3_API void b3CollideHulls( b3LocalManifold* manifold, int capacity, const b3HullData* hullA, const b3HullData* hullB,
                            b3Transform transformBtoA, b3SATCache* cache );

B3_API void b3CollideCapsuleAndTriangle( b3LocalManifold* manifold, int capacity, const b3Capsule* capsuleA,
                                         const b3Vec3* triangleB, b3SimplexCache* cache );

B3_API void b3CollideHullAndTriangle( b3LocalManifold* manifold, int capacity, const b3HullData* hullA, b3Vec3 v1, b3Vec3 v2,
                                      b3Vec3 v3, int triangleFlags, b3SATCache* cache );

B3_API void b3CollideSphereAndTriangle( b3LocalManifold* manifold, int capacity, const b3Sphere* sphereA,
                                        const b3Vec3* triangleB );
 // collision


B3_API b3PlaneSolverResult b3SolvePlanes( b3Vec3 targetDelta, b3CollisionPlane* planes, int count );

B3_API b3Vec3 b3ClipVector( b3Vec3 vector, const b3CollisionPlane* planes, int count );
 // character