// SPDX-License-Identifier: BSD-3-Clause
//
// Generated by boxnd-gen. See box3d_gen_shim.h.

#include "box3d_gen_shim.h"

void hsg_b3World_GetBounds(b3WorldId a0, b3AABB* out)
{
	*out = b3World_GetBounds(a0);
}

void hsg_b3World_GetBodyEvents(b3WorldId a0, b3BodyEvents* out)
{
	*out = b3World_GetBodyEvents(a0);
}

void hsg_b3World_GetSensorEvents(b3WorldId a0, b3SensorEvents* out)
{
	*out = b3World_GetSensorEvents(a0);
}

void hsg_b3World_GetContactEvents(b3WorldId a0, b3ContactEvents* out)
{
	*out = b3World_GetContactEvents(a0);
}

void hsg_b3World_GetJointEvents(b3WorldId a0, b3JointEvents* out)
{
	*out = b3World_GetJointEvents(a0);
}

void hsg_b3World_OverlapAABB(b3WorldId a0, const b3AABB* a1, const b3QueryFilter* a2, b3OverlapResultFcn* a3, void* a4, b3TreeStats* out)
{
	*out = b3World_OverlapAABB(a0, *a1, *a2, a3, a4);
}

void hsg_b3World_OverlapShape(b3WorldId a0, const b3Pos* a1, const b3ShapeProxy* a2, const b3QueryFilter* a3, b3OverlapResultFcn* a4, void* a5, b3TreeStats* out)
{
	*out = b3World_OverlapShape(a0, *a1, a2, *a3, a4, a5);
}

void hsg_b3World_CastRay(b3WorldId a0, const b3Pos* a1, const b3Vec3* a2, const b3QueryFilter* a3, b3CastResultFcn* a4, void* a5, b3TreeStats* out)
{
	*out = b3World_CastRay(a0, *a1, *a2, *a3, a4, a5);
}

void hsg_b3World_CastRayClosest(b3WorldId a0, const b3Pos* a1, const b3Vec3* a2, const b3QueryFilter* a3, b3RayResult* out)
{
	*out = b3World_CastRayClosest(a0, *a1, *a2, *a3);
}

void hsg_b3World_CastShape(b3WorldId a0, const b3Pos* a1, const b3ShapeProxy* a2, const b3Vec3* a3, const b3QueryFilter* a4, b3CastResultFcn* a5, void* a6, b3TreeStats* out)
{
	*out = b3World_CastShape(a0, *a1, a2, *a3, *a4, a5, a6);
}

float hsg_b3World_CastMover(b3WorldId a0, const b3Pos* a1, const b3Capsule* a2, const b3Vec3* a3, const b3QueryFilter* a4, b3MoverFilterFcn* a5, void* a6)
{
	return b3World_CastMover(a0, *a1, a2, *a3, *a4, a5, a6);
}

void hsg_b3World_CollideMover(b3WorldId a0, const b3Pos* a1, const b3Capsule* a2, const b3QueryFilter* a3, b3PlaneResultFcn* a4, void* a5)
{
	b3World_CollideMover(a0, *a1, a2, *a3, a4, a5);
}

void hsg_b3World_SetGravity(b3WorldId a0, const b3Vec3* a1)
{
	b3World_SetGravity(a0, *a1);
}

void hsg_b3World_GetGravity(b3WorldId a0, b3Vec3* out)
{
	*out = b3World_GetGravity(a0);
}

void hsg_b3World_GetProfile(b3WorldId a0, b3Profile* out)
{
	*out = b3World_GetProfile(a0);
}

void hsg_b3World_GetCounters(b3WorldId a0, b3Counters* out)
{
	*out = b3World_GetCounters(a0);
}

void hsg_b3World_GetMaxCapacity(b3WorldId a0, b3Capacity* out)
{
	*out = b3World_GetMaxCapacity(a0);
}

void hsg_b3RecPlayer_GetInfo(const b3RecPlayer* a0, b3RecPlayerInfo* out)
{
	*out = b3RecPlayer_GetInfo(a0);
}

void hsg_b3RecPlayer_GetFrameQuery(const b3RecPlayer* a0, int a1, b3RecQueryInfo* out)
{
	*out = b3RecPlayer_GetFrameQuery(a0, a1);
}

void hsg_b3RecPlayer_GetFrameQueryHit(const b3RecPlayer* a0, int a1, int a2, b3RecQueryHit* out)
{
	*out = b3RecPlayer_GetFrameQueryHit(a0, a1, a2);
}

void hsg_b3Body_GetPosition(b3BodyId a0, b3Pos* out)
{
	*out = b3Body_GetPosition(a0);
}

void hsg_b3Body_GetRotation(b3BodyId a0, b3Quat* out)
{
	*out = b3Body_GetRotation(a0);
}

void hsg_b3Body_GetTransform(b3BodyId a0, b3WorldTransform* out)
{
	*out = b3Body_GetTransform(a0);
}

void hsg_b3Body_SetTransform(b3BodyId a0, const b3Pos* a1, const b3Quat* a2)
{
	b3Body_SetTransform(a0, *a1, *a2);
}

void hsg_b3Body_GetLocalPoint(b3BodyId a0, const b3Pos* a1, b3Vec3* out)
{
	*out = b3Body_GetLocalPoint(a0, *a1);
}

void hsg_b3Body_GetWorldPoint(b3BodyId a0, const b3Vec3* a1, b3Pos* out)
{
	*out = b3Body_GetWorldPoint(a0, *a1);
}

void hsg_b3Body_GetLocalVector(b3BodyId a0, const b3Vec3* a1, b3Vec3* out)
{
	*out = b3Body_GetLocalVector(a0, *a1);
}

void hsg_b3Body_GetWorldVector(b3BodyId a0, const b3Vec3* a1, b3Vec3* out)
{
	*out = b3Body_GetWorldVector(a0, *a1);
}

void hsg_b3Body_GetLinearVelocity(b3BodyId a0, b3Vec3* out)
{
	*out = b3Body_GetLinearVelocity(a0);
}

void hsg_b3Body_GetAngularVelocity(b3BodyId a0, b3Vec3* out)
{
	*out = b3Body_GetAngularVelocity(a0);
}

void hsg_b3Body_SetLinearVelocity(b3BodyId a0, const b3Vec3* a1)
{
	b3Body_SetLinearVelocity(a0, *a1);
}

void hsg_b3Body_SetAngularVelocity(b3BodyId a0, const b3Vec3* a1)
{
	b3Body_SetAngularVelocity(a0, *a1);
}

void hsg_b3Body_SetTargetTransform(b3BodyId a0, const b3WorldTransform* a1, float a2, bool a3)
{
	b3Body_SetTargetTransform(a0, *a1, a2, a3);
}

void hsg_b3Body_GetLocalPointVelocity(b3BodyId a0, const b3Vec3* a1, b3Vec3* out)
{
	*out = b3Body_GetLocalPointVelocity(a0, *a1);
}

void hsg_b3Body_GetWorldPointVelocity(b3BodyId a0, const b3Pos* a1, b3Vec3* out)
{
	*out = b3Body_GetWorldPointVelocity(a0, *a1);
}

void hsg_b3Body_ApplyForce(b3BodyId a0, const b3Vec3* a1, const b3Pos* a2, bool a3)
{
	b3Body_ApplyForce(a0, *a1, *a2, a3);
}

void hsg_b3Body_ApplyForceToCenter(b3BodyId a0, const b3Vec3* a1, bool a2)
{
	b3Body_ApplyForceToCenter(a0, *a1, a2);
}

void hsg_b3Body_ApplyTorque(b3BodyId a0, const b3Vec3* a1, bool a2)
{
	b3Body_ApplyTorque(a0, *a1, a2);
}

void hsg_b3Body_ApplyLinearImpulse(b3BodyId a0, const b3Vec3* a1, const b3Pos* a2, bool a3)
{
	b3Body_ApplyLinearImpulse(a0, *a1, *a2, a3);
}

void hsg_b3Body_ApplyLinearImpulseToCenter(b3BodyId a0, const b3Vec3* a1, bool a2)
{
	b3Body_ApplyLinearImpulseToCenter(a0, *a1, a2);
}

void hsg_b3Body_ApplyAngularImpulse(b3BodyId a0, const b3Vec3* a1, bool a2)
{
	b3Body_ApplyAngularImpulse(a0, *a1, a2);
}

void hsg_b3Body_GetLocalRotationalInertia(b3BodyId a0, b3Matrix3* out)
{
	*out = b3Body_GetLocalRotationalInertia(a0);
}

void hsg_b3Body_GetWorldInverseRotationalInertia(b3BodyId a0, b3Matrix3* out)
{
	*out = b3Body_GetWorldInverseRotationalInertia(a0);
}

void hsg_b3Body_GetLocalCenterOfMass(b3BodyId a0, b3Vec3* out)
{
	*out = b3Body_GetLocalCenterOfMass(a0);
}

void hsg_b3Body_GetWorldCenterOfMass(b3BodyId a0, b3Pos* out)
{
	*out = b3Body_GetWorldCenterOfMass(a0);
}

void hsg_b3Body_SetMassData(b3BodyId a0, const b3MassData* a1)
{
	b3Body_SetMassData(a0, *a1);
}

void hsg_b3Body_GetMassData(b3BodyId a0, b3MassData* out)
{
	*out = b3Body_GetMassData(a0);
}

void hsg_b3Body_SetMotionLocks(b3BodyId a0, const b3MotionLocks* a1)
{
	b3Body_SetMotionLocks(a0, *a1);
}

void hsg_b3Body_GetMotionLocks(b3BodyId a0, b3MotionLocks* out)
{
	*out = b3Body_GetMotionLocks(a0);
}

void hsg_b3Body_ComputeAABB(b3BodyId a0, b3AABB* out)
{
	*out = b3Body_ComputeAABB(a0);
}

float hsg_b3Body_GetClosestPoint(b3BodyId a0, b3Vec3* a1, const b3Vec3* a2)
{
	return b3Body_GetClosestPoint(a0, a1, *a2);
}

void hsg_b3Body_CastRay(b3BodyId a0, const b3Pos* a1, const b3Vec3* a2, const b3QueryFilter* a3, float a4, const b3WorldTransform* a5, b3BodyCastResult* out)
{
	*out = b3Body_CastRay(a0, *a1, *a2, *a3, a4, *a5);
}

void hsg_b3Body_CastShape(b3BodyId a0, const b3Pos* a1, const b3ShapeProxy* a2, const b3Vec3* a3, const b3QueryFilter* a4, float a5, bool a6, const b3WorldTransform* a7, b3BodyCastResult* out)
{
	*out = b3Body_CastShape(a0, *a1, a2, *a3, *a4, a5, a6, *a7);
}

bool hsg_b3Body_OverlapShape(b3BodyId a0, const b3Pos* a1, const b3ShapeProxy* a2, const b3QueryFilter* a3, const b3WorldTransform* a4)
{
	return b3Body_OverlapShape(a0, *a1, a2, *a3, *a4);
}

int hsg_b3Body_CollideMover(b3BodyId a0, b3BodyPlaneResult* a1, int a2, const b3Pos* a3, const b3Capsule* a4, const b3QueryFilter* a5, const b3WorldTransform* a6)
{
	return b3Body_CollideMover(a0, a1, a2, *a3, a4, *a5, *a6);
}

b3ShapeId hsg_b3CreateTransformedHullShape(b3BodyId a0, const b3ShapeDef* a1, const b3HullData* a2, const b3Transform* a3, const b3Vec3* a4)
{
	return b3CreateTransformedHullShape(a0, a1, a2, *a3, *a4);
}

b3ShapeId hsg_b3CreateMeshShape(b3BodyId a0, const b3ShapeDef* a1, const b3MeshData* a2, const b3Vec3* a3)
{
	return b3CreateMeshShape(a0, a1, a2, *a3);
}

void hsg_b3Shape_SetSurfaceMaterial(b3ShapeId a0, const b3SurfaceMaterial* a1)
{
	b3Shape_SetSurfaceMaterial(a0, *a1);
}

void hsg_b3Shape_GetSurfaceMaterial(b3ShapeId a0, b3SurfaceMaterial* out)
{
	*out = b3Shape_GetSurfaceMaterial(a0);
}

void hsg_b3Shape_SetMeshMaterial(b3ShapeId a0, const b3SurfaceMaterial* a1, int a2)
{
	b3Shape_SetMeshMaterial(a0, *a1, a2);
}

void hsg_b3Shape_GetMeshSurfaceMaterial(b3ShapeId a0, int a1, b3SurfaceMaterial* out)
{
	*out = b3Shape_GetMeshSurfaceMaterial(a0, a1);
}

void hsg_b3Shape_GetFilter(b3ShapeId a0, b3Filter* out)
{
	*out = b3Shape_GetFilter(a0);
}

void hsg_b3Shape_SetFilter(b3ShapeId a0, const b3Filter* a1, bool a2)
{
	b3Shape_SetFilter(a0, *a1, a2);
}

void hsg_b3Shape_RayCast(b3ShapeId a0, const b3Pos* a1, const b3Vec3* a2, b3WorldCastOutput* out)
{
	*out = b3Shape_RayCast(a0, *a1, *a2);
}

void hsg_b3Shape_GetSphere(b3ShapeId a0, b3Sphere* out)
{
	*out = b3Shape_GetSphere(a0);
}

void hsg_b3Shape_GetCapsule(b3ShapeId a0, b3Capsule* out)
{
	*out = b3Shape_GetCapsule(a0);
}

void hsg_b3Shape_GetMesh(b3ShapeId a0, b3Mesh* out)
{
	*out = b3Shape_GetMesh(a0);
}

void hsg_b3Shape_SetMesh(b3ShapeId a0, const b3MeshData* a1, const b3Vec3* a2)
{
	b3Shape_SetMesh(a0, a1, *a2);
}

void hsg_b3Shape_GetAABB(b3ShapeId a0, b3AABB* out)
{
	*out = b3Shape_GetAABB(a0);
}

void hsg_b3Shape_ComputeMassData(b3ShapeId a0, b3MassData* out)
{
	*out = b3Shape_ComputeMassData(a0);
}

void hsg_b3Shape_GetClosestPoint(b3ShapeId a0, const b3Vec3* a1, b3Vec3* out)
{
	*out = b3Shape_GetClosestPoint(a0, *a1);
}

void hsg_b3Shape_ApplyWind(b3ShapeId a0, const b3Vec3* a1, float a2, float a3, float a4, bool a5)
{
	b3Shape_ApplyWind(a0, *a1, a2, a3, a4, a5);
}

void hsg_b3Joint_SetLocalFrameA(b3JointId a0, const b3Transform* a1)
{
	b3Joint_SetLocalFrameA(a0, *a1);
}

void hsg_b3Joint_GetLocalFrameA(b3JointId a0, b3Transform* out)
{
	*out = b3Joint_GetLocalFrameA(a0);
}

void hsg_b3Joint_SetLocalFrameB(b3JointId a0, const b3Transform* a1)
{
	b3Joint_SetLocalFrameB(a0, *a1);
}

void hsg_b3Joint_GetLocalFrameB(b3JointId a0, b3Transform* out)
{
	*out = b3Joint_GetLocalFrameB(a0);
}

void hsg_b3Joint_GetConstraintForce(b3JointId a0, b3Vec3* out)
{
	*out = b3Joint_GetConstraintForce(a0);
}

void hsg_b3Joint_GetConstraintTorque(b3JointId a0, b3Vec3* out)
{
	*out = b3Joint_GetConstraintTorque(a0);
}

void hsg_b3MotorJoint_SetLinearVelocity(b3JointId a0, const b3Vec3* a1)
{
	b3MotorJoint_SetLinearVelocity(a0, *a1);
}

void hsg_b3MotorJoint_GetLinearVelocity(b3JointId a0, b3Vec3* out)
{
	*out = b3MotorJoint_GetLinearVelocity(a0);
}

void hsg_b3MotorJoint_SetAngularVelocity(b3JointId a0, const b3Vec3* a1)
{
	b3MotorJoint_SetAngularVelocity(a0, *a1);
}

void hsg_b3MotorJoint_GetAngularVelocity(b3JointId a0, b3Vec3* out)
{
	*out = b3MotorJoint_GetAngularVelocity(a0);
}

void hsg_b3SphericalJoint_SetTargetRotation(b3JointId a0, const b3Quat* a1)
{
	b3SphericalJoint_SetTargetRotation(a0, *a1);
}

void hsg_b3SphericalJoint_GetTargetRotation(b3JointId a0, b3Quat* out)
{
	*out = b3SphericalJoint_GetTargetRotation(a0);
}

void hsg_b3SphericalJoint_SetMotorVelocity(b3JointId a0, const b3Vec3* a1)
{
	b3SphericalJoint_SetMotorVelocity(a0, *a1);
}

void hsg_b3SphericalJoint_GetMotorVelocity(b3JointId a0, b3Vec3* out)
{
	*out = b3SphericalJoint_GetMotorVelocity(a0);
}

void hsg_b3SphericalJoint_GetMotorTorque(b3JointId a0, b3Vec3* out)
{
	*out = b3SphericalJoint_GetMotorTorque(a0);
}

bool hsg_b3Contact_IsValid(const b3ContactId* a0)
{
	return b3Contact_IsValid(*a0);
}

void hsg_b3Contact_GetData(const b3ContactId* a0, b3ContactData* out)
{
	*out = b3Contact_GetData(*a0);
}

void hsg_b3DynamicTree_Create(int a0, b3DynamicTree* out)
{
	*out = b3DynamicTree_Create(a0);
}

int hsg_b3DynamicTree_CreateProxy(b3DynamicTree* a0, const b3AABB* a1, uint64_t a2, uint64_t a3)
{
	return b3DynamicTree_CreateProxy(a0, *a1, a2, a3);
}

void hsg_b3DynamicTree_MoveProxy(b3DynamicTree* a0, int a1, const b3AABB* a2)
{
	b3DynamicTree_MoveProxy(a0, a1, *a2);
}

void hsg_b3DynamicTree_EnlargeProxy(b3DynamicTree* a0, int a1, const b3AABB* a2)
{
	b3DynamicTree_EnlargeProxy(a0, a1, *a2);
}

void hsg_b3DynamicTree_Query(const b3DynamicTree* a0, const b3AABB* a1, uint64_t a2, bool a3, b3TreeQueryCallbackFcn* a4, void* a5, b3TreeStats* out)
{
	*out = b3DynamicTree_Query(a0, *a1, a2, a3, a4, a5);
}

void hsg_b3DynamicTree_QueryClosest(const b3DynamicTree* a0, const b3Vec3* a1, uint64_t a2, bool a3, b3TreeQueryClosestCallbackFcn* a4, void* a5, float* a6, b3TreeStats* out)
{
	*out = b3DynamicTree_QueryClosest(a0, *a1, a2, a3, a4, a5, a6);
}

void hsg_b3DynamicTree_RayCast(const b3DynamicTree* a0, const b3RayCastInput* a1, uint64_t a2, bool a3, b3TreeRayCastCallbackFcn* a4, void* a5, b3TreeStats* out)
{
	*out = b3DynamicTree_RayCast(a0, a1, a2, a3, a4, a5);
}

void hsg_b3DynamicTree_BoxCast(const b3DynamicTree* a0, const b3BoxCastInput* a1, uint64_t a2, bool a3, b3TreeBoxCastCallbackFcn* a4, void* a5, b3TreeStats* out)
{
	*out = b3DynamicTree_BoxCast(a0, a1, a2, a3, a4, a5);
}

void hsg_b3DynamicTree_GetRootBounds(const b3DynamicTree* a0, b3AABB* out)
{
	*out = b3DynamicTree_GetRootBounds(a0);
}

void hsg_b3DynamicTree_Load(const char* a0, float a1, b3DynamicTree* out)
{
	*out = b3DynamicTree_Load(a0, a1);
}

b3HullData* hsg_b3CloneAndTransformHull(const b3HullData* a0, const b3Transform* a1, const b3Vec3* a2)
{
	return b3CloneAndTransformHull(a0, *a1, *a2);
}

void hsg_b3MakeCubeHull(float a0, b3BoxHull* out)
{
	*out = b3MakeCubeHull(a0);
}

void hsg_b3MakeBoxHull(float a0, float a1, float a2, b3BoxHull* out)
{
	*out = b3MakeBoxHull(a0, a1, a2);
}

void hsg_b3MakeOffsetBoxHull(float a0, float a1, float a2, const b3Vec3* a3, b3BoxHull* out)
{
	*out = b3MakeOffsetBoxHull(a0, a1, a2, *a3);
}

void hsg_b3MakeTransformedBoxHull(float a0, float a1, float a2, const b3Transform* a3, b3BoxHull* out)
{
	*out = b3MakeTransformedBoxHull(a0, a1, a2, *a3);
}

void hsg_b3MakeScaledBoxHull(const b3Vec3* a0, const b3Transform* a1, const b3Vec3* a2, b3BoxHull* out)
{
	*out = b3MakeScaledBoxHull(*a0, *a1, *a2);
}

void hsg_b3ScaleBox(b3Vec3* a0, b3Transform* a1, const b3Vec3* a2, float a3)
{
	b3ScaleBox(a0, a1, *a2, a3);
}

b3MeshData* hsg_b3CreateBoxMesh(const b3Vec3* a0, const b3Vec3* a1, bool a2)
{
	return b3CreateBoxMesh(*a0, *a1, a2);
}

b3MeshData* hsg_b3CreateHollowBoxMesh(const b3Vec3* a0, const b3Vec3* a1)
{
	return b3CreateHollowBoxMesh(*a0, *a1);
}

b3MeshData* hsg_b3CreatePlatformMesh(const b3Vec3* a0, float a1, float a2, float a3)
{
	return b3CreatePlatformMesh(*a0, a1, a2, a3);
}

b3HeightFieldData* hsg_b3CreateGrid(int a0, int a1, const b3Vec3* a2, bool a3)
{
	return b3CreateGrid(a0, a1, *a2, a3);
}

b3HeightFieldData* hsg_b3CreateWave(int a0, int a1, const b3Vec3* a2, float a3, float a4, bool a5)
{
	return b3CreateWave(a0, a1, *a2, a3, a4, a5);
}

void hsg_b3GetCompoundChild(const b3CompoundData* a0, int a1, b3ChildShape* out)
{
	*out = b3GetCompoundChild(a0, a1);
}

void hsg_b3QueryCompound(const b3CompoundData* a0, const b3AABB* a1, b3CompoundQueryFcn* a2, void* a3)
{
	b3QueryCompound(a0, *a1, a2, a3);
}

void hsg_b3GetCompoundCapsule(const b3CompoundData* a0, int a1, b3CompoundCapsule* out)
{
	*out = b3GetCompoundCapsule(a0, a1);
}

void hsg_b3GetCompoundHull(const b3CompoundData* a0, int a1, b3CompoundHull* out)
{
	*out = b3GetCompoundHull(a0, a1);
}

void hsg_b3GetCompoundMesh(const b3CompoundData* a0, int a1, b3CompoundMesh* out)
{
	*out = b3GetCompoundMesh(a0, a1);
}

void hsg_b3GetCompoundSphere(const b3CompoundData* a0, int a1, b3CompoundSphere* out)
{
	*out = b3GetCompoundSphere(a0, a1);
}

void hsg_b3ComputeSphereMass(const b3Sphere* a0, float a1, b3MassData* out)
{
	*out = b3ComputeSphereMass(a0, a1);
}

void hsg_b3ComputeCapsuleMass(const b3Capsule* a0, float a1, b3MassData* out)
{
	*out = b3ComputeCapsuleMass(a0, a1);
}

void hsg_b3ComputeHullMass(const b3HullData* a0, float a1, b3MassData* out)
{
	*out = b3ComputeHullMass(a0, a1);
}

void hsg_b3ComputeSphereAABB(const b3Sphere* a0, const b3Transform* a1, b3AABB* out)
{
	*out = b3ComputeSphereAABB(a0, *a1);
}

void hsg_b3ComputeCapsuleAABB(const b3Capsule* a0, const b3Transform* a1, b3AABB* out)
{
	*out = b3ComputeCapsuleAABB(a0, *a1);
}

void hsg_b3ComputeHullAABB(const b3HullData* a0, const b3Transform* a1, b3AABB* out)
{
	*out = b3ComputeHullAABB(a0, *a1);
}

void hsg_b3ComputeMeshAABB(const b3MeshData* a0, const b3Transform* a1, const b3Vec3* a2, b3AABB* out)
{
	*out = b3ComputeMeshAABB(a0, *a1, *a2);
}

void hsg_b3ComputeHeightFieldAABB(const b3HeightFieldData* a0, const b3Transform* a1, b3AABB* out)
{
	*out = b3ComputeHeightFieldAABB(a0, *a1);
}

void hsg_b3ComputeCompoundAABB(const b3CompoundData* a0, const b3Transform* a1, b3AABB* out)
{
	*out = b3ComputeCompoundAABB(a0, *a1);
}

bool hsg_b3OverlapCapsule(const b3Capsule* a0, const b3Transform* a1, const b3ShapeProxy* a2)
{
	return b3OverlapCapsule(a0, *a1, a2);
}

bool hsg_b3OverlapCompound(const b3CompoundData* a0, const b3Transform* a1, const b3ShapeProxy* a2)
{
	return b3OverlapCompound(a0, *a1, a2);
}

bool hsg_b3OverlapHeightField(const b3HeightFieldData* a0, const b3Transform* a1, const b3ShapeProxy* a2)
{
	return b3OverlapHeightField(a0, *a1, a2);
}

bool hsg_b3OverlapHull(const b3HullData* a0, const b3Transform* a1, const b3ShapeProxy* a2)
{
	return b3OverlapHull(a0, *a1, a2);
}

bool hsg_b3OverlapMesh(const b3Mesh* a0, const b3Transform* a1, const b3ShapeProxy* a2)
{
	return b3OverlapMesh(a0, *a1, a2);
}

bool hsg_b3OverlapSphere(const b3Sphere* a0, const b3Transform* a1, const b3ShapeProxy* a2)
{
	return b3OverlapSphere(a0, *a1, a2);
}

void hsg_b3RayCastSphere(const b3Sphere* a0, const b3RayCastInput* a1, b3CastOutput* out)
{
	*out = b3RayCastSphere(a0, a1);
}

void hsg_b3RayCastHollowSphere(const b3Sphere* a0, const b3RayCastInput* a1, b3CastOutput* out)
{
	*out = b3RayCastHollowSphere(a0, a1);
}

void hsg_b3RayCastCapsule(const b3Capsule* a0, const b3RayCastInput* a1, b3CastOutput* out)
{
	*out = b3RayCastCapsule(a0, a1);
}

void hsg_b3RayCastCompound(const b3CompoundData* a0, const b3RayCastInput* a1, b3CastOutput* out)
{
	*out = b3RayCastCompound(a0, a1);
}

void hsg_b3RayCastHull(const b3HullData* a0, const b3RayCastInput* a1, b3CastOutput* out)
{
	*out = b3RayCastHull(a0, a1);
}

void hsg_b3RayCastMesh(const b3Mesh* a0, const b3RayCastInput* a1, b3CastOutput* out)
{
	*out = b3RayCastMesh(a0, a1);
}

void hsg_b3RayCastHeightField(const b3HeightFieldData* a0, const b3RayCastInput* a1, b3CastOutput* out)
{
	*out = b3RayCastHeightField(a0, a1);
}

void hsg_b3ShapeCastSphere(const b3Sphere* a0, const b3ShapeCastInput* a1, b3CastOutput* out)
{
	*out = b3ShapeCastSphere(a0, a1);
}

void hsg_b3ShapeCastCapsule(const b3Capsule* a0, const b3ShapeCastInput* a1, b3CastOutput* out)
{
	*out = b3ShapeCastCapsule(a0, a1);
}

void hsg_b3ShapeCastCompound(const b3CompoundData* a0, const b3ShapeCastInput* a1, b3CastOutput* out)
{
	*out = b3ShapeCastCompound(a0, a1);
}

void hsg_b3ShapeCastHull(const b3HullData* a0, const b3ShapeCastInput* a1, b3CastOutput* out)
{
	*out = b3ShapeCastHull(a0, a1);
}

void hsg_b3ShapeCastMesh(const b3Mesh* a0, const b3ShapeCastInput* a1, b3CastOutput* out)
{
	*out = b3ShapeCastMesh(a0, a1);
}

void hsg_b3ShapeCastHeightField(const b3HeightFieldData* a0, const b3ShapeCastInput* a1, b3CastOutput* out)
{
	*out = b3ShapeCastHeightField(a0, a1);
}

void hsg_b3QueryMesh(const b3Mesh* a0, const b3AABB* a1, b3MeshQueryFcn* a2, void* a3)
{
	b3QueryMesh(a0, *a1, a2, a3);
}

void hsg_b3QueryHeightField(const b3HeightFieldData* a0, const b3AABB* a1, b3MeshQueryFcn* a2, void* a3)
{
	b3QueryHeightField(a0, *a1, a2, a3);
}

void hsg_b3ShapeDistance(const b3DistanceInput* a0, b3SimplexCache* a1, b3Simplex* a2, int a3, b3DistanceOutput* out)
{
	*out = b3ShapeDistance(a0, a1, a2, a3);
}

void hsg_b3ShapeCast(const b3ShapeCastPairInput* a0, b3CastOutput* out)
{
	*out = b3ShapeCast(a0);
}

void hsg_b3GetSweepTransform(const b3Sweep* a0, float a1, b3Transform* out)
{
	*out = b3GetSweepTransform(a0, a1);
}

void hsg_b3TimeOfImpact(const b3TOIInput* a0, b3TOIOutput* out)
{
	*out = b3TimeOfImpact(a0);
}

void hsg_b3CollideSpheres(b3LocalManifold* a0, int a1, const b3Sphere* a2, const b3Sphere* a3, const b3Transform* a4)
{
	b3CollideSpheres(a0, a1, a2, a3, *a4);
}

void hsg_b3CollideCapsuleAndSphere(b3LocalManifold* a0, int a1, const b3Capsule* a2, const b3Sphere* a3, const b3Transform* a4)
{
	b3CollideCapsuleAndSphere(a0, a1, a2, a3, *a4);
}

void hsg_b3CollideHullAndSphere(b3LocalManifold* a0, int a1, const b3HullData* a2, const b3Sphere* a3, const b3Transform* a4, b3SimplexCache* a5)
{
	b3CollideHullAndSphere(a0, a1, a2, a3, *a4, a5);
}

void hsg_b3CollideCapsules(b3LocalManifold* a0, int a1, const b3Capsule* a2, const b3Capsule* a3, const b3Transform* a4)
{
	b3CollideCapsules(a0, a1, a2, a3, *a4);
}

void hsg_b3CollideHullAndCapsule(b3LocalManifold* a0, int a1, const b3HullData* a2, const b3Capsule* a3, const b3Transform* a4, b3SimplexCache* a5)
{
	b3CollideHullAndCapsule(a0, a1, a2, a3, *a4, a5);
}

void hsg_b3CollideHulls(b3LocalManifold* a0, int a1, const b3HullData* a2, const b3HullData* a3, const b3Transform* a4, b3SATCache* a5)
{
	b3CollideHulls(a0, a1, a2, a3, *a4, a5);
}

void hsg_b3CollideHullAndTriangle(b3LocalManifold* a0, int a1, const b3HullData* a2, const b3Vec3* a3, const b3Vec3* a4, const b3Vec3* a5, int a6, b3SATCache* a7)
{
	b3CollideHullAndTriangle(a0, a1, a2, *a3, *a4, *a5, a6, a7);
}

void hsg_b3SolvePlanes(const b3Vec3* a0, b3CollisionPlane* a1, int a2, b3PlaneSolverResult* out)
{
	*out = b3SolvePlanes(*a0, a1, a2);
}

void hsg_b3ClipVector(const b3Vec3* a0, const b3CollisionPlane* a1, int a2, b3Vec3* out)
{
	*out = b3ClipVector(*a0, a1, a2);
}