Puppet2D.Engine/B2.cs - master - EugenyCh7/Puppet2D.Net

Puppet2D.Engine/B2.cs
2 569 строк127 KB
EugenyCh7
Puppet2D.Engine.Common fix
24 авг 2025, 20:51
24 авг 2025, 20:51bac0272
using Puppet2D.Engine.Common;
using Puppet2D.System;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Security;

#pragma warning disable CS0649
namespace Puppet2D.Engine
{
    [SuppressUnmanagedCodeSecurity]
    internal static unsafe partial class B2
    {
        public partial class BindgenInternal
        {
            public const string DllImportPath = @"box2d";
        }

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2AABB_Center", CallingConvention = CallingConvention.Cdecl)]
        public static extern Vector2 AABBCenter(AABB a);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2AABB_Contains", CallingConvention = CallingConvention.Cdecl)]
        [return: MarshalAs(UnmanagedType.U1)] public static extern bool AABBContains(AABB a, AABB b);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2AABB_Extents", CallingConvention = CallingConvention.Cdecl)]
        public static extern Vector2 AABBExtents(AABB a);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2AABB_Union", CallingConvention = CallingConvention.Cdecl)]
        public static extern AABB AABBUnion(AABB a, AABB b);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Abs", CallingConvention = CallingConvention.Cdecl)]
        public static extern Vector2 Abs(Vector2 a);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2AbsFloat", CallingConvention = CallingConvention.Cdecl)]
        public static extern float AbsFloat(float a);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2AbsInt", CallingConvention = CallingConvention.Cdecl)]
        public static extern int AbsInt(int a);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Add", CallingConvention = CallingConvention.Cdecl)]
        public static extern Vector2 Add(Vector2 a, Vector2 b);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Atan2", CallingConvention = CallingConvention.Cdecl)]
        public static extern float Atan2(float y, float x);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Body_ApplyAngularImpulse", CallingConvention = CallingConvention.Cdecl)]
        public static extern void BodyApplyAngularImpulse(BodyId bodyId, float impulse, [MarshalAs(UnmanagedType.U1)] bool wake);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Body_ApplyForce", CallingConvention = CallingConvention.Cdecl)]
        public static extern void BodyApplyForce(BodyId bodyId, Vector2 force, Vector2 point, [MarshalAs(UnmanagedType.U1)] bool wake);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Body_ApplyForceToCenter", CallingConvention = CallingConvention.Cdecl)]
        public static extern void BodyApplyForceToCenter(BodyId bodyId, Vector2 force, [MarshalAs(UnmanagedType.U1)] bool wake);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Body_ApplyLinearImpulse", CallingConvention = CallingConvention.Cdecl)]
        public static extern void BodyApplyLinearImpulse(BodyId bodyId, Vector2 impulse, Vector2 point, [MarshalAs(UnmanagedType.U1)] bool wake);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Body_ApplyLinearImpulseToCenter", CallingConvention = CallingConvention.Cdecl)]
        public static extern void BodyApplyLinearImpulseToCenter(BodyId bodyId, Vector2 impulse, [MarshalAs(UnmanagedType.U1)] bool wake);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Body_ApplyMassFromShapes", CallingConvention = CallingConvention.Cdecl)]
        public static extern void BodyApplyMassFromShapes(BodyId bodyId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Body_ApplyTorque", CallingConvention = CallingConvention.Cdecl)]
        public static extern void BodyApplyTorque(BodyId bodyId, float torque, [MarshalAs(UnmanagedType.U1)] bool wake);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Body_ComputeAABB", CallingConvention = CallingConvention.Cdecl)]
        public static extern AABB BodyComputeAABB(BodyId bodyId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Body_Disable", CallingConvention = CallingConvention.Cdecl)]
        public static extern void BodyDisable(BodyId bodyId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Body_Enable", CallingConvention = CallingConvention.Cdecl)]
        public static extern void BodyEnable(BodyId bodyId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Body_EnableContactEvents", CallingConvention = CallingConvention.Cdecl)]
        public static extern void BodyEnableContactEvents(BodyId bodyId, [MarshalAs(UnmanagedType.U1)] bool flag);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Body_EnableHitEvents", CallingConvention = CallingConvention.Cdecl)]
        public static extern void BodyEnableHitEvents(BodyId bodyId, [MarshalAs(UnmanagedType.U1)] bool flag);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Body_EnableSleep", CallingConvention = CallingConvention.Cdecl)]
        public static extern void BodyEnableSleep(BodyId bodyId, [MarshalAs(UnmanagedType.U1)] bool enableSleep);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Body_GetAngularDamping", CallingConvention = CallingConvention.Cdecl)]
        public static extern float BodyGetAngularDamping(BodyId bodyId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Body_GetAngularVelocity", CallingConvention = CallingConvention.Cdecl)]
        public static extern float BodyGetAngularVelocity(BodyId bodyId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Body_GetContactCapacity", CallingConvention = CallingConvention.Cdecl)]
        public static extern int BodyGetContactCapacity(BodyId bodyId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Body_GetContactData", CallingConvention = CallingConvention.Cdecl)]
        public static extern int BodyGetContactData(BodyId bodyId, ContactData* contactData, int capacity);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Body_GetGravityScale", CallingConvention = CallingConvention.Cdecl)]
        public static extern float BodyGetGravityScale(BodyId bodyId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Body_GetJointCount", CallingConvention = CallingConvention.Cdecl)]
        public static extern int BodyGetJointCount(BodyId bodyId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Body_GetJoints", CallingConvention = CallingConvention.Cdecl)]
        public static extern int BodyGetJoints(BodyId bodyId, JointId* jointArray, int capacity);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Body_GetLinearDamping", CallingConvention = CallingConvention.Cdecl)]
        public static extern float BodyGetLinearDamping(BodyId bodyId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Body_GetLinearVelocity", CallingConvention = CallingConvention.Cdecl)]
        public static extern Vector2 BodyGetLinearVelocity(BodyId bodyId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Body_GetLocalCenterOfMass", CallingConvention = CallingConvention.Cdecl)]
        public static extern Vector2 BodyGetLocalCenterOfMass(BodyId bodyId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Body_GetLocalPoint", CallingConvention = CallingConvention.Cdecl)]
        public static extern Vector2 BodyGetLocalPoint(BodyId bodyId, Vector2 worldPoint);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Body_GetLocalPointVelocity", CallingConvention = CallingConvention.Cdecl)]
        public static extern Vector2 BodyGetLocalPointVelocity(BodyId bodyId, Vector2 localPoint);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Body_GetLocalVector", CallingConvention = CallingConvention.Cdecl)]
        public static extern Vector2 BodyGetLocalVector(BodyId bodyId, Vector2 worldVector);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Body_GetMass", CallingConvention = CallingConvention.Cdecl)]
        public static extern float BodyGetMass(BodyId bodyId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Body_GetMassData", CallingConvention = CallingConvention.Cdecl)]
        public static extern MassData BodyGetMassData(BodyId bodyId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Body_GetName", CallingConvention = CallingConvention.Cdecl)]
        public static extern byte* BodyGetName(BodyId bodyId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Body_GetPosition", CallingConvention = CallingConvention.Cdecl)]
        public static extern Vector2 BodyGetPosition(BodyId bodyId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Body_GetRotation", CallingConvention = CallingConvention.Cdecl)]
        public static extern Rotation BodyGetRotation(BodyId bodyId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Body_GetRotationalInertia", CallingConvention = CallingConvention.Cdecl)]
        public static extern float BodyGetRotationalInertia(BodyId bodyId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Body_GetShapeCount", CallingConvention = CallingConvention.Cdecl)]
        public static extern int BodyGetShapeCount(BodyId bodyId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Body_GetShapes", CallingConvention = CallingConvention.Cdecl)]
        public static extern int BodyGetShapes(BodyId bodyId, ShapeId* shapeArray, int capacity);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Body_GetSleepThreshold", CallingConvention = CallingConvention.Cdecl)]
        public static extern float BodyGetSleepThreshold(BodyId bodyId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Body_GetTransform", CallingConvention = CallingConvention.Cdecl)]
        public static extern Transform BodyGetTransform(BodyId bodyId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Body_GetType", CallingConvention = CallingConvention.Cdecl)]
        public static extern BodyType BodyGetType(BodyId bodyId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Body_GetUserData", CallingConvention = CallingConvention.Cdecl)]
        public static extern void* BodyGetUserData(BodyId bodyId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Body_GetWorld", CallingConvention = CallingConvention.Cdecl)]
        public static extern WorldId BodyGetWorld(BodyId bodyId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Body_GetWorldCenterOfMass", CallingConvention = CallingConvention.Cdecl)]
        public static extern Vector2 BodyGetWorldCenterOfMass(BodyId bodyId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Body_GetWorldPoint", CallingConvention = CallingConvention.Cdecl)]
        public static extern Vector2 BodyGetWorldPoint(BodyId bodyId, Vector2 localPoint);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Body_GetWorldPointVelocity", CallingConvention = CallingConvention.Cdecl)]
        public static extern Vector2 BodyGetWorldPointVelocity(BodyId bodyId, Vector2 worldPoint);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Body_GetWorldVector", CallingConvention = CallingConvention.Cdecl)]
        public static extern Vector2 BodyGetWorldVector(BodyId bodyId, Vector2 localVector);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Body_IsAwake", CallingConvention = CallingConvention.Cdecl)]
        [return: MarshalAs(UnmanagedType.U1)] public static extern bool BodyIsAwake(BodyId bodyId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Body_IsBullet", CallingConvention = CallingConvention.Cdecl)]
        [return: MarshalAs(UnmanagedType.U1)] public static extern bool BodyIsBullet(BodyId bodyId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Body_IsEnabled", CallingConvention = CallingConvention.Cdecl)]
        [return: MarshalAs(UnmanagedType.U1)] public static extern bool BodyIsEnabled(BodyId bodyId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Body_IsFixedRotation", CallingConvention = CallingConvention.Cdecl)]
        [return: MarshalAs(UnmanagedType.U1)] public static extern bool BodyIsFixedRotation(BodyId bodyId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Body_IsSleepEnabled", CallingConvention = CallingConvention.Cdecl)]
        [return: MarshalAs(UnmanagedType.U1)] public static extern bool BodyIsSleepEnabled(BodyId bodyId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Body_IsValid", CallingConvention = CallingConvention.Cdecl)]
        [return: MarshalAs(UnmanagedType.U1)] public static extern bool BodyIsValid(BodyId id);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Body_SetAngularDamping", CallingConvention = CallingConvention.Cdecl)]
        public static extern void BodySetAngularDamping(BodyId bodyId, float angularDamping);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Body_SetAngularVelocity", CallingConvention = CallingConvention.Cdecl)]
        public static extern void BodySetAngularVelocity(BodyId bodyId, float angularVelocity);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Body_SetAwake", CallingConvention = CallingConvention.Cdecl)]
        public static extern void BodySetAwake(BodyId bodyId, [MarshalAs(UnmanagedType.U1)] bool awake);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Body_SetBullet", CallingConvention = CallingConvention.Cdecl)]
        public static extern void BodySetBullet(BodyId bodyId, [MarshalAs(UnmanagedType.U1)] bool flag);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Body_SetFixedRotation", CallingConvention = CallingConvention.Cdecl)]
        public static extern void BodySetFixedRotation(BodyId bodyId, [MarshalAs(UnmanagedType.U1)] bool flag);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Body_SetGravityScale", CallingConvention = CallingConvention.Cdecl)]
        public static extern void BodySetGravityScale(BodyId bodyId, float gravityScale);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Body_SetLinearDamping", CallingConvention = CallingConvention.Cdecl)]
        public static extern void BodySetLinearDamping(BodyId bodyId, float linearDamping);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Body_SetLinearVelocity", CallingConvention = CallingConvention.Cdecl)]
        public static extern void BodySetLinearVelocity(BodyId bodyId, Vector2 linearVelocity);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Body_SetMassData", CallingConvention = CallingConvention.Cdecl)]
        public static extern void BodySetMassData(BodyId bodyId, MassData massData);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Body_SetName", CallingConvention = CallingConvention.Cdecl)]
        public static extern void BodySetName(BodyId bodyId, byte* name);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Body_SetSleepThreshold", CallingConvention = CallingConvention.Cdecl)]
        public static extern void BodySetSleepThreshold(BodyId bodyId, float sleepThreshold);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Body_SetTargetTransform", CallingConvention = CallingConvention.Cdecl)]
        public static extern void BodySetTargetTransform(BodyId bodyId, Transform target, float timeStep);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Body_SetTransform", CallingConvention = CallingConvention.Cdecl)]
        public static extern void BodySetTransform(BodyId bodyId, Vector2 position, Rotation rotation);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Body_SetType", CallingConvention = CallingConvention.Cdecl)]
        public static extern void BodySetType(BodyId bodyId, BodyType type);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Body_SetUserData", CallingConvention = CallingConvention.Cdecl)]
        public static extern void BodySetUserData(BodyId bodyId, void* userData);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Chain_GetFriction", CallingConvention = CallingConvention.Cdecl)]
        public static extern float ChainGetFriction(ChainId chainId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Chain_GetMaterial", CallingConvention = CallingConvention.Cdecl)]
        public static extern int ChainGetMaterial(ChainId chainId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Chain_GetRestitution", CallingConvention = CallingConvention.Cdecl)]
        public static extern float ChainGetRestitution(ChainId chainId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Chain_GetSegmentCount", CallingConvention = CallingConvention.Cdecl)]
        public static extern int ChainGetSegmentCount(ChainId chainId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Chain_GetSegments", CallingConvention = CallingConvention.Cdecl)]
        public static extern int ChainGetSegments(ChainId chainId, ShapeId* segmentArray, int capacity);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Chain_GetWorld", CallingConvention = CallingConvention.Cdecl)]
        public static extern WorldId ChainGetWorld(ChainId chainId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Chain_IsValid", CallingConvention = CallingConvention.Cdecl)]
        [return: MarshalAs(UnmanagedType.U1)] public static extern bool ChainIsValid(ChainId id);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Chain_SetFriction", CallingConvention = CallingConvention.Cdecl)]
        public static extern void ChainSetFriction(ChainId chainId, float friction);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Chain_SetMaterial", CallingConvention = CallingConvention.Cdecl)]
        public static extern void ChainSetMaterial(ChainId chainId, int material);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Chain_SetRestitution", CallingConvention = CallingConvention.Cdecl)]
        public static extern void ChainSetRestitution(ChainId chainId, float restitution);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Clamp", CallingConvention = CallingConvention.Cdecl)]
        public static extern Vector2 Clamp(Vector2 v, Vector2 a, Vector2 b);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2ClampFloat", CallingConvention = CallingConvention.Cdecl)]
        public static extern float ClampFloat(float a, float lower, float upper);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2ClampInt", CallingConvention = CallingConvention.Cdecl)]
        public static extern int ClampInt(int a, int lower, int upper);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2ClipVector", CallingConvention = CallingConvention.Cdecl)]
        public static extern Vector2 ClipVector(Vector2 vector, CollisionPlane* planes, int count);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2CollideCapsuleAndCircle", CallingConvention = CallingConvention.Cdecl)]
        public static extern Manifold CollideCapsuleAndCircle(Capsule* capsuleA, Transform xfA, Circle* circleB, Transform xfB);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2CollideCapsules", CallingConvention = CallingConvention.Cdecl)]
        public static extern Manifold CollideCapsules(Capsule* capsuleA, Transform xfA, Capsule* capsuleB, Transform xfB);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2CollideChainSegmentAndCapsule", CallingConvention = CallingConvention.Cdecl)]
        public static extern Manifold CollideChainSegmentAndCapsule(ChainSegment* segmentA, Transform xfA, Capsule* capsuleB, Transform xfB, SimplexCache* cache);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2CollideChainSegmentAndCircle", CallingConvention = CallingConvention.Cdecl)]
        public static extern Manifold CollideChainSegmentAndCircle(ChainSegment* segmentA, Transform xfA, Circle* circleB, Transform xfB);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2CollideChainSegmentAndPolygon", CallingConvention = CallingConvention.Cdecl)]
        public static extern Manifold CollideChainSegmentAndPolygon(ChainSegment* segmentA, Transform xfA, Polygon* polygonB, Transform xfB, SimplexCache* cache);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2CollideCircles", CallingConvention = CallingConvention.Cdecl)]
        public static extern Manifold CollideCircles(Circle* circleA, Transform xfA, Circle* circleB, Transform xfB);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2CollidePolygonAndCapsule", CallingConvention = CallingConvention.Cdecl)]
        public static extern Manifold CollidePolygonAndCapsule(Polygon* polygonA, Transform xfA, Capsule* capsuleB, Transform xfB);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2CollidePolygonAndCircle", CallingConvention = CallingConvention.Cdecl)]
        public static extern Manifold CollidePolygonAndCircle(Polygon* polygonA, Transform xfA, Circle* circleB, Transform xfB);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2CollidePolygons", CallingConvention = CallingConvention.Cdecl)]
        public static extern Manifold CollidePolygons(Polygon* polygonA, Transform xfA, Polygon* polygonB, Transform xfB);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2CollideSegmentAndCapsule", CallingConvention = CallingConvention.Cdecl)]
        public static extern Manifold CollideSegmentAndCapsule(Segment* segmentA, Transform xfA, Capsule* capsuleB, Transform xfB);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2CollideSegmentAndCircle", CallingConvention = CallingConvention.Cdecl)]
        public static extern Manifold CollideSegmentAndCircle(Segment* segmentA, Transform xfA, Circle* circleB, Transform xfB);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2CollideSegmentAndPolygon", CallingConvention = CallingConvention.Cdecl)]
        public static extern Manifold CollideSegmentAndPolygon(Segment* segmentA, Transform xfA, Polygon* polygonB, Transform xfB);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2ComputeAngularVelocity", CallingConvention = CallingConvention.Cdecl)]
        public static extern float ComputeAngularVelocity(Rotation q1, Rotation q2, float inv_h);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2ComputeCapsuleAABB", CallingConvention = CallingConvention.Cdecl)]
        public static extern AABB ComputeCapsuleAABB(Capsule* shape, Transform transform);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2ComputeCapsuleMass", CallingConvention = CallingConvention.Cdecl)]
        public static extern MassData ComputeCapsuleMass(Capsule* shape, float density);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2ComputeCircleAABB", CallingConvention = CallingConvention.Cdecl)]
        public static extern AABB ComputeCircleAABB(Circle* shape, Transform transform);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2ComputeCircleMass", CallingConvention = CallingConvention.Cdecl)]
        public static extern MassData ComputeCircleMass(Circle* shape, float density);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2ComputeCosSin", CallingConvention = CallingConvention.Cdecl)]
        public static extern CosSin ComputeCosSin(float radians);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2ComputeHull", CallingConvention = CallingConvention.Cdecl)]
        public static extern Hull ComputeHull(Vector2* points, int count);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2ComputePolygonAABB", CallingConvention = CallingConvention.Cdecl)]
        public static extern AABB ComputePolygonAABB(Polygon* shape, Transform transform);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2ComputePolygonMass", CallingConvention = CallingConvention.Cdecl)]
        public static extern MassData ComputePolygonMass(Polygon* shape, float density);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2ComputeRotationBetweenUnitVectors", CallingConvention = CallingConvention.Cdecl)]
        public static extern Rotation ComputeRotationBetweenUnitVectors(Vector2 v1, Vector2 v2);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2ComputeSegmentAABB", CallingConvention = CallingConvention.Cdecl)]
        public static extern AABB ComputeSegmentAABB(Segment* shape, Transform transform);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2CreateBody", CallingConvention = CallingConvention.Cdecl)]
        public static extern BodyId CreateBody(WorldId worldId, BodyDef* def);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2CreateCapsuleShape", CallingConvention = CallingConvention.Cdecl)]
        public static extern ShapeId CreateCapsuleShape(BodyId bodyId, ShapeDef* def, Capsule* capsule);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2CreateChain", CallingConvention = CallingConvention.Cdecl)]
        public static extern ChainId CreateChain(BodyId bodyId, ChainDef* def);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2CreateCircleShape", CallingConvention = CallingConvention.Cdecl)]
        public static extern ShapeId CreateCircleShape(BodyId bodyId, ShapeDef* def, Circle* circle);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2CreateDistanceJoint", CallingConvention = CallingConvention.Cdecl)]
        public static extern JointId CreateDistanceJoint(WorldId worldId, DistanceJointDef* def);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2CreateFilterJoint", CallingConvention = CallingConvention.Cdecl)]
        public static extern JointId CreateFilterJoint(WorldId worldId, FilterJointDef* def);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2CreateMotorJoint", CallingConvention = CallingConvention.Cdecl)]
        public static extern JointId CreateMotorJoint(WorldId worldId, MotorJointDef* def);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2CreateMouseJoint", CallingConvention = CallingConvention.Cdecl)]
        public static extern JointId CreateMouseJoint(WorldId worldId, MouseJointDef* def);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2CreatePolygonShape", CallingConvention = CallingConvention.Cdecl)]
        public static extern ShapeId CreatePolygonShape(BodyId bodyId, ShapeDef* def, Polygon* polygon);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2CreatePrismaticJoint", CallingConvention = CallingConvention.Cdecl)]
        public static extern JointId CreatePrismaticJoint(WorldId worldId, PrismaticJointDef* def);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2CreateRevoluteJoint", CallingConvention = CallingConvention.Cdecl)]
        public static extern JointId CreateRevoluteJoint(WorldId worldId, RevoluteJointDef* def);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2CreateSegmentShape", CallingConvention = CallingConvention.Cdecl)]
        public static extern ShapeId CreateSegmentShape(BodyId bodyId, ShapeDef* def, Segment* segment);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2CreateWeldJoint", CallingConvention = CallingConvention.Cdecl)]
        public static extern JointId CreateWeldJoint(WorldId worldId, WeldJointDef* def);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2CreateWheelJoint", CallingConvention = CallingConvention.Cdecl)]
        public static extern JointId CreateWheelJoint(WorldId worldId, WheelJointDef* def);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2CreateWorld", CallingConvention = CallingConvention.Cdecl)]
        public static extern WorldId CreateWorld(WorldDef* def);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Cross", CallingConvention = CallingConvention.Cdecl)]
        public static extern float Cross(Vector2 a, Vector2 b);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2CrossSV", CallingConvention = CallingConvention.Cdecl)]
        public static extern Vector2 CrossSV(float s, Vector2 v);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2CrossVS", CallingConvention = CallingConvention.Cdecl)]
        public static extern Vector2 CrossVS(Vector2 v, float s);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2DefaultBodyDef", CallingConvention = CallingConvention.Cdecl)]
        public static extern BodyDef DefaultBodyDef();

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2DefaultChainDef", CallingConvention = CallingConvention.Cdecl)]
        public static extern ChainDef DefaultChainDef();

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2DefaultDistanceJointDef", CallingConvention = CallingConvention.Cdecl)]
        public static extern DistanceJointDef DefaultDistanceJointDef();

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2DefaultExplosionDef", CallingConvention = CallingConvention.Cdecl)]
        public static extern ExplosionDef DefaultExplosionDef();

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2DefaultFilter", CallingConvention = CallingConvention.Cdecl)]
        public static extern Filter DefaultFilter();

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2DefaultFilterJointDef", CallingConvention = CallingConvention.Cdecl)]
        public static extern FilterJointDef DefaultFilterJointDef();

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2DefaultMotorJointDef", CallingConvention = CallingConvention.Cdecl)]
        public static extern MotorJointDef DefaultMotorJointDef();

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2DefaultMouseJointDef", CallingConvention = CallingConvention.Cdecl)]
        public static extern MouseJointDef DefaultMouseJointDef();

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2DefaultPrismaticJointDef", CallingConvention = CallingConvention.Cdecl)]
        public static extern PrismaticJointDef DefaultPrismaticJointDef();

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2DefaultQueryFilter", CallingConvention = CallingConvention.Cdecl)]
        public static extern QueryFilter DefaultQueryFilter();

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2DefaultRevoluteJointDef", CallingConvention = CallingConvention.Cdecl)]
        public static extern RevoluteJointDef DefaultRevoluteJointDef();

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2DefaultShapeDef", CallingConvention = CallingConvention.Cdecl)]
        public static extern ShapeDef DefaultShapeDef();

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2DefaultSurfaceMaterial", CallingConvention = CallingConvention.Cdecl)]
        public static extern SurfaceMaterial DefaultSurfaceMaterial();

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2DefaultWeldJointDef", CallingConvention = CallingConvention.Cdecl)]
        public static extern WeldJointDef DefaultWeldJointDef();

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2DefaultWheelJointDef", CallingConvention = CallingConvention.Cdecl)]
        public static extern WheelJointDef DefaultWheelJointDef();

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2DefaultWorldDef", CallingConvention = CallingConvention.Cdecl)]
        public static extern WorldDef DefaultWorldDef();

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2DestroyBody", CallingConvention = CallingConvention.Cdecl)]
        public static extern void DestroyBody(BodyId bodyId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2DestroyChain", CallingConvention = CallingConvention.Cdecl)]
        public static extern void DestroyChain(ChainId chainId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2DestroyJoint", CallingConvention = CallingConvention.Cdecl)]
        public static extern void DestroyJoint(JointId jointId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2DestroyShape", CallingConvention = CallingConvention.Cdecl)]
        public static extern void DestroyShape(ShapeId shapeId, [MarshalAs(UnmanagedType.U1)] bool updateBodyMass);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2DestroyWorld", CallingConvention = CallingConvention.Cdecl)]
        public static extern void DestroyWorld(WorldId worldId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Distance", CallingConvention = CallingConvention.Cdecl)]
        public static extern float Distance(Vector2 a, Vector2 b);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2DistanceJoint_EnableLimit", CallingConvention = CallingConvention.Cdecl)]
        public static extern void DistanceJointEnableLimit(JointId jointId, [MarshalAs(UnmanagedType.U1)] bool enableLimit);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2DistanceJoint_EnableMotor", CallingConvention = CallingConvention.Cdecl)]
        public static extern void DistanceJointEnableMotor(JointId jointId, [MarshalAs(UnmanagedType.U1)] bool enableMotor);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2DistanceJoint_EnableSpring", CallingConvention = CallingConvention.Cdecl)]
        public static extern void DistanceJointEnableSpring(JointId jointId, [MarshalAs(UnmanagedType.U1)] bool enableSpring);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2DistanceJoint_GetCurrentLength", CallingConvention = CallingConvention.Cdecl)]
        public static extern float DistanceJointGetCurrentLength(JointId jointId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2DistanceJoint_GetLength", CallingConvention = CallingConvention.Cdecl)]
        public static extern float DistanceJointGetLength(JointId jointId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2DistanceJoint_GetMaxLength", CallingConvention = CallingConvention.Cdecl)]
        public static extern float DistanceJointGetMaxLength(JointId jointId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2DistanceJoint_GetMaxMotorForce", CallingConvention = CallingConvention.Cdecl)]
        public static extern float DistanceJointGetMaxMotorForce(JointId jointId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2DistanceJoint_GetMinLength", CallingConvention = CallingConvention.Cdecl)]
        public static extern float DistanceJointGetMinLength(JointId jointId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2DistanceJoint_GetMotorForce", CallingConvention = CallingConvention.Cdecl)]
        public static extern float DistanceJointGetMotorForce(JointId jointId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2DistanceJoint_GetMotorSpeed", CallingConvention = CallingConvention.Cdecl)]
        public static extern float DistanceJointGetMotorSpeed(JointId jointId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2DistanceJoint_GetSpringDampingRatio", CallingConvention = CallingConvention.Cdecl)]
        public static extern float DistanceJointGetSpringDampingRatio(JointId jointId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2DistanceJoint_GetSpringHertz", CallingConvention = CallingConvention.Cdecl)]
        public static extern float DistanceJointGetSpringHertz(JointId jointId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2DistanceJoint_IsLimitEnabled", CallingConvention = CallingConvention.Cdecl)]
        [return: MarshalAs(UnmanagedType.U1)] public static extern bool DistanceJointIsLimitEnabled(JointId jointId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2DistanceJoint_IsMotorEnabled", CallingConvention = CallingConvention.Cdecl)]
        [return: MarshalAs(UnmanagedType.U1)] public static extern bool DistanceJointIsMotorEnabled(JointId jointId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2DistanceJoint_IsSpringEnabled", CallingConvention = CallingConvention.Cdecl)]
        [return: MarshalAs(UnmanagedType.U1)] public static extern bool DistanceJointIsSpringEnabled(JointId jointId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2DistanceJoint_SetLength", CallingConvention = CallingConvention.Cdecl)]
        public static extern void DistanceJointSetLength(JointId jointId, float length);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2DistanceJoint_SetLengthRange", CallingConvention = CallingConvention.Cdecl)]
        public static extern void DistanceJointSetLengthRange(JointId jointId, float minLength, float maxLength);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2DistanceJoint_SetMaxMotorForce", CallingConvention = CallingConvention.Cdecl)]
        public static extern void DistanceJointSetMaxMotorForce(JointId jointId, float force);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2DistanceJoint_SetMotorSpeed", CallingConvention = CallingConvention.Cdecl)]
        public static extern void DistanceJointSetMotorSpeed(JointId jointId, float motorSpeed);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2DistanceJoint_SetSpringDampingRatio", CallingConvention = CallingConvention.Cdecl)]
        public static extern void DistanceJointSetSpringDampingRatio(JointId jointId, float dampingRatio);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2DistanceJoint_SetSpringHertz", CallingConvention = CallingConvention.Cdecl)]
        public static extern void DistanceJointSetSpringHertz(JointId jointId, float hertz);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2DistanceSquared", CallingConvention = CallingConvention.Cdecl)]
        public static extern float DistanceSquared(Vector2 a, Vector2 b);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Dot", CallingConvention = CallingConvention.Cdecl)]
        public static extern float Dot(Vector2 a, Vector2 b);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2DynamicTree_Create", CallingConvention = CallingConvention.Cdecl)]
        public static extern DynamicTree DynamicTreeCreate();

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2DynamicTree_CreateProxy", CallingConvention = CallingConvention.Cdecl)]
        public static extern int DynamicTreeCreateProxy(DynamicTree* tree, AABB aabb, ulong categoryBits, ulong userData);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2DynamicTree_Destroy", CallingConvention = CallingConvention.Cdecl)]
        public static extern void DynamicTreeDestroy(DynamicTree* tree);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2DynamicTree_DestroyProxy", CallingConvention = CallingConvention.Cdecl)]
        public static extern void DynamicTreeDestroyProxy(DynamicTree* tree, int proxyId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2DynamicTree_EnlargeProxy", CallingConvention = CallingConvention.Cdecl)]
        public static extern void DynamicTreeEnlargeProxy(DynamicTree* tree, int proxyId, AABB aabb);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2DynamicTree_GetAABB", CallingConvention = CallingConvention.Cdecl)]
        public static extern AABB DynamicTreeGetAABB(DynamicTree* tree, int proxyId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2DynamicTree_GetAreaRatio", CallingConvention = CallingConvention.Cdecl)]
        public static extern float DynamicTreeGetAreaRatio(DynamicTree* tree);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2DynamicTree_GetByteCount", CallingConvention = CallingConvention.Cdecl)]
        public static extern int DynamicTreeGetByteCount(DynamicTree* tree);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2DynamicTree_GetCategoryBits", CallingConvention = CallingConvention.Cdecl)]
        public static extern ulong DynamicTreeGetCategoryBits(DynamicTree* tree, int proxyId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2DynamicTree_GetHeight", CallingConvention = CallingConvention.Cdecl)]
        public static extern int DynamicTreeGetHeight(DynamicTree* tree);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2DynamicTree_GetProxyCount", CallingConvention = CallingConvention.Cdecl)]
        public static extern int DynamicTreeGetProxyCount(DynamicTree* tree);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2DynamicTree_GetRootBounds", CallingConvention = CallingConvention.Cdecl)]
        public static extern AABB DynamicTreeGetRootBounds(DynamicTree* tree);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2DynamicTree_GetUserData", CallingConvention = CallingConvention.Cdecl)]
        public static extern ulong DynamicTreeGetUserData(DynamicTree* tree, int proxyId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2DynamicTree_MoveProxy", CallingConvention = CallingConvention.Cdecl)]
        public static extern void DynamicTreeMoveProxy(DynamicTree* tree, int proxyId, AABB aabb);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2DynamicTree_Query", CallingConvention = CallingConvention.Cdecl)]
        public static extern TreeStats DynamicTreeQuery(DynamicTree* tree, AABB aabb, ulong maskBits, nint callback, void* context);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2DynamicTree_RayCast", CallingConvention = CallingConvention.Cdecl)]
        public static extern TreeStats DynamicTreeRayCast(DynamicTree* tree, RayCastInput* input, ulong maskBits, nint callback, void* context);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2DynamicTree_Rebuild", CallingConvention = CallingConvention.Cdecl)]
        public static extern int DynamicTreeRebuild(DynamicTree* tree, [MarshalAs(UnmanagedType.U1)] bool fullBuild);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2DynamicTree_SetCategoryBits", CallingConvention = CallingConvention.Cdecl)]
        public static extern void DynamicTreeSetCategoryBits(DynamicTree* tree, int proxyId, ulong categoryBits);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2DynamicTree_ShapeCast", CallingConvention = CallingConvention.Cdecl)]
        public static extern TreeStats DynamicTreeShapeCast(DynamicTree* tree, ShapeCastInput* input, ulong maskBits, nint callback, void* context);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2DynamicTree_Validate", CallingConvention = CallingConvention.Cdecl)]
        public static extern void DynamicTreeValidate(DynamicTree* tree);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2DynamicTree_ValidateNoEnlarged", CallingConvention = CallingConvention.Cdecl)]
        public static extern void DynamicTreeValidateNoEnlarged(DynamicTree* tree);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2GetByteCount", CallingConvention = CallingConvention.Cdecl)]
        public static extern int GetByteCount();

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2GetInverse22", CallingConvention = CallingConvention.Cdecl)]
        public static extern Mat22 GetInverse22(Mat22 A);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2GetLengthAndNormalize", CallingConvention = CallingConvention.Cdecl)]
        public static extern Vector2 GetLengthAndNormalize(float* length, Vector2 v);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2GetLengthUnitsPerMeter", CallingConvention = CallingConvention.Cdecl)]
        public static extern float GetLengthUnitsPerMeter();

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2GetMilliseconds", CallingConvention = CallingConvention.Cdecl)]
        public static extern float GetMilliseconds(ulong ticks);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2GetMillisecondsAndReset", CallingConvention = CallingConvention.Cdecl)]
        public static extern float GetMillisecondsAndReset(ulong* ticks);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2GetSweepTransform", CallingConvention = CallingConvention.Cdecl)]
        public static extern Transform GetSweepTransform(Sweep* sweep, float time);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2GetTicks", CallingConvention = CallingConvention.Cdecl)]
        public static extern ulong GetTicks();

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2GetVersion", CallingConvention = CallingConvention.Cdecl)]
        public static extern Version GetVersion();

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Hash", CallingConvention = CallingConvention.Cdecl)]
        public static extern uint Hash(uint hash, byte* data, int count);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2IntegrateRotation", CallingConvention = CallingConvention.Cdecl)]
        public static extern Rotation IntegrateRotation(Rotation q1, float deltaAngle);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2InternalAssertFcn", CallingConvention = CallingConvention.Cdecl)]
        public static extern int InternalAssertFcn(byte* condition, byte* fileName, int lineNumber);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2InvMulRot", CallingConvention = CallingConvention.Cdecl)]
        public static extern Rotation InvMulRot(Rotation q, Rotation r);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2InvMulTransforms", CallingConvention = CallingConvention.Cdecl)]
        public static extern Transform InvMulTransforms(Transform A, Transform B);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2InvRotateVector", CallingConvention = CallingConvention.Cdecl)]
        public static extern Vector2 InvRotateVector(Rotation q, Vector2 v);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2InvTransformPoint", CallingConvention = CallingConvention.Cdecl)]
        public static extern Vector2 InvTransformPoint(Transform t, Vector2 p);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2IsNormalized", CallingConvention = CallingConvention.Cdecl)]
        [return: MarshalAs(UnmanagedType.U1)] public static extern bool IsNormalized(Vector2 a);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2IsNormalizedRot", CallingConvention = CallingConvention.Cdecl)]
        [return: MarshalAs(UnmanagedType.U1)] public static extern bool IsNormalizedRot(Rotation q);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2IsValidAABB", CallingConvention = CallingConvention.Cdecl)]
        [return: MarshalAs(UnmanagedType.U1)] public static extern bool IsValidAABB(AABB aabb);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2IsValidFloat", CallingConvention = CallingConvention.Cdecl)]
        [return: MarshalAs(UnmanagedType.U1)] public static extern bool IsValidFloat(float a);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2IsValidPlane", CallingConvention = CallingConvention.Cdecl)]
        [return: MarshalAs(UnmanagedType.U1)] public static extern bool IsValidPlane(Plane a);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2IsValidRay", CallingConvention = CallingConvention.Cdecl)]
        [return: MarshalAs(UnmanagedType.U1)] public static extern bool IsValidRay(RayCastInput* input);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2IsValidRotation", CallingConvention = CallingConvention.Cdecl)]
        [return: MarshalAs(UnmanagedType.U1)] public static extern bool IsValidRotation(Rotation q);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2IsValidVec2", CallingConvention = CallingConvention.Cdecl)]
        [return: MarshalAs(UnmanagedType.U1)] public static extern bool IsValidVec2(Vector2 v);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Joint_GetBodyA", CallingConvention = CallingConvention.Cdecl)]
        public static extern BodyId JointGetBodyA(JointId jointId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Joint_GetBodyB", CallingConvention = CallingConvention.Cdecl)]
        public static extern BodyId JointGetBodyB(JointId jointId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Joint_GetCollideConnected", CallingConvention = CallingConvention.Cdecl)]
        [return: MarshalAs(UnmanagedType.U1)] public static extern bool JointGetCollideConnected(JointId jointId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Joint_GetConstraintForce", CallingConvention = CallingConvention.Cdecl)]
        public static extern Vector2 JointGetConstraintForce(JointId jointId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Joint_GetConstraintTorque", CallingConvention = CallingConvention.Cdecl)]
        public static extern float JointGetConstraintTorque(JointId jointId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Joint_GetLocalAnchorA", CallingConvention = CallingConvention.Cdecl)]
        public static extern Vector2 JointGetLocalAnchorA(JointId jointId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Joint_GetLocalAnchorB", CallingConvention = CallingConvention.Cdecl)]
        public static extern Vector2 JointGetLocalAnchorB(JointId jointId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Joint_GetType", CallingConvention = CallingConvention.Cdecl)]
        public static extern JointType JointGetType(JointId jointId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Joint_GetUserData", CallingConvention = CallingConvention.Cdecl)]
        public static extern void* JointGetUserData(JointId jointId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Joint_GetWorld", CallingConvention = CallingConvention.Cdecl)]
        public static extern WorldId JointGetWorld(JointId jointId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Joint_IsValid", CallingConvention = CallingConvention.Cdecl)]
        [return: MarshalAs(UnmanagedType.U1)] public static extern bool JointIsValid(JointId id);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Joint_SetCollideConnected", CallingConvention = CallingConvention.Cdecl)]
        public static extern void JointSetCollideConnected(JointId jointId, [MarshalAs(UnmanagedType.U1)] bool shouldCollide);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Joint_SetUserData", CallingConvention = CallingConvention.Cdecl)]
        public static extern void JointSetUserData(JointId jointId, void* userData);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Joint_WakeBodies", CallingConvention = CallingConvention.Cdecl)]
        public static extern void JointWakeBodies(JointId jointId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2LeftPerp", CallingConvention = CallingConvention.Cdecl)]
        public static extern Vector2 LeftPerp(Vector2 v);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Length", CallingConvention = CallingConvention.Cdecl)]
        public static extern float Length(Vector2 v);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2LengthSquared", CallingConvention = CallingConvention.Cdecl)]
        public static extern float LengthSquared(Vector2 v);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Lerp", CallingConvention = CallingConvention.Cdecl)]
        public static extern Vector2 Lerp(Vector2 a, Vector2 b, float t);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2LoadBodyId", CallingConvention = CallingConvention.Cdecl)]
        public static extern BodyId LoadBodyId(ulong x);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2LoadChainId", CallingConvention = CallingConvention.Cdecl)]
        public static extern ChainId LoadChainId(ulong x);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2LoadJointId", CallingConvention = CallingConvention.Cdecl)]
        public static extern JointId LoadJointId(ulong x);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2LoadShapeId", CallingConvention = CallingConvention.Cdecl)]
        public static extern ShapeId LoadShapeId(ulong x);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2MakeAABB", CallingConvention = CallingConvention.Cdecl)]
        public static extern AABB MakeAABB(Vector2* points, int count, float radius);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2MakeBox", CallingConvention = CallingConvention.Cdecl)]
        public static extern Polygon MakeBox(float halfWidth, float halfHeight);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2MakeOffsetBox", CallingConvention = CallingConvention.Cdecl)]
        public static extern Polygon MakeOffsetBox(float halfWidth, float halfHeight, Vector2 center, Rotation rotation);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2MakeOffsetPolygon", CallingConvention = CallingConvention.Cdecl)]
        public static extern Polygon MakeOffsetPolygon(Hull* hull, Vector2 position, Rotation rotation);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2MakeOffsetProxy", CallingConvention = CallingConvention.Cdecl)]
        public static extern ShapeProxy MakeOffsetProxy(Vector2* points, int count, float radius, Vector2 position, Rotation rotation);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2MakeOffsetRoundedBox", CallingConvention = CallingConvention.Cdecl)]
        public static extern Polygon MakeOffsetRoundedBox(float halfWidth, float halfHeight, Vector2 center, Rotation rotation, float radius);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2MakeOffsetRoundedPolygon", CallingConvention = CallingConvention.Cdecl)]
        public static extern Polygon MakeOffsetRoundedPolygon(Hull* hull, Vector2 position, Rotation rotation, float radius);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2MakePolygon", CallingConvention = CallingConvention.Cdecl)]
        public static extern Polygon MakePolygon(Hull* hull, float radius);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2MakeProxy", CallingConvention = CallingConvention.Cdecl)]
        public static extern ShapeProxy MakeProxy(Vector2* points, int count, float radius);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2MakeRot", CallingConvention = CallingConvention.Cdecl)]
        public static extern Rotation MakeRot(float radians);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2MakeRoundedBox", CallingConvention = CallingConvention.Cdecl)]
        public static extern Polygon MakeRoundedBox(float halfWidth, float halfHeight, float radius);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2MakeSquare", CallingConvention = CallingConvention.Cdecl)]
        public static extern Polygon MakeSquare(float halfWidth);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Max", CallingConvention = CallingConvention.Cdecl)]
        public static extern Vector2 Max(Vector2 a, Vector2 b);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2MaxFloat", CallingConvention = CallingConvention.Cdecl)]
        public static extern float MaxFloat(float a, float b);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2MaxInt", CallingConvention = CallingConvention.Cdecl)]
        public static extern int MaxInt(int a, int b);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Min", CallingConvention = CallingConvention.Cdecl)]
        public static extern Vector2 Min(Vector2 a, Vector2 b);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2MinFloat", CallingConvention = CallingConvention.Cdecl)]
        public static extern float MinFloat(float a, float b);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2MinInt", CallingConvention = CallingConvention.Cdecl)]
        public static extern int MinInt(int a, int b);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2MotorJoint_GetAngularOffset", CallingConvention = CallingConvention.Cdecl)]
        public static extern float MotorJointGetAngularOffset(JointId jointId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2MotorJoint_GetCorrectionFactor", CallingConvention = CallingConvention.Cdecl)]
        public static extern float MotorJointGetCorrectionFactor(JointId jointId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2MotorJoint_GetLinearOffset", CallingConvention = CallingConvention.Cdecl)]
        public static extern Vector2 MotorJointGetLinearOffset(JointId jointId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2MotorJoint_GetMaxForce", CallingConvention = CallingConvention.Cdecl)]
        public static extern float MotorJointGetMaxForce(JointId jointId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2MotorJoint_GetMaxTorque", CallingConvention = CallingConvention.Cdecl)]
        public static extern float MotorJointGetMaxTorque(JointId jointId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2MotorJoint_SetAngularOffset", CallingConvention = CallingConvention.Cdecl)]
        public static extern void MotorJointSetAngularOffset(JointId jointId, float angularOffset);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2MotorJoint_SetCorrectionFactor", CallingConvention = CallingConvention.Cdecl)]
        public static extern void MotorJointSetCorrectionFactor(JointId jointId, float correctionFactor);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2MotorJoint_SetLinearOffset", CallingConvention = CallingConvention.Cdecl)]
        public static extern void MotorJointSetLinearOffset(JointId jointId, Vector2 linearOffset);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2MotorJoint_SetMaxForce", CallingConvention = CallingConvention.Cdecl)]
        public static extern void MotorJointSetMaxForce(JointId jointId, float maxForce);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2MotorJoint_SetMaxTorque", CallingConvention = CallingConvention.Cdecl)]
        public static extern void MotorJointSetMaxTorque(JointId jointId, float maxTorque);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2MouseJoint_GetMaxForce", CallingConvention = CallingConvention.Cdecl)]
        public static extern float MouseJointGetMaxForce(JointId jointId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2MouseJoint_GetSpringDampingRatio", CallingConvention = CallingConvention.Cdecl)]
        public static extern float MouseJointGetSpringDampingRatio(JointId jointId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2MouseJoint_GetSpringHertz", CallingConvention = CallingConvention.Cdecl)]
        public static extern float MouseJointGetSpringHertz(JointId jointId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2MouseJoint_GetTarget", CallingConvention = CallingConvention.Cdecl)]
        public static extern Vector2 MouseJointGetTarget(JointId jointId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2MouseJoint_SetMaxForce", CallingConvention = CallingConvention.Cdecl)]
        public static extern void MouseJointSetMaxForce(JointId jointId, float maxForce);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2MouseJoint_SetSpringDampingRatio", CallingConvention = CallingConvention.Cdecl)]
        public static extern void MouseJointSetSpringDampingRatio(JointId jointId, float dampingRatio);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2MouseJoint_SetSpringHertz", CallingConvention = CallingConvention.Cdecl)]
        public static extern void MouseJointSetSpringHertz(JointId jointId, float hertz);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2MouseJoint_SetTarget", CallingConvention = CallingConvention.Cdecl)]
        public static extern void MouseJointSetTarget(JointId jointId, Vector2 target);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Mul", CallingConvention = CallingConvention.Cdecl)]
        public static extern Vector2 Mul(Vector2 a, Vector2 b);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2MulAdd", CallingConvention = CallingConvention.Cdecl)]
        public static extern Vector2 MulAdd(Vector2 a, float s, Vector2 b);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2MulMV", CallingConvention = CallingConvention.Cdecl)]
        public static extern Vector2 MulMV(Mat22 A, Vector2 v);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2MulRot", CallingConvention = CallingConvention.Cdecl)]
        public static extern Rotation MulRot(Rotation q, Rotation r);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2MulSub", CallingConvention = CallingConvention.Cdecl)]
        public static extern Vector2 MulSub(Vector2 a, float s, Vector2 b);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2MulSV", CallingConvention = CallingConvention.Cdecl)]
        public static extern Vector2 MulSV(float s, Vector2 v);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2MulTransforms", CallingConvention = CallingConvention.Cdecl)]
        public static extern Transform MulTransforms(Transform A, Transform B);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Neg", CallingConvention = CallingConvention.Cdecl)]
        public static extern Vector2 Neg(Vector2 a);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2NLerp", CallingConvention = CallingConvention.Cdecl)]
        public static extern Rotation NLerp(Rotation q1, Rotation q2, float t);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Normalize", CallingConvention = CallingConvention.Cdecl)]
        public static extern Vector2 Normalize(Vector2 v);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2NormalizeRot", CallingConvention = CallingConvention.Cdecl)]
        public static extern Rotation NormalizeRot(Rotation q);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2PlaneSeparation", CallingConvention = CallingConvention.Cdecl)]
        public static extern float PlaneSeparation(Plane plane, Vector2 point);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2PointInCapsule", CallingConvention = CallingConvention.Cdecl)]
        [return: MarshalAs(UnmanagedType.U1)] public static extern bool PointInCapsule(Vector2 point, Capsule* shape);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2PointInCircle", CallingConvention = CallingConvention.Cdecl)]
        [return: MarshalAs(UnmanagedType.U1)] public static extern bool PointInCircle(Vector2 point, Circle* shape);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2PointInPolygon", CallingConvention = CallingConvention.Cdecl)]
        [return: MarshalAs(UnmanagedType.U1)] public static extern bool PointInPolygon(Vector2 point, Polygon* shape);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2PrismaticJoint_EnableLimit", CallingConvention = CallingConvention.Cdecl)]
        public static extern void PrismaticJointEnableLimit(JointId jointId, [MarshalAs(UnmanagedType.U1)] bool enableLimit);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2PrismaticJoint_EnableMotor", CallingConvention = CallingConvention.Cdecl)]
        public static extern void PrismaticJointEnableMotor(JointId jointId, [MarshalAs(UnmanagedType.U1)] bool enableMotor);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2PrismaticJoint_EnableSpring", CallingConvention = CallingConvention.Cdecl)]
        public static extern void PrismaticJointEnableSpring(JointId jointId, [MarshalAs(UnmanagedType.U1)] bool enableSpring);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2PrismaticJoint_GetLowerLimit", CallingConvention = CallingConvention.Cdecl)]
        public static extern float PrismaticJointGetLowerLimit(JointId jointId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2PrismaticJoint_GetMaxMotorForce", CallingConvention = CallingConvention.Cdecl)]
        public static extern float PrismaticJointGetMaxMotorForce(JointId jointId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2PrismaticJoint_GetMotorForce", CallingConvention = CallingConvention.Cdecl)]
        public static extern float PrismaticJointGetMotorForce(JointId jointId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2PrismaticJoint_GetMotorSpeed", CallingConvention = CallingConvention.Cdecl)]
        public static extern float PrismaticJointGetMotorSpeed(JointId jointId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2PrismaticJoint_GetSpeed", CallingConvention = CallingConvention.Cdecl)]
        public static extern float PrismaticJointGetSpeed(JointId jointId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2PrismaticJoint_GetSpringDampingRatio", CallingConvention = CallingConvention.Cdecl)]
        public static extern float PrismaticJointGetSpringDampingRatio(JointId jointId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2PrismaticJoint_GetSpringHertz", CallingConvention = CallingConvention.Cdecl)]
        public static extern float PrismaticJointGetSpringHertz(JointId jointId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2PrismaticJoint_GetTranslation", CallingConvention = CallingConvention.Cdecl)]
        public static extern float PrismaticJointGetTranslation(JointId jointId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2PrismaticJoint_GetUpperLimit", CallingConvention = CallingConvention.Cdecl)]
        public static extern float PrismaticJointGetUpperLimit(JointId jointId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2PrismaticJoint_IsLimitEnabled", CallingConvention = CallingConvention.Cdecl)]
        [return: MarshalAs(UnmanagedType.U1)] public static extern bool PrismaticJointIsLimitEnabled(JointId jointId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2PrismaticJoint_IsMotorEnabled", CallingConvention = CallingConvention.Cdecl)]
        [return: MarshalAs(UnmanagedType.U1)] public static extern bool PrismaticJointIsMotorEnabled(JointId jointId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2PrismaticJoint_IsSpringEnabled", CallingConvention = CallingConvention.Cdecl)]
        [return: MarshalAs(UnmanagedType.U1)] public static extern bool PrismaticJointIsSpringEnabled(JointId jointId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2PrismaticJoint_SetLimits", CallingConvention = CallingConvention.Cdecl)]
        public static extern void PrismaticJointSetLimits(JointId jointId, float lower, float upper);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2PrismaticJoint_SetMaxMotorForce", CallingConvention = CallingConvention.Cdecl)]
        public static extern void PrismaticJointSetMaxMotorForce(JointId jointId, float force);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2PrismaticJoint_SetMotorSpeed", CallingConvention = CallingConvention.Cdecl)]
        public static extern void PrismaticJointSetMotorSpeed(JointId jointId, float motorSpeed);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2PrismaticJoint_SetSpringDampingRatio", CallingConvention = CallingConvention.Cdecl)]
        public static extern void PrismaticJointSetSpringDampingRatio(JointId jointId, float dampingRatio);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2PrismaticJoint_SetSpringHertz", CallingConvention = CallingConvention.Cdecl)]
        public static extern void PrismaticJointSetSpringHertz(JointId jointId, float hertz);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2RayCastCapsule", CallingConvention = CallingConvention.Cdecl)]
        public static extern CastOutput RayCastCapsule(RayCastInput* input, Capsule* shape);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2RayCastCircle", CallingConvention = CallingConvention.Cdecl)]
        public static extern CastOutput RayCastCircle(RayCastInput* input, Circle* shape);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2RayCastPolygon", CallingConvention = CallingConvention.Cdecl)]
        public static extern CastOutput RayCastPolygon(RayCastInput* input, Polygon* shape);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2RayCastSegment", CallingConvention = CallingConvention.Cdecl)]
        public static extern CastOutput RayCastSegment(RayCastInput* input, Segment* shape, [MarshalAs(UnmanagedType.U1)] bool oneSided);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2RelativeAngle", CallingConvention = CallingConvention.Cdecl)]
        public static extern float RelativeAngle(Rotation b, Rotation a);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2RevoluteJoint_EnableLimit", CallingConvention = CallingConvention.Cdecl)]
        public static extern void RevoluteJointEnableLimit(JointId jointId, [MarshalAs(UnmanagedType.U1)] bool enableLimit);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2RevoluteJoint_EnableMotor", CallingConvention = CallingConvention.Cdecl)]
        public static extern void RevoluteJointEnableMotor(JointId jointId, [MarshalAs(UnmanagedType.U1)] bool enableMotor);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2RevoluteJoint_EnableSpring", CallingConvention = CallingConvention.Cdecl)]
        public static extern void RevoluteJointEnableSpring(JointId jointId, [MarshalAs(UnmanagedType.U1)] bool enableSpring);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2RevoluteJoint_GetAngle", CallingConvention = CallingConvention.Cdecl)]
        public static extern float RevoluteJointGetAngle(JointId jointId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2RevoluteJoint_GetLowerLimit", CallingConvention = CallingConvention.Cdecl)]
        public static extern float RevoluteJointGetLowerLimit(JointId jointId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2RevoluteJoint_GetMaxMotorTorque", CallingConvention = CallingConvention.Cdecl)]
        public static extern float RevoluteJointGetMaxMotorTorque(JointId jointId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2RevoluteJoint_GetMotorSpeed", CallingConvention = CallingConvention.Cdecl)]
        public static extern float RevoluteJointGetMotorSpeed(JointId jointId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2RevoluteJoint_GetMotorTorque", CallingConvention = CallingConvention.Cdecl)]
        public static extern float RevoluteJointGetMotorTorque(JointId jointId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2RevoluteJoint_GetSpringDampingRatio", CallingConvention = CallingConvention.Cdecl)]
        public static extern float RevoluteJointGetSpringDampingRatio(JointId jointId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2RevoluteJoint_GetSpringHertz", CallingConvention = CallingConvention.Cdecl)]
        public static extern float RevoluteJointGetSpringHertz(JointId jointId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2RevoluteJoint_GetUpperLimit", CallingConvention = CallingConvention.Cdecl)]
        public static extern float RevoluteJointGetUpperLimit(JointId jointId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2RevoluteJoint_IsLimitEnabled", CallingConvention = CallingConvention.Cdecl)]
        [return: MarshalAs(UnmanagedType.U1)] public static extern bool RevoluteJointIsLimitEnabled(JointId jointId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2RevoluteJoint_IsMotorEnabled", CallingConvention = CallingConvention.Cdecl)]
        [return: MarshalAs(UnmanagedType.U1)] public static extern bool RevoluteJointIsMotorEnabled(JointId jointId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2RevoluteJoint_IsSpringEnabled", CallingConvention = CallingConvention.Cdecl)]
        [return: MarshalAs(UnmanagedType.U1)] public static extern bool RevoluteJointIsSpringEnabled(JointId jointId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2RevoluteJoint_SetLimits", CallingConvention = CallingConvention.Cdecl)]
        public static extern void RevoluteJointSetLimits(JointId jointId, float lower, float upper);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2RevoluteJoint_SetMaxMotorTorque", CallingConvention = CallingConvention.Cdecl)]
        public static extern void RevoluteJointSetMaxMotorTorque(JointId jointId, float torque);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2RevoluteJoint_SetMotorSpeed", CallingConvention = CallingConvention.Cdecl)]
        public static extern void RevoluteJointSetMotorSpeed(JointId jointId, float motorSpeed);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2RevoluteJoint_SetSpringDampingRatio", CallingConvention = CallingConvention.Cdecl)]
        public static extern void RevoluteJointSetSpringDampingRatio(JointId jointId, float dampingRatio);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2RevoluteJoint_SetSpringHertz", CallingConvention = CallingConvention.Cdecl)]
        public static extern void RevoluteJointSetSpringHertz(JointId jointId, float hertz);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2RightPerp", CallingConvention = CallingConvention.Cdecl)]
        public static extern Vector2 RightPerp(Vector2 v);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Rot_GetAngle", CallingConvention = CallingConvention.Cdecl)]
        public static extern float RotGetAngle(Rotation q);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Rot_GetXAxis", CallingConvention = CallingConvention.Cdecl)]
        public static extern Vector2 RotGetXAxis(Rotation q);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Rot_GetYAxis", CallingConvention = CallingConvention.Cdecl)]
        public static extern Vector2 RotGetYAxis(Rotation q);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2RotateVector", CallingConvention = CallingConvention.Cdecl)]
        public static extern Vector2 RotateVector(Rotation q, Vector2 v);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2SegmentDistance", CallingConvention = CallingConvention.Cdecl)]
        public static extern SegmentDistanceResult SegmentDistance(Vector2 p1, Vector2 q1, Vector2 p2, Vector2 q2);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2SetAllocator", CallingConvention = CallingConvention.Cdecl)]
        public static extern void SetAllocator(nint freeFcn);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2SetAssertFcn", CallingConvention = CallingConvention.Cdecl)]
        public static extern void SetAssertFcn(nint assertFcn);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2SetLengthUnitsPerMeter", CallingConvention = CallingConvention.Cdecl)]
        public static extern void SetLengthUnitsPerMeter(float lengthUnits);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Shape_AreContactEventsEnabled", CallingConvention = CallingConvention.Cdecl)]
        [return: MarshalAs(UnmanagedType.U1)] public static extern bool ShapeAreContactEventsEnabled(ShapeId shapeId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Shape_AreHitEventsEnabled", CallingConvention = CallingConvention.Cdecl)]
        [return: MarshalAs(UnmanagedType.U1)] public static extern bool ShapeAreHitEventsEnabled(ShapeId shapeId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Shape_ArePreSolveEventsEnabled", CallingConvention = CallingConvention.Cdecl)]
        [return: MarshalAs(UnmanagedType.U1)] public static extern bool ShapeArePreSolveEventsEnabled(ShapeId shapeId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Shape_AreSensorEventsEnabled", CallingConvention = CallingConvention.Cdecl)]
        [return: MarshalAs(UnmanagedType.U1)] public static extern bool ShapeAreSensorEventsEnabled(ShapeId shapeId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Shape_EnableContactEvents", CallingConvention = CallingConvention.Cdecl)]
        public static extern void ShapeEnableContactEvents(ShapeId shapeId, [MarshalAs(UnmanagedType.U1)] bool flag);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Shape_EnableHitEvents", CallingConvention = CallingConvention.Cdecl)]
        public static extern void ShapeEnableHitEvents(ShapeId shapeId, [MarshalAs(UnmanagedType.U1)] bool flag);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Shape_EnablePreSolveEvents", CallingConvention = CallingConvention.Cdecl)]
        public static extern void ShapeEnablePreSolveEvents(ShapeId shapeId, [MarshalAs(UnmanagedType.U1)] bool flag);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Shape_EnableSensorEvents", CallingConvention = CallingConvention.Cdecl)]
        public static extern void ShapeEnableSensorEvents(ShapeId shapeId, [MarshalAs(UnmanagedType.U1)] bool flag);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Shape_GetAABB", CallingConvention = CallingConvention.Cdecl)]
        public static extern AABB ShapeGetAABB(ShapeId shapeId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Shape_GetBody", CallingConvention = CallingConvention.Cdecl)]
        public static extern BodyId ShapeGetBody(ShapeId shapeId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Shape_GetCapsule", CallingConvention = CallingConvention.Cdecl)]
        public static extern Capsule ShapeGetCapsule(ShapeId shapeId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Shape_GetChainSegment", CallingConvention = CallingConvention.Cdecl)]
        public static extern ChainSegment ShapeGetChainSegment(ShapeId shapeId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Shape_GetCircle", CallingConvention = CallingConvention.Cdecl)]
        public static extern Circle ShapeGetCircle(ShapeId shapeId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Shape_GetClosestPoint", CallingConvention = CallingConvention.Cdecl)]
        public static extern Vector2 ShapeGetClosestPoint(ShapeId shapeId, Vector2 target);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Shape_GetContactCapacity", CallingConvention = CallingConvention.Cdecl)]
        public static extern int ShapeGetContactCapacity(ShapeId shapeId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Shape_GetContactData", CallingConvention = CallingConvention.Cdecl)]
        public static extern int ShapeGetContactData(ShapeId shapeId, ContactData* contactData, int capacity);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Shape_GetDensity", CallingConvention = CallingConvention.Cdecl)]
        public static extern float ShapeGetDensity(ShapeId shapeId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Shape_GetFilter", CallingConvention = CallingConvention.Cdecl)]
        public static extern Filter ShapeGetFilter(ShapeId shapeId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Shape_GetFriction", CallingConvention = CallingConvention.Cdecl)]
        public static extern float ShapeGetFriction(ShapeId shapeId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Shape_GetMassData", CallingConvention = CallingConvention.Cdecl)]
        public static extern MassData ShapeGetMassData(ShapeId shapeId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Shape_GetMaterial", CallingConvention = CallingConvention.Cdecl)]
        public static extern int ShapeGetMaterial(ShapeId shapeId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Shape_GetParentChain", CallingConvention = CallingConvention.Cdecl)]
        public static extern ChainId ShapeGetParentChain(ShapeId shapeId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Shape_GetPolygon", CallingConvention = CallingConvention.Cdecl)]
        public static extern Polygon ShapeGetPolygon(ShapeId shapeId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Shape_GetRestitution", CallingConvention = CallingConvention.Cdecl)]
        public static extern float ShapeGetRestitution(ShapeId shapeId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Shape_GetSegment", CallingConvention = CallingConvention.Cdecl)]
        public static extern Segment ShapeGetSegment(ShapeId shapeId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Shape_GetSensorCapacity", CallingConvention = CallingConvention.Cdecl)]
        public static extern int ShapeGetSensorCapacity(ShapeId shapeId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Shape_GetSensorOverlaps", CallingConvention = CallingConvention.Cdecl)]
        public static extern int ShapeGetSensorOverlaps(ShapeId shapeId, ShapeId* overlaps, int capacity);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Shape_GetType", CallingConvention = CallingConvention.Cdecl)]
        public static extern ShapeType ShapeGetType(ShapeId shapeId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Shape_GetUserData", CallingConvention = CallingConvention.Cdecl)]
        public static extern void* ShapeGetUserData(ShapeId shapeId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Shape_GetWorld", CallingConvention = CallingConvention.Cdecl)]
        public static extern WorldId ShapeGetWorld(ShapeId shapeId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Shape_IsSensor", CallingConvention = CallingConvention.Cdecl)]
        [return: MarshalAs(UnmanagedType.U1)] public static extern bool ShapeIsSensor(ShapeId shapeId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Shape_IsValid", CallingConvention = CallingConvention.Cdecl)]
        [return: MarshalAs(UnmanagedType.U1)] public static extern bool ShapeIsValid(ShapeId id);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Shape_RayCast", CallingConvention = CallingConvention.Cdecl)]
        public static extern CastOutput ShapeRayCast(ShapeId shapeId, RayCastInput* input);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Shape_SetCapsule", CallingConvention = CallingConvention.Cdecl)]
        public static extern void ShapeSetCapsule(ShapeId shapeId, Capsule* capsule);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Shape_SetCircle", CallingConvention = CallingConvention.Cdecl)]
        public static extern void ShapeSetCircle(ShapeId shapeId, Circle* circle);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Shape_SetDensity", CallingConvention = CallingConvention.Cdecl)]
        public static extern void ShapeSetDensity(ShapeId shapeId, float density, [MarshalAs(UnmanagedType.U1)] bool updateBodyMass);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Shape_SetFilter", CallingConvention = CallingConvention.Cdecl)]
        public static extern void ShapeSetFilter(ShapeId shapeId, Filter filter);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Shape_SetFriction", CallingConvention = CallingConvention.Cdecl)]
        public static extern void ShapeSetFriction(ShapeId shapeId, float friction);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Shape_SetMaterial", CallingConvention = CallingConvention.Cdecl)]
        public static extern void ShapeSetMaterial(ShapeId shapeId, int material);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Shape_SetPolygon", CallingConvention = CallingConvention.Cdecl)]
        public static extern void ShapeSetPolygon(ShapeId shapeId, Polygon* polygon);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Shape_SetRestitution", CallingConvention = CallingConvention.Cdecl)]
        public static extern void ShapeSetRestitution(ShapeId shapeId, float restitution);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Shape_SetSegment", CallingConvention = CallingConvention.Cdecl)]
        public static extern void ShapeSetSegment(ShapeId shapeId, Segment* segment);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Shape_SetUserData", CallingConvention = CallingConvention.Cdecl)]
        public static extern void ShapeSetUserData(ShapeId shapeId, void* userData);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Shape_TestPoint", CallingConvention = CallingConvention.Cdecl)]
        [return: MarshalAs(UnmanagedType.U1)] public static extern bool ShapeTestPoint(ShapeId shapeId, Vector2 point);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2ShapeCast", CallingConvention = CallingConvention.Cdecl)]
        public static extern CastOutput ShapeCast(ShapeCastPairInput* input);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2ShapeCastCapsule", CallingConvention = CallingConvention.Cdecl)]
        public static extern CastOutput ShapeCastCapsule(ShapeCastInput* input, Capsule* shape);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2ShapeCastCircle", CallingConvention = CallingConvention.Cdecl)]
        public static extern CastOutput ShapeCastCircle(ShapeCastInput* input, Circle* shape);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2ShapeCastPolygon", CallingConvention = CallingConvention.Cdecl)]
        public static extern CastOutput ShapeCastPolygon(ShapeCastInput* input, Polygon* shape);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2ShapeCastSegment", CallingConvention = CallingConvention.Cdecl)]
        public static extern CastOutput ShapeCastSegment(ShapeCastInput* input, Segment* shape);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2ShapeDistance", CallingConvention = CallingConvention.Cdecl)]
        public static extern DistanceOutput ShapeDistance(DistanceInput* input, SimplexCache* cache, Simplex* simplexes, int simplexCapacity);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Solve22", CallingConvention = CallingConvention.Cdecl)]
        public static extern Vector2 Solve22(Mat22 A, Vector2 b);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2SolvePlanes", CallingConvention = CallingConvention.Cdecl)]
        public static extern PlaneSolverResult SolvePlanes(Vector2 position, CollisionPlane* planes, int count);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2StoreBodyId", CallingConvention = CallingConvention.Cdecl)]
        public static extern ulong StoreBodyId(BodyId id);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2StoreChainId", CallingConvention = CallingConvention.Cdecl)]
        public static extern ulong StoreChainId(ChainId id);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2StoreJointId", CallingConvention = CallingConvention.Cdecl)]
        public static extern ulong StoreJointId(JointId id);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2StoreShapeId", CallingConvention = CallingConvention.Cdecl)]
        public static extern ulong StoreShapeId(ShapeId id);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Sub", CallingConvention = CallingConvention.Cdecl)]
        public static extern Vector2 Sub(Vector2 a, Vector2 b);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2TimeOfImpact", CallingConvention = CallingConvention.Cdecl)]
        public static extern TOIOutput TimeOfImpact(TOIInput* input);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2TransformPoint", CallingConvention = CallingConvention.Cdecl)]
        public static extern Vector2 TransformPoint(Transform t, Vector2 p);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2TransformPolygon", CallingConvention = CallingConvention.Cdecl)]
        public static extern Polygon TransformPolygon(Transform transform, Polygon* polygon);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2UnwindAngle", CallingConvention = CallingConvention.Cdecl)]
        public static extern float UnwindAngle(float radians);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2UnwindLargeAngle", CallingConvention = CallingConvention.Cdecl)]
        public static extern float UnwindLargeAngle(float radians);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2ValidateHull", CallingConvention = CallingConvention.Cdecl)]
        [return: MarshalAs(UnmanagedType.U1)] public static extern bool ValidateHull(Hull* hull);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2WeldJoint_GetAngularDampingRatio", CallingConvention = CallingConvention.Cdecl)]
        public static extern float WeldJointGetAngularDampingRatio(JointId jointId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2WeldJoint_GetAngularHertz", CallingConvention = CallingConvention.Cdecl)]
        public static extern float WeldJointGetAngularHertz(JointId jointId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2WeldJoint_GetLinearDampingRatio", CallingConvention = CallingConvention.Cdecl)]
        public static extern float WeldJointGetLinearDampingRatio(JointId jointId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2WeldJoint_GetLinearHertz", CallingConvention = CallingConvention.Cdecl)]
        public static extern float WeldJointGetLinearHertz(JointId jointId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2WeldJoint_GetReferenceAngle", CallingConvention = CallingConvention.Cdecl)]
        public static extern float WeldJointGetReferenceAngle(JointId jointId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2WeldJoint_SetAngularDampingRatio", CallingConvention = CallingConvention.Cdecl)]
        public static extern void WeldJointSetAngularDampingRatio(JointId jointId, float dampingRatio);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2WeldJoint_SetAngularHertz", CallingConvention = CallingConvention.Cdecl)]
        public static extern void WeldJointSetAngularHertz(JointId jointId, float hertz);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2WeldJoint_SetLinearDampingRatio", CallingConvention = CallingConvention.Cdecl)]
        public static extern void WeldJointSetLinearDampingRatio(JointId jointId, float dampingRatio);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2WeldJoint_SetLinearHertz", CallingConvention = CallingConvention.Cdecl)]
        public static extern void WeldJointSetLinearHertz(JointId jointId, float hertz);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2WeldJoint_SetReferenceAngle", CallingConvention = CallingConvention.Cdecl)]
        public static extern void WeldJointSetReferenceAngle(JointId jointId, float angleInRadians);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2WheelJoint_EnableLimit", CallingConvention = CallingConvention.Cdecl)]
        public static extern void WheelJointEnableLimit(JointId jointId, [MarshalAs(UnmanagedType.U1)] bool enableLimit);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2WheelJoint_EnableMotor", CallingConvention = CallingConvention.Cdecl)]
        public static extern void WheelJointEnableMotor(JointId jointId, [MarshalAs(UnmanagedType.U1)] bool enableMotor);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2WheelJoint_EnableSpring", CallingConvention = CallingConvention.Cdecl)]
        public static extern void WheelJointEnableSpring(JointId jointId, [MarshalAs(UnmanagedType.U1)] bool enableSpring);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2WheelJoint_GetLowerLimit", CallingConvention = CallingConvention.Cdecl)]
        public static extern float WheelJointGetLowerLimit(JointId jointId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2WheelJoint_GetMaxMotorTorque", CallingConvention = CallingConvention.Cdecl)]
        public static extern float WheelJointGetMaxMotorTorque(JointId jointId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2WheelJoint_GetMotorSpeed", CallingConvention = CallingConvention.Cdecl)]
        public static extern float WheelJointGetMotorSpeed(JointId jointId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2WheelJoint_GetMotorTorque", CallingConvention = CallingConvention.Cdecl)]
        public static extern float WheelJointGetMotorTorque(JointId jointId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2WheelJoint_GetSpringDampingRatio", CallingConvention = CallingConvention.Cdecl)]
        public static extern float WheelJointGetSpringDampingRatio(JointId jointId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2WheelJoint_GetSpringHertz", CallingConvention = CallingConvention.Cdecl)]
        public static extern float WheelJointGetSpringHertz(JointId jointId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2WheelJoint_GetUpperLimit", CallingConvention = CallingConvention.Cdecl)]
        public static extern float WheelJointGetUpperLimit(JointId jointId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2WheelJoint_IsLimitEnabled", CallingConvention = CallingConvention.Cdecl)]
        [return: MarshalAs(UnmanagedType.U1)] public static extern bool WheelJointIsLimitEnabled(JointId jointId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2WheelJoint_IsMotorEnabled", CallingConvention = CallingConvention.Cdecl)]
        [return: MarshalAs(UnmanagedType.U1)] public static extern bool WheelJointIsMotorEnabled(JointId jointId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2WheelJoint_IsSpringEnabled", CallingConvention = CallingConvention.Cdecl)]
        [return: MarshalAs(UnmanagedType.U1)] public static extern bool WheelJointIsSpringEnabled(JointId jointId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2WheelJoint_SetLimits", CallingConvention = CallingConvention.Cdecl)]
        public static extern void WheelJointSetLimits(JointId jointId, float lower, float upper);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2WheelJoint_SetMaxMotorTorque", CallingConvention = CallingConvention.Cdecl)]
        public static extern void WheelJointSetMaxMotorTorque(JointId jointId, float torque);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2WheelJoint_SetMotorSpeed", CallingConvention = CallingConvention.Cdecl)]
        public static extern void WheelJointSetMotorSpeed(JointId jointId, float motorSpeed);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2WheelJoint_SetSpringDampingRatio", CallingConvention = CallingConvention.Cdecl)]
        public static extern void WheelJointSetSpringDampingRatio(JointId jointId, float dampingRatio);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2WheelJoint_SetSpringHertz", CallingConvention = CallingConvention.Cdecl)]
        public static extern void WheelJointSetSpringHertz(JointId jointId, float hertz);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2World_CastMover", CallingConvention = CallingConvention.Cdecl)]
        public static extern float WorldCastMover(WorldId worldId, Capsule* mover, Vector2 translation, QueryFilter filter);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2World_CastRay", CallingConvention = CallingConvention.Cdecl)]
        public static extern TreeStats WorldCastRay(WorldId worldId, Vector2 origin, Vector2 translation, QueryFilter filter, nint fcn, void* context);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2World_CastRayClosest", CallingConvention = CallingConvention.Cdecl)]
        public static extern RayResult WorldCastRayClosest(WorldId worldId, Vector2 origin, Vector2 translation, QueryFilter filter);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2World_CastShape", CallingConvention = CallingConvention.Cdecl)]
        public static extern TreeStats WorldCastShape(WorldId worldId, ShapeProxy* proxy, Vector2 translation, QueryFilter filter, nint fcn, void* context);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2World_CollideMover", CallingConvention = CallingConvention.Cdecl)]
        public static extern void WorldCollideMover(WorldId worldId, Capsule* mover, QueryFilter filter, nint fcn, void* context);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2World_DumpMemoryStats", CallingConvention = CallingConvention.Cdecl)]
        public static extern void WorldDumpMemoryStats(WorldId worldId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2World_EnableContinuous", CallingConvention = CallingConvention.Cdecl)]
        public static extern void WorldEnableContinuous(WorldId worldId, [MarshalAs(UnmanagedType.U1)] bool flag);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2World_EnableSleeping", CallingConvention = CallingConvention.Cdecl)]
        public static extern void WorldEnableSleeping(WorldId worldId, [MarshalAs(UnmanagedType.U1)] bool flag);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2World_EnableSpeculative", CallingConvention = CallingConvention.Cdecl)]
        public static extern void WorldEnableSpeculative(WorldId worldId, [MarshalAs(UnmanagedType.U1)] bool flag);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2World_EnableWarmStarting", CallingConvention = CallingConvention.Cdecl)]
        public static extern void WorldEnableWarmStarting(WorldId worldId, [MarshalAs(UnmanagedType.U1)] bool flag);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2World_Explode", CallingConvention = CallingConvention.Cdecl)]
        public static extern void WorldExplode(WorldId worldId, ExplosionDef* explosionDef);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2World_GetAwakeBodyCount", CallingConvention = CallingConvention.Cdecl)]
        public static extern int WorldGetAwakeBodyCount(WorldId worldId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2World_GetBodyEvents", CallingConvention = CallingConvention.Cdecl)]
        public static extern BodyEvents WorldGetBodyEvents(WorldId worldId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2World_GetContactEvents", CallingConvention = CallingConvention.Cdecl)]
        public static extern ContactEvents WorldGetContactEvents(WorldId worldId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2World_GetCounters", CallingConvention = CallingConvention.Cdecl)]
        public static extern Counters WorldGetCounters(WorldId worldId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2World_GetGravity", CallingConvention = CallingConvention.Cdecl)]
        public static extern Vector2 WorldGetGravity(WorldId worldId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2World_GetHitEventThreshold", CallingConvention = CallingConvention.Cdecl)]
        public static extern float WorldGetHitEventThreshold(WorldId worldId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2World_GetMaximumLinearSpeed", CallingConvention = CallingConvention.Cdecl)]
        public static extern float WorldGetMaximumLinearSpeed(WorldId worldId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2World_GetProfile", CallingConvention = CallingConvention.Cdecl)]
        public static extern Profile WorldGetProfile(WorldId worldId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2World_GetRestitutionThreshold", CallingConvention = CallingConvention.Cdecl)]
        public static extern float WorldGetRestitutionThreshold(WorldId worldId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2World_GetSensorEvents", CallingConvention = CallingConvention.Cdecl)]
        public static extern SensorEvents WorldGetSensorEvents(WorldId worldId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2World_GetUserData", CallingConvention = CallingConvention.Cdecl)]
        public static extern void* WorldGetUserData(WorldId worldId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2World_IsContinuousEnabled", CallingConvention = CallingConvention.Cdecl)]
        [return: MarshalAs(UnmanagedType.U1)] public static extern bool WorldIsContinuousEnabled(WorldId worldId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2World_IsSleepingEnabled", CallingConvention = CallingConvention.Cdecl)]
        [return: MarshalAs(UnmanagedType.U1)] public static extern bool WorldIsSleepingEnabled(WorldId worldId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2World_IsValid", CallingConvention = CallingConvention.Cdecl)]
        [return: MarshalAs(UnmanagedType.U1)] public static extern bool WorldIsValid(WorldId id);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2World_IsWarmStartingEnabled", CallingConvention = CallingConvention.Cdecl)]
        [return: MarshalAs(UnmanagedType.U1)] public static extern bool WorldIsWarmStartingEnabled(WorldId worldId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2World_OverlapAABB", CallingConvention = CallingConvention.Cdecl)]
        public static extern TreeStats WorldOverlapAABB(WorldId worldId, AABB aabb, QueryFilter filter, nint fcn, void* context);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2World_OverlapShape", CallingConvention = CallingConvention.Cdecl)]
        public static extern TreeStats WorldOverlapShape(WorldId worldId, ShapeProxy* proxy, QueryFilter filter, nint fcn, void* context);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2World_RebuildStaticTree", CallingConvention = CallingConvention.Cdecl)]
        public static extern void WorldRebuildStaticTree(WorldId worldId);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2World_SetContactTuning", CallingConvention = CallingConvention.Cdecl)]
        public static extern void WorldSetContactTuning(WorldId worldId, float hertz, float dampingRatio, float pushSpeed);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2World_SetCustomFilterCallback", CallingConvention = CallingConvention.Cdecl)]
        public static extern void WorldSetCustomFilterCallback(WorldId worldId, nint fcn, void* context);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2World_SetFrictionCallback", CallingConvention = CallingConvention.Cdecl)]
        public static extern void WorldSetFrictionCallback(WorldId worldId, nint callback);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2World_SetGravity", CallingConvention = CallingConvention.Cdecl)]
        public static extern void WorldSetGravity(WorldId worldId, Vector2 gravity);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2World_SetHitEventThreshold", CallingConvention = CallingConvention.Cdecl)]
        public static extern void WorldSetHitEventThreshold(WorldId worldId, float value);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2World_SetJointTuning", CallingConvention = CallingConvention.Cdecl)]
        public static extern void WorldSetJointTuning(WorldId worldId, float hertz, float dampingRatio);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2World_SetMaximumLinearSpeed", CallingConvention = CallingConvention.Cdecl)]
        public static extern void WorldSetMaximumLinearSpeed(WorldId worldId, float maximumLinearSpeed);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2World_SetPreSolveCallback", CallingConvention = CallingConvention.Cdecl)]
        public static extern void WorldSetPreSolveCallback(WorldId worldId, nint fcn, void* context);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2World_SetRestitutionCallback", CallingConvention = CallingConvention.Cdecl)]
        public static extern void WorldSetRestitutionCallback(WorldId worldId, nint callback);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2World_SetRestitutionThreshold", CallingConvention = CallingConvention.Cdecl)]
        public static extern void WorldSetRestitutionThreshold(WorldId worldId, float value);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2World_SetUserData", CallingConvention = CallingConvention.Cdecl)]
        public static extern void WorldSetUserData(WorldId worldId, void* userData);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2World_Step", CallingConvention = CallingConvention.Cdecl)]
        public static extern void WorldStep(WorldId worldId, float timeStep, int subStepCount);

        [DllImport(BindgenInternal.DllImportPath, EntryPoint = "b2Yield", CallingConvention = CallingConvention.Cdecl)]
        public static extern void Yield();

        public enum BodyType : uint
        {
            staticBody = 0,
            kinematicBody = 1,
            dynamicBody = 2,
            bodyTypeCount = 3
        }

        public enum JointType : uint
        {
            distanceJoint = 0,
            filterJoint = 1,
            motorJoint = 2,
            mouseJoint = 3,
            prismaticJoint = 4,
            revoluteJoint = 5,
            weldJoint = 6,
            wheelJoint = 7
        }

        public enum ShapeType : uint
        {
            circleShape = 0,
            capsuleShape = 1,
            segmentShape = 2,
            polygonShape = 3,
            chainSegmentShape = 4,
            shapeTypeCount = 5
        }

        public enum TOIState : uint
        {
            toiStateUnknown = 0,
            toiStateFailed = 1,
            toiStateOverlapped = 2,
            toiStateHit = 3,
            toiStateSeparated = 4
        }

        public struct Version
        {
            public int major;

            public int minor;

            public int revision;
        }

        public struct CosSin
        {
            public float cosine;

            public float sine;
        }

        public struct Mat22
        {
            public Vector2 cx;

            public Vector2 cy;
        }

        public struct Plane
        {
            public Vector2 normal;

            public float offset;
        }

        public struct SimplexCache
        {
            public ushort count;

            public InlineArrays.byte_3 indexA;

            public InlineArrays.byte_3 indexB;
        }

        public struct Hull
        {
            public InlineArrays.Vec2_8 points;

            public int count;
        }

        public struct RayCastInput
        {
            public Vector2 origin;

            public Vector2 translation;

            public float maxFraction;
        }

        public struct ShapeProxy
        {
            public InlineArrays.Vec2_8 points;

            public int count;

            public float radius;
        }

        public struct ShapeCastInput
        {
            public ShapeProxy proxy;

            public Vector2 translation;

            public float maxFraction;

            [MarshalAs(UnmanagedType.U1)]
            public bool canEncroach;
        }

        public struct CastOutput
        {
            public Vector2 normal;

            public Vector2 point;

            public float fraction;

            public int iterations;

            [MarshalAs(UnmanagedType.U1)]
            public bool hit;
        }

        public struct MassData
        {
            public float mass;

            public Vector2 center;

            public float rotationalInertia;
        }

        public struct Circle
        {
            public Vector2 center;

            public float radius;
        }

        public struct Capsule
        {
            public Vector2 center1;

            public Vector2 center2;

            public float radius;
        }

        public struct Polygon
        {
            public InlineArrays.Vec2_8 vertices;

            public InlineArrays.Vec2_8 normals;

            public Vector2 centroid;

            public float radius;

            public int count;
        }

        public struct Segment
        {
            public Vector2 point1;

            public Vector2 point2;
        }

        public struct ChainSegment
        {
            public Vector2 ghost1;

            public Segment segment;

            public Vector2 ghost2;

            public int chainId;
        }

        public struct SegmentDistanceResult
        {
            public Vector2 closest1;

            public Vector2 closest2;

            public float fraction1;

            public float fraction2;

            public float distanceSquared;
        }

        public struct DistanceInput
        {
            public ShapeProxy proxyA;

            public ShapeProxy proxyB;

            public Transform transformA;

            public Transform transformB;

            [MarshalAs(UnmanagedType.U1)]
            public bool useRadii;
        }

        public struct DistanceOutput
        {
            public Vector2 pointA;

            public Vector2 pointB;

            public Vector2 normal;

            public float distance;

            public int iterations;

            public int simplexCount;
        }

        public struct SimplexVertex
        {
            public Vector2 wA;

            public Vector2 wB;

            public Vector2 w;

            public float a;

            public int indexA;

            public int indexB;
        }

        public struct Simplex
        {
            public SimplexVertex v1;

            public SimplexVertex v2;

            public SimplexVertex v3;

            public int count;
        }

        public struct ShapeCastPairInput
        {
            public ShapeProxy proxyA;

            public ShapeProxy proxyB;

            public Transform transformA;

            public Transform transformB;

            public Vector2 translationB;

            public float maxFraction;

            [MarshalAs(UnmanagedType.U1)]
            public bool canEncroach;
        }

        public struct Sweep
        {
            public Vector2 localCenter;

            public Vector2 c1;

            public Vector2 c2;

            public Rotation q1;

            public Rotation q2;
        }

        public struct TOIInput
        {
            public ShapeProxy proxyA;

            public ShapeProxy proxyB;

            public Sweep sweepA;

            public Sweep sweepB;

            public float maxFraction;
        }

        public struct TOIOutput
        {
            public TOIState state;

            public float fraction;
        }

        public struct ManifoldPoint
        {
            public Vector2 point;

            public Vector2 anchorA;

            public Vector2 anchorB;

            public float separation;

            public float normalImpulse;

            public float tangentImpulse;

            public float totalNormalImpulse;

            public float normalVelocity;

            public ushort id;

            [MarshalAs(UnmanagedType.U1)]
            public bool persisted;
        }

        public struct Manifold
        {
            public Vector2 normal;

            public float rollingImpulse;

            public InlineArrays.ManifoldPoint_2 points;

            public int pointCount;
        }

        public struct DynamicTree
        {
            public TreeNode* nodes;

            public int root;

            public int nodeCount;

            public int nodeCapacity;

            public int freeList;

            public int proxyCount;

            public int* leafIndices;

            public AABB* leafBoxes;

            public Vector2* leafCenters;

            public int* binIndices;

            public int rebuildCapacity;
        }

        public struct TreeNode
        {
        }

        public struct TreeStats
        {
            public int nodeVisits;

            public int leafVisits;
        }

        public struct PlaneResult
        {
            public Plane plane;

            [MarshalAs(UnmanagedType.U1)]
            public bool hit;
        }

        public struct CollisionPlane
        {
            public Plane plane;

            public float pushLimit;

            public float push;

            [MarshalAs(UnmanagedType.U1)]
            public bool clipVelocity;
        }

        public struct PlaneSolverResult
        {
            public Vector2 position;

            public int iterationCount;
        }

        public struct WorldId
        {
            public ushort index1;

            public ushort generation;
        }

        public struct BodyId
        {
            public int index1;

            public ushort world0;

            public ushort generation;
        }

        public struct ShapeId
        {
            public int index1;

            public ushort world0;

            public ushort generation;
        }

        public struct ChainId
        {
            public int index1;

            public ushort world0;

            public ushort generation;
        }

        public struct JointId
        {
            public int index1;

            public ushort world0;

            public ushort generation;
        }

        public struct RayResult
        {
            public ShapeId shapeId;

            public Vector2 point;

            public Vector2 normal;

            public float fraction;

            public int nodeVisits;

            public int leafVisits;

            [MarshalAs(UnmanagedType.U1)]
            public bool hit;
        }

        public struct WorldDef
        {
            public Vector2 gravity;

            public float restitutionThreshold;

            public float hitEventThreshold;

            public float contactHertz;

            public float contactDampingRatio;

            public float maxContactPushSpeed;

            public float jointHertz;

            public float jointDampingRatio;

            public float maximumLinearSpeed;

            public nint frictionCallback;

            public nint restitutionCallback;

            [MarshalAs(UnmanagedType.U1)]
            public bool enableSleep;

            [MarshalAs(UnmanagedType.U1)]
            public bool enableContinuous;

            public int workerCount;

            public nint enqueueTask;

            public nint finishTask;

            public void* userTaskContext;

            public void* userData;

            public int internalValue;
        }

        public struct BodyDef
        {
            public BodyType type;

            public Vector2 position;

            public Rotation rotation;

            public Vector2 linearVelocity;

            public float angularVelocity;

            public float linearDamping;

            public float angularDamping;

            public float gravityScale;

            public float sleepThreshold;

            public byte* name;

            public void* userData;

            [MarshalAs(UnmanagedType.U1)]
            public bool enableSleep;

            [MarshalAs(UnmanagedType.U1)]
            public bool isAwake;

            [MarshalAs(UnmanagedType.U1)]
            public bool fixedRotation;

            [MarshalAs(UnmanagedType.U1)]
            public bool isBullet;

            [MarshalAs(UnmanagedType.U1)]
            public bool isEnabled;

            [MarshalAs(UnmanagedType.U1)]
            public bool allowFastRotation;

            public int internalValue;
        }

        public struct Filter
        {
            public ulong categoryBits;

            public ulong maskBits;

            public int groupIndex;
        }

        public struct QueryFilter
        {
            public ulong categoryBits;

            public ulong maskBits;
        }

        public struct SurfaceMaterial
        {
            public float friction;

            public float restitution;

            public float rollingResistance;

            public float tangentSpeed;

            public int userMaterialId;

            public uint customColor;
        }

        public struct ShapeDef
        {
            public void* userData;

            public SurfaceMaterial material;

            public float density;

            public Filter filter;

            [MarshalAs(UnmanagedType.U1)]
            public bool isSensor;

            [MarshalAs(UnmanagedType.U1)]
            public bool enableSensorEvents;

            [MarshalAs(UnmanagedType.U1)]
            public bool enableContactEvents;

            [MarshalAs(UnmanagedType.U1)]
            public bool enableHitEvents;

            [MarshalAs(UnmanagedType.U1)]
            public bool enablePreSolveEvents;

            [MarshalAs(UnmanagedType.U1)]
            public bool invokeContactCreation;

            [MarshalAs(UnmanagedType.U1)]
            public bool updateBodyMass;

            public int internalValue;
        }

        public struct ChainDef
        {
            public void* userData;

            public Vector2* points;

            public int count;

            public SurfaceMaterial* materials;

            public int materialCount;

            public Filter filter;

            [MarshalAs(UnmanagedType.U1)]
            public bool isLoop;

            [MarshalAs(UnmanagedType.U1)]
            public bool enableSensorEvents;

            public int internalValue;
        }

        public struct Profile
        {
            public float step;

            public float pairs;

            public float collide;

            public float solve;

            public float mergeIslands;

            public float prepareStages;

            public float solveConstraints;

            public float prepareConstraints;

            public float integrateVelocities;

            public float warmStart;

            public float solveImpulses;

            public float integratePositions;

            public float relaxImpulses;

            public float applyRestitution;

            public float storeImpulses;

            public float splitIslands;

            public float transforms;

            public float hitEvents;

            public float refit;

            public float bullets;

            public float sleepIslands;

            public float sensors;
        }

        public struct Counters
        {
            public int bodyCount;

            public int shapeCount;

            public int contactCount;

            public int jointCount;

            public int islandCount;

            public int stackUsed;

            public int staticTreeHeight;

            public int treeHeight;

            public int byteCount;

            public int taskCount;

            public InlineArrays.int_12 colorCounts;
        }

        public struct DistanceJointDef
        {
            public BodyId bodyIdA;

            public BodyId bodyIdB;

            public Vector2 localAnchorA;

            public Vector2 localAnchorB;

            public float length;

            [MarshalAs(UnmanagedType.U1)]
            public bool enableSpring;

            public float hertz;

            public float dampingRatio;

            [MarshalAs(UnmanagedType.U1)]
            public bool enableLimit;

            public float minLength;

            public float maxLength;

            [MarshalAs(UnmanagedType.U1)]
            public bool enableMotor;

            public float maxMotorForce;

            public float motorSpeed;

            [MarshalAs(UnmanagedType.U1)]
            public bool collideConnected;

            public void* userData;

            public int internalValue;
        }

        public struct MotorJointDef
        {
            public BodyId bodyIdA;

            public BodyId bodyIdB;

            public Vector2 linearOffset;

            public float angularOffset;

            public float maxForce;

            public float maxTorque;

            public float correctionFactor;

            [MarshalAs(UnmanagedType.U1)]
            public bool collideConnected;

            public void* userData;

            public int internalValue;
        }

        public struct MouseJointDef
        {
            public BodyId bodyIdA;

            public BodyId bodyIdB;

            public Vector2 target;

            public float hertz;

            public float dampingRatio;

            public float maxForce;

            [MarshalAs(UnmanagedType.U1)]
            public bool collideConnected;

            public void* userData;

            public int internalValue;
        }

        public struct FilterJointDef
        {
            public BodyId bodyIdA;

            public BodyId bodyIdB;

            public void* userData;

            public int internalValue;
        }

        public struct PrismaticJointDef
        {
            public BodyId bodyIdA;

            public BodyId bodyIdB;

            public Vector2 localAnchorA;

            public Vector2 localAnchorB;

            public Vector2 localAxisA;

            public float referenceAngle;

            [MarshalAs(UnmanagedType.U1)]
            public bool enableSpring;

            public float hertz;

            public float dampingRatio;

            [MarshalAs(UnmanagedType.U1)]
            public bool enableLimit;

            public float lowerTranslation;

            public float upperTranslation;

            [MarshalAs(UnmanagedType.U1)]
            public bool enableMotor;

            public float maxMotorForce;

            public float motorSpeed;

            [MarshalAs(UnmanagedType.U1)]
            public bool collideConnected;

            public void* userData;

            public int internalValue;
        }

        public struct RevoluteJointDef
        {
            public BodyId bodyIdA;

            public BodyId bodyIdB;

            public Vector2 localAnchorA;

            public Vector2 localAnchorB;

            public float referenceAngle;

            [MarshalAs(UnmanagedType.U1)]
            public bool enableSpring;

            public float hertz;

            public float dampingRatio;

            [MarshalAs(UnmanagedType.U1)]
            public bool enableLimit;

            public float lowerAngle;

            public float upperAngle;

            [MarshalAs(UnmanagedType.U1)]
            public bool enableMotor;

            public float maxMotorTorque;

            public float motorSpeed;

            public float drawSize;

            [MarshalAs(UnmanagedType.U1)]
            public bool collideConnected;

            public void* userData;

            public int internalValue;
        }

        public struct WeldJointDef
        {
            public BodyId bodyIdA;

            public BodyId bodyIdB;

            public Vector2 localAnchorA;

            public Vector2 localAnchorB;

            public float referenceAngle;

            public float linearHertz;

            public float angularHertz;

            public float linearDampingRatio;

            public float angularDampingRatio;

            [MarshalAs(UnmanagedType.U1)]
            public bool collideConnected;

            public void* userData;

            public int internalValue;
        }

        public struct WheelJointDef
        {
            public BodyId bodyIdA;

            public BodyId bodyIdB;

            public Vector2 localAnchorA;

            public Vector2 localAnchorB;

            public Vector2 localAxisA;

            [MarshalAs(UnmanagedType.U1)]
            public bool enableSpring;

            public float hertz;

            public float dampingRatio;

            [MarshalAs(UnmanagedType.U1)]
            public bool enableLimit;

            public float lowerTranslation;

            public float upperTranslation;

            [MarshalAs(UnmanagedType.U1)]
            public bool enableMotor;

            public float maxMotorTorque;

            public float motorSpeed;

            [MarshalAs(UnmanagedType.U1)]
            public bool collideConnected;

            public void* userData;

            public int internalValue;
        }

        public struct ExplosionDef
        {
            public ulong maskBits;

            public Vector2 position;

            public float radius;

            public float falloff;

            public float impulsePerLength;
        }

        public struct SensorBeginTouchEvent
        {
            public ShapeId sensorShapeId;

            public ShapeId visitorShapeId;
        }

        public struct SensorEndTouchEvent
        {
            public ShapeId sensorShapeId;

            public ShapeId visitorShapeId;
        }

        public struct SensorEvents
        {
            public SensorBeginTouchEvent* beginEvents;

            public SensorEndTouchEvent* endEvents;

            public int beginCount;

            public int endCount;
        }

        public struct ContactBeginTouchEvent
        {
            public ShapeId shapeIdA;

            public ShapeId shapeIdB;

            public Manifold manifold;
        }

        public struct ContactEndTouchEvent
        {
            public ShapeId shapeIdA;

            public ShapeId shapeIdB;
        }

        public struct ContactHitEvent
        {
            public ShapeId shapeIdA;

            public ShapeId shapeIdB;

            public Vector2 point;

            public Vector2 normal;

            public float approachSpeed;
        }

        public struct ContactEvents
        {
            public ContactBeginTouchEvent* beginEvents;

            public ContactEndTouchEvent* endEvents;

            public ContactHitEvent* hitEvents;

            public int beginCount;

            public int endCount;

            public int hitCount;
        }

        public struct BodyMoveEvent
        {
            public Transform transform;

            public BodyId bodyId;

            public void* userData;

            [MarshalAs(UnmanagedType.U1)]
            public bool fellAsleep;
        }

        public struct BodyEvents
        {
            public BodyMoveEvent* moveEvents;

            public int moveCount;
        }

        public struct ContactData
        {
            public ShapeId shapeIdA;

            public ShapeId shapeIdB;

            public Manifold manifold;
        }

        public partial struct InlineArrays
        {
            [InlineArray(8)]
            public struct Vec2_8
            {
                public Vector2 Item0;
            }
        }

        public partial struct InlineArrays
        {
            [InlineArray(3)]
            public struct byte_3
            {
                public byte Item0;
            }
        }

        public partial struct InlineArrays
        {
            [InlineArray(2)]
            public struct ManifoldPoint_2
            {
                public ManifoldPoint Item0;
            }
        }

        public partial struct InlineArrays
        {
            [InlineArray(12)]
            public struct int_12
            {
                public int Item0;
            }
        }

        public const int B2_DEFAULT_CATEGORY_BITS = 1;

        public const ulong B2_DEFAULT_MASK_BITS = 18446744073709551615;

        public const int B2_HASH_INIT = 5381;

        public const int B2_MAX_POLYGON_VERTICES = 8;

        public const float B2_PI = 3.1415927f;
    }
}