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

#include "box2d_gen_shim.h"

void hsg_b2World_GetBounds(b2WorldId a0, b2AABB* out)
{
	*out = b2World_GetBounds(a0);
}

void hsg_b2World_GetBodyEvents(b2WorldId a0, b2BodyEvents* out)
{
	*out = b2World_GetBodyEvents(a0);
}

void hsg_b2World_GetSensorEvents(b2WorldId a0, b2SensorEvents* out)
{
	*out = b2World_GetSensorEvents(a0);
}

void hsg_b2World_GetContactEvents(b2WorldId a0, b2ContactEvents* out)
{
	*out = b2World_GetContactEvents(a0);
}

void hsg_b2World_GetJointEvents(b2WorldId a0, b2JointEvents* out)
{
	*out = b2World_GetJointEvents(a0);
}

void hsg_b2World_OverlapAABB(b2WorldId a0, const b2Pos* a1, const b2AABB* a2, const b2QueryFilter* a3, b2OverlapResultFcn* a4, void* a5, b2TreeStats* out)
{
	*out = b2World_OverlapAABB(a0, *a1, *a2, *a3, a4, a5);
}

void hsg_b2World_OverlapShape(b2WorldId a0, const b2Pos* a1, const b2ShapeProxy* a2, const b2QueryFilter* a3, b2OverlapResultFcn* a4, void* a5, b2TreeStats* out)
{
	*out = b2World_OverlapShape(a0, *a1, a2, *a3, a4, a5);
}

void hsg_b2World_CastRay(b2WorldId a0, const b2Pos* a1, const b2Vec2* a2, const b2QueryFilter* a3, b2CastResultFcn* a4, void* a5, b2TreeStats* out)
{
	*out = b2World_CastRay(a0, *a1, *a2, *a3, a4, a5);
}

void hsg_b2World_CastRayClosest(b2WorldId a0, const b2Pos* a1, const b2Vec2* a2, const b2QueryFilter* a3, b2RayResult* out)
{
	*out = b2World_CastRayClosest(a0, *a1, *a2, *a3);
}

void hsg_b2World_CastShape(b2WorldId a0, const b2Pos* a1, const b2ShapeProxy* a2, const b2Vec2* a3, const b2QueryFilter* a4, b2CastResultFcn* a5, void* a6, b2TreeStats* out)
{
	*out = b2World_CastShape(a0, *a1, a2, *a3, *a4, a5, a6);
}

float hsg_b2World_CastMover(b2WorldId a0, const b2Pos* a1, const b2Capsule* a2, const b2Vec2* a3, const b2QueryFilter* a4)
{
	return b2World_CastMover(a0, *a1, a2, *a3, *a4);
}

void hsg_b2World_CollideMover(b2WorldId a0, const b2Pos* a1, const b2Capsule* a2, const b2QueryFilter* a3, b2PlaneResultFcn* a4, void* a5)
{
	b2World_CollideMover(a0, *a1, a2, *a3, a4, a5);
}

void hsg_b2World_SetGravity(b2WorldId a0, const b2Vec2* a1)
{
	b2World_SetGravity(a0, *a1);
}

void hsg_b2World_GetGravity(b2WorldId a0, b2Vec2* out)
{
	*out = b2World_GetGravity(a0);
}

void hsg_b2World_GetProfile(b2WorldId a0, b2Profile* out)
{
	*out = b2World_GetProfile(a0);
}

void hsg_b2World_GetCounters(b2WorldId a0, b2Counters* out)
{
	*out = b2World_GetCounters(a0);
}

void hsg_b2World_GetMaxCapacity(b2WorldId a0, b2Capacity* out)
{
	*out = b2World_GetMaxCapacity(a0);
}

void hsg_b2Body_GetPosition(b2BodyId a0, b2Pos* out)
{
	*out = b2Body_GetPosition(a0);
}

void hsg_b2Body_GetRotation(b2BodyId a0, b2Rot* out)
{
	*out = b2Body_GetRotation(a0);
}

void hsg_b2Body_GetTransform(b2BodyId a0, b2WorldTransform* out)
{
	*out = b2Body_GetTransform(a0);
}

void hsg_b2Body_SetTransform(b2BodyId a0, const b2Pos* a1, const b2Rot* a2)
{
	b2Body_SetTransform(a0, *a1, *a2);
}

void hsg_b2Body_GetLocalPoint(b2BodyId a0, const b2Pos* a1, b2Vec2* out)
{
	*out = b2Body_GetLocalPoint(a0, *a1);
}

void hsg_b2Body_GetWorldPoint(b2BodyId a0, const b2Vec2* a1, b2Pos* out)
{
	*out = b2Body_GetWorldPoint(a0, *a1);
}

void hsg_b2Body_GetLocalVector(b2BodyId a0, const b2Vec2* a1, b2Vec2* out)
{
	*out = b2Body_GetLocalVector(a0, *a1);
}

void hsg_b2Body_GetWorldVector(b2BodyId a0, const b2Vec2* a1, b2Vec2* out)
{
	*out = b2Body_GetWorldVector(a0, *a1);
}

void hsg_b2Body_GetLinearVelocity(b2BodyId a0, b2Vec2* out)
{
	*out = b2Body_GetLinearVelocity(a0);
}

void hsg_b2Body_SetLinearVelocity(b2BodyId a0, const b2Vec2* a1)
{
	b2Body_SetLinearVelocity(a0, *a1);
}

void hsg_b2Body_SetTargetTransform(b2BodyId a0, const b2WorldTransform* a1, float a2, bool a3)
{
	b2Body_SetTargetTransform(a0, *a1, a2, a3);
}

void hsg_b2Body_GetLocalPointVelocity(b2BodyId a0, const b2Vec2* a1, b2Vec2* out)
{
	*out = b2Body_GetLocalPointVelocity(a0, *a1);
}

void hsg_b2Body_GetWorldPointVelocity(b2BodyId a0, const b2Pos* a1, b2Vec2* out)
{
	*out = b2Body_GetWorldPointVelocity(a0, *a1);
}

void hsg_b2Body_ApplyForce(b2BodyId a0, const b2Vec2* a1, const b2Pos* a2, bool a3)
{
	b2Body_ApplyForce(a0, *a1, *a2, a3);
}

void hsg_b2Body_ApplyForceToCenter(b2BodyId a0, const b2Vec2* a1, bool a2)
{
	b2Body_ApplyForceToCenter(a0, *a1, a2);
}

void hsg_b2Body_ApplyLinearImpulse(b2BodyId a0, const b2Vec2* a1, const b2Pos* a2, bool a3)
{
	b2Body_ApplyLinearImpulse(a0, *a1, *a2, a3);
}

void hsg_b2Body_ApplyLinearImpulseToCenter(b2BodyId a0, const b2Vec2* a1, bool a2)
{
	b2Body_ApplyLinearImpulseToCenter(a0, *a1, a2);
}

void hsg_b2Body_GetLocalCenter(b2BodyId a0, b2Vec2* out)
{
	*out = b2Body_GetLocalCenter(a0);
}

void hsg_b2Body_GetWorldCenter(b2BodyId a0, b2Pos* out)
{
	*out = b2Body_GetWorldCenter(a0);
}

void hsg_b2Body_SetMassData(b2BodyId a0, const b2MassData* a1)
{
	b2Body_SetMassData(a0, *a1);
}

void hsg_b2Body_GetMassData(b2BodyId a0, b2MassData* out)
{
	*out = b2Body_GetMassData(a0);
}

void hsg_b2Body_SetMotionLocks(b2BodyId a0, const b2MotionLocks* a1)
{
	b2Body_SetMotionLocks(a0, *a1);
}

void hsg_b2Body_GetMotionLocks(b2BodyId a0, b2MotionLocks* out)
{
	*out = b2Body_GetMotionLocks(a0);
}

void hsg_b2Body_ComputeAABB(b2BodyId a0, b2AABB* out)
{
	*out = b2Body_ComputeAABB(a0);
}

void hsg_b2Shape_GetSurfaceMaterial(b2ShapeId a0, b2SurfaceMaterial* out)
{
	*out = b2Shape_GetSurfaceMaterial(a0);
}

void hsg_b2Shape_GetFilter(b2ShapeId a0, b2Filter* out)
{
	*out = b2Shape_GetFilter(a0);
}

void hsg_b2Shape_SetFilter(b2ShapeId a0, const b2Filter* a1)
{
	b2Shape_SetFilter(a0, *a1);
}

bool hsg_b2Shape_TestPoint(b2ShapeId a0, const b2Pos* a1)
{
	return b2Shape_TestPoint(a0, *a1);
}

void hsg_b2Shape_RayCast(b2ShapeId a0, const b2Pos* a1, const b2Vec2* a2, b2WorldCastOutput* out)
{
	*out = b2Shape_RayCast(a0, *a1, *a2);
}

void hsg_b2Shape_GetCircle(b2ShapeId a0, b2Circle* out)
{
	*out = b2Shape_GetCircle(a0);
}

void hsg_b2Shape_GetSegment(b2ShapeId a0, b2Segment* out)
{
	*out = b2Shape_GetSegment(a0);
}

void hsg_b2Shape_GetChainSegment(b2ShapeId a0, b2ChainSegment* out)
{
	*out = b2Shape_GetChainSegment(a0);
}

void hsg_b2Shape_GetCapsule(b2ShapeId a0, b2Capsule* out)
{
	*out = b2Shape_GetCapsule(a0);
}

void hsg_b2Shape_GetPolygon(b2ShapeId a0, b2Polygon* out)
{
	*out = b2Shape_GetPolygon(a0);
}

void hsg_b2Shape_GetAABB(b2ShapeId a0, b2AABB* out)
{
	*out = b2Shape_GetAABB(a0);
}

void hsg_b2Shape_ComputeMassData(b2ShapeId a0, b2MassData* out)
{
	*out = b2Shape_ComputeMassData(a0);
}

void hsg_b2Shape_GetClosestPoint(b2ShapeId a0, const b2Pos* a1, b2Pos* out)
{
	*out = b2Shape_GetClosestPoint(a0, *a1);
}

void hsg_b2Shape_ApplyWind(b2ShapeId a0, const b2Vec2* a1, float a2, float a3, bool a4)
{
	b2Shape_ApplyWind(a0, *a1, a2, a3, a4);
}

void hsg_b2Chain_GetSurfaceMaterial(b2ChainId a0, int a1, b2SurfaceMaterial* out)
{
	*out = b2Chain_GetSurfaceMaterial(a0, a1);
}

void hsg_b2Joint_SetLocalFrameA(b2JointId a0, const b2Transform* a1)
{
	b2Joint_SetLocalFrameA(a0, *a1);
}

void hsg_b2Joint_GetLocalFrameA(b2JointId a0, b2Transform* out)
{
	*out = b2Joint_GetLocalFrameA(a0);
}

void hsg_b2Joint_SetLocalFrameB(b2JointId a0, const b2Transform* a1)
{
	b2Joint_SetLocalFrameB(a0, *a1);
}

void hsg_b2Joint_GetLocalFrameB(b2JointId a0, b2Transform* out)
{
	*out = b2Joint_GetLocalFrameB(a0);
}

void hsg_b2Joint_GetConstraintForce(b2JointId a0, b2Vec2* out)
{
	*out = b2Joint_GetConstraintForce(a0);
}

void hsg_b2MotorJoint_SetLinearVelocity(b2JointId a0, const b2Vec2* a1)
{
	b2MotorJoint_SetLinearVelocity(a0, *a1);
}

void hsg_b2MotorJoint_GetLinearVelocity(b2JointId a0, b2Vec2* out)
{
	*out = b2MotorJoint_GetLinearVelocity(a0);
}

bool hsg_b2Contact_IsValid(const b2ContactId* a0)
{
	return b2Contact_IsValid(*a0);
}

void hsg_b2Contact_GetData(const b2ContactId* a0, b2ContactData* out)
{
	*out = b2Contact_GetData(*a0);
}

void hsg_b2RecPlayer_GetInfo(const b2RecPlayer* a0, b2RecPlayerInfo* out)
{
	*out = b2RecPlayer_GetInfo(a0);
}

void hsg_b2RecPlayer_GetFrameQuery(const b2RecPlayer* a0, int a1, b2RecQueryInfo* out)
{
	*out = b2RecPlayer_GetFrameQuery(a0, a1);
}

void hsg_b2RecPlayer_GetFrameQueryHit(const b2RecPlayer* a0, int a1, int a2, b2RecQueryHit* out)
{
	*out = b2RecPlayer_GetFrameQueryHit(a0, a1, a2);
}

void hsg_b2MakePolygon(const b2Hull* a0, float a1, b2Polygon* out)
{
	*out = b2MakePolygon(a0, a1);
}

void hsg_b2MakeOffsetPolygon(const b2Hull* a0, const b2Vec2* a1, const b2Rot* a2, b2Polygon* out)
{
	*out = b2MakeOffsetPolygon(a0, *a1, *a2);
}

void hsg_b2MakeOffsetRoundedPolygon(const b2Hull* a0, const b2Vec2* a1, const b2Rot* a2, float a3, b2Polygon* out)
{
	*out = b2MakeOffsetRoundedPolygon(a0, *a1, *a2, a3);
}

void hsg_b2MakeSquare(float a0, b2Polygon* out)
{
	*out = b2MakeSquare(a0);
}

void hsg_b2MakeBox(float a0, float a1, b2Polygon* out)
{
	*out = b2MakeBox(a0, a1);
}

void hsg_b2MakeRoundedBox(float a0, float a1, float a2, b2Polygon* out)
{
	*out = b2MakeRoundedBox(a0, a1, a2);
}

void hsg_b2MakeOffsetBox(float a0, float a1, const b2Vec2* a2, const b2Rot* a3, b2Polygon* out)
{
	*out = b2MakeOffsetBox(a0, a1, *a2, *a3);
}

void hsg_b2MakeOffsetRoundedBox(float a0, float a1, const b2Vec2* a2, const b2Rot* a3, float a4, b2Polygon* out)
{
	*out = b2MakeOffsetRoundedBox(a0, a1, *a2, *a3, a4);
}

void hsg_b2TransformPolygon(const b2Transform* a0, const b2Polygon* a1, b2Polygon* out)
{
	*out = b2TransformPolygon(*a0, a1);
}

void hsg_b2ComputeCircleMass(const b2Circle* a0, float a1, b2MassData* out)
{
	*out = b2ComputeCircleMass(a0, a1);
}

void hsg_b2ComputeCapsuleMass(const b2Capsule* a0, float a1, b2MassData* out)
{
	*out = b2ComputeCapsuleMass(a0, a1);
}

void hsg_b2ComputePolygonMass(const b2Polygon* a0, float a1, b2MassData* out)
{
	*out = b2ComputePolygonMass(a0, a1);
}

void hsg_b2ComputeCircleAABB(const b2Circle* a0, const b2WorldTransform* a1, b2AABB* out)
{
	*out = b2ComputeCircleAABB(a0, *a1);
}

void hsg_b2ComputeCapsuleAABB(const b2Capsule* a0, const b2WorldTransform* a1, b2AABB* out)
{
	*out = b2ComputeCapsuleAABB(a0, *a1);
}

void hsg_b2ComputePolygonAABB(const b2Polygon* a0, const b2WorldTransform* a1, b2AABB* out)
{
	*out = b2ComputePolygonAABB(a0, *a1);
}

void hsg_b2ComputeSegmentAABB(const b2Segment* a0, const b2WorldTransform* a1, b2AABB* out)
{
	*out = b2ComputeSegmentAABB(a0, *a1);
}

bool hsg_b2PointInCircle(const b2Circle* a0, const b2Vec2* a1)
{
	return b2PointInCircle(a0, *a1);
}

bool hsg_b2PointInCapsule(const b2Capsule* a0, const b2Vec2* a1)
{
	return b2PointInCapsule(a0, *a1);
}

bool hsg_b2PointInPolygon(const b2Polygon* a0, const b2Vec2* a1)
{
	return b2PointInPolygon(a0, *a1);
}

void hsg_b2RayCastCircle(const b2Circle* a0, const b2RayCastInput* a1, b2CastOutput* out)
{
	*out = b2RayCastCircle(a0, a1);
}

void hsg_b2RayCastCapsule(const b2Capsule* a0, const b2RayCastInput* a1, b2CastOutput* out)
{
	*out = b2RayCastCapsule(a0, a1);
}

void hsg_b2RayCastSegment(const b2Segment* a0, const b2RayCastInput* a1, bool a2, b2CastOutput* out)
{
	*out = b2RayCastSegment(a0, a1, a2);
}

void hsg_b2RayCastPolygon(const b2Polygon* a0, const b2RayCastInput* a1, b2CastOutput* out)
{
	*out = b2RayCastPolygon(a0, a1);
}

void hsg_b2ShapeCastCircle(const b2Circle* a0, const b2ShapeCastInput* a1, b2CastOutput* out)
{
	*out = b2ShapeCastCircle(a0, a1);
}

void hsg_b2ShapeCastCapsule(const b2Capsule* a0, const b2ShapeCastInput* a1, b2CastOutput* out)
{
	*out = b2ShapeCastCapsule(a0, a1);
}

void hsg_b2ShapeCastSegment(const b2Segment* a0, const b2ShapeCastInput* a1, b2CastOutput* out)
{
	*out = b2ShapeCastSegment(a0, a1);
}

void hsg_b2ShapeCastPolygon(const b2Polygon* a0, const b2ShapeCastInput* a1, b2CastOutput* out)
{
	*out = b2ShapeCastPolygon(a0, a1);
}

void hsg_b2ComputeHull(const b2Vec2* a0, int a1, b2Hull* out)
{
	*out = b2ComputeHull(a0, a1);
}

void hsg_b2SegmentDistance(const b2Vec2* a0, const b2Vec2* a1, const b2Vec2* a2, const b2Vec2* a3, b2SegmentDistanceResult* out)
{
	*out = b2SegmentDistance(*a0, *a1, *a2, *a3);
}

void hsg_b2ShapeDistance(const b2DistanceInput* a0, b2SimplexCache* a1, b2Simplex* a2, int a3, b2DistanceOutput* out)
{
	*out = b2ShapeDistance(a0, a1, a2, a3);
}

void hsg_b2ShapeCast(const b2ShapeCastPairInput* a0, b2CastOutput* out)
{
	*out = b2ShapeCast(a0);
}

void hsg_b2MakeProxy(const b2Vec2* a0, int a1, float a2, b2ShapeProxy* out)
{
	*out = b2MakeProxy(a0, a1, a2);
}

void hsg_b2MakeOffsetProxy(const b2Vec2* a0, int a1, float a2, const b2Vec2* a3, const b2Rot* a4, b2ShapeProxy* out)
{
	*out = b2MakeOffsetProxy(a0, a1, a2, *a3, *a4);
}

void hsg_b2GetSweepTransform(const b2Sweep* a0, float a1, b2Transform* out)
{
	*out = b2GetSweepTransform(a0, a1);
}

void hsg_b2TimeOfImpact(const b2TOIInput* a0, b2TOIOutput* out)
{
	*out = b2TimeOfImpact(a0);
}

void hsg_b2CollideCircles(const b2Circle* a0, const b2Circle* a1, const b2Transform* a2, b2LocalManifold* out)
{
	*out = b2CollideCircles(a0, a1, *a2);
}

void hsg_b2CollideCapsuleAndCircle(const b2Capsule* a0, const b2Circle* a1, const b2Transform* a2, b2LocalManifold* out)
{
	*out = b2CollideCapsuleAndCircle(a0, a1, *a2);
}

void hsg_b2CollideSegmentAndCircle(const b2Segment* a0, const b2Circle* a1, const b2Transform* a2, b2LocalManifold* out)
{
	*out = b2CollideSegmentAndCircle(a0, a1, *a2);
}

void hsg_b2CollidePolygonAndCircle(const b2Polygon* a0, const b2Circle* a1, const b2Transform* a2, b2LocalManifold* out)
{
	*out = b2CollidePolygonAndCircle(a0, a1, *a2);
}

void hsg_b2CollideCapsules(const b2Capsule* a0, const b2Capsule* a1, const b2Transform* a2, b2LocalManifold* out)
{
	*out = b2CollideCapsules(a0, a1, *a2);
}

void hsg_b2CollideSegmentAndCapsule(const b2Segment* a0, const b2Capsule* a1, const b2Transform* a2, b2LocalManifold* out)
{
	*out = b2CollideSegmentAndCapsule(a0, a1, *a2);
}

void hsg_b2CollidePolygonAndCapsule(const b2Polygon* a0, const b2Capsule* a1, const b2Transform* a2, b2LocalManifold* out)
{
	*out = b2CollidePolygonAndCapsule(a0, a1, *a2);
}

void hsg_b2CollidePolygons(const b2Polygon* a0, const b2Polygon* a1, const b2Transform* a2, b2LocalManifold* out)
{
	*out = b2CollidePolygons(a0, a1, *a2);
}

void hsg_b2CollideSegmentAndPolygon(const b2Segment* a0, const b2Polygon* a1, const b2Transform* a2, b2LocalManifold* out)
{
	*out = b2CollideSegmentAndPolygon(a0, a1, *a2);
}

void hsg_b2CollideChainSegmentAndCircle(const b2ChainSegment* a0, const b2Circle* a1, const b2Transform* a2, b2LocalManifold* out)
{
	*out = b2CollideChainSegmentAndCircle(a0, a1, *a2);
}

void hsg_b2CollideChainSegmentAndCapsule(const b2ChainSegment* a0, const b2Capsule* a1, const b2Transform* a2, b2SimplexCache* a3, b2LocalManifold* out)
{
	*out = b2CollideChainSegmentAndCapsule(a0, a1, *a2, a3);
}

void hsg_b2CollideChainSegmentAndPolygon(const b2ChainSegment* a0, const b2Polygon* a1, const b2Transform* a2, b2SimplexCache* a3, b2LocalManifold* out)
{
	*out = b2CollideChainSegmentAndPolygon(a0, a1, *a2, a3);
}

void hsg_b2DynamicTree_Create(int a0, b2DynamicTree* out)
{
	*out = b2DynamicTree_Create(a0);
}

int hsg_b2DynamicTree_CreateProxy(b2DynamicTree* a0, const b2AABB* a1, uint64_t a2, uint64_t a3)
{
	return b2DynamicTree_CreateProxy(a0, *a1, a2, a3);
}

void hsg_b2DynamicTree_MoveProxy(b2DynamicTree* a0, int a1, const b2AABB* a2)
{
	b2DynamicTree_MoveProxy(a0, a1, *a2);
}

void hsg_b2DynamicTree_EnlargeProxy(b2DynamicTree* a0, int a1, const b2AABB* a2)
{
	b2DynamicTree_EnlargeProxy(a0, a1, *a2);
}

void hsg_b2DynamicTree_Query(const b2DynamicTree* a0, const b2AABB* a1, uint64_t a2, b2TreeQueryCallbackFcn* a3, void* a4, b2TreeStats* out)
{
	*out = b2DynamicTree_Query(a0, *a1, a2, a3, a4);
}

void hsg_b2DynamicTree_QueryAll(const b2DynamicTree* a0, const b2AABB* a1, b2TreeQueryCallbackFcn* a2, void* a3, b2TreeStats* out)
{
	*out = b2DynamicTree_QueryAll(a0, *a1, a2, a3);
}

void hsg_b2DynamicTree_RayCast(const b2DynamicTree* a0, const b2RayCastInput* a1, uint64_t a2, b2TreeRayCastCallbackFcn* a3, void* a4, b2TreeStats* out)
{
	*out = b2DynamicTree_RayCast(a0, a1, a2, a3, a4);
}

void hsg_b2DynamicTree_BoxCast(const b2DynamicTree* a0, const b2BoxCastInput* a1, uint64_t a2, b2TreeBoxCastCallbackFcn* a3, void* a4, b2TreeStats* out)
{
	*out = b2DynamicTree_BoxCast(a0, a1, a2, a3, a4);
}

void hsg_b2DynamicTree_GetRootBounds(const b2DynamicTree* a0, b2AABB* out)
{
	*out = b2DynamicTree_GetRootBounds(a0);
}

void hsg_b2DynamicTree_GetAABB(const b2DynamicTree* a0, int a1, b2AABB* out)
{
	*out = b2DynamicTree_GetAABB(a0, a1);
}

void hsg_b2SolvePlanes(const b2Vec2* a0, b2CollisionPlane* a1, int a2, b2PlaneSolverResult* out)
{
	*out = b2SolvePlanes(*a0, a1, a2);
}

void hsg_b2ClipVector(const b2Vec2* a0, const b2CollisionPlane* a1, int a2, b2Vec2* out)
{
	*out = b2ClipVector(*a0, a1, a2);
}